Programming

Привет, хабровчане. Для будущих студентов курса "C++ Developer. Professional" Александр Колесников подготовил статью.

Приглашаем также посмотреть открытый вебинар на тему Области видимости и невидимости. За 1,5 часа участники вместе с экспертом успеют реализовать класс общего назначения и запустить несколько unit-тестов с использованием googletest. Присоединяйтесь.

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

Сегодня язык программирования С++ существует в нескольких параллельных реальностях: C++98, C++11, C++14, C++17, C++20. Существует как минимум один источник, где можно немного разобраться со всем этим набором мультивселенных. Однако, когда дело дойдет до написания кода использования stackOverflow, вопрос а точно эта строка написана безопасно", будет мучать разработчика из релиза в релиз. Кстати, на момент написания статьи готовится новый стандарт С++23 =).

Откуда проблемы

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

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

• неверное объявление типов данных;

• неверное использование выражений;

• неправильная обработка целочисленных данных;

• неправильная работа с контейнерами;

• неправильная работа со строками;

• неправильная работа с памятью;

• неверная обработка exception;

• пренебрежение ограничениями OOP;

• состояния гонки при обработке ресурсов мультипоточным приложением;

• прочие проблемы, о которых мало, где сказано.

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

Разберем несколько примеров.

String Format

void check_password(const char *user) {  int ret;  //  static const char format[] = "%s wrong pass.\n";  size_t messageLength = strlen(user) + sizeof(msg_format);  char *data = (char *)malloc(messageLength); // <- так же не очень безопасный вариант  if (data == NULL) {    //Код для ошибки  }  ret = snprintf(data, messageLength, format, user);  if (ret < 0) {     //Код для ошибки  } else if (ret >= messageLength) {     //Последний шанс обработать некорректные данные  }  syslog(LOG_INFO, msg);  free(msg);}

В чем проблема? Данные, которые используются для создания строки, контролируются пользователем. Передача других спец символов (%n, %x) и использование строк больших размеров может вывести из строя приложение.

Integer overflow

Данная проблема головная боль любого ПО, которое работает с накапливаемыми данными. Какого размера переменные использовать, чтобы оптимально хранить данные и одновременно сделать запас для приложения, если если оно будет использоваться месяцами без перезапуска? В некоторых случаях ответить однозначно на этот вопрос нельзя, поэтому программист, ориентируясь на собственный опыт, волевым решением пишет uint16_t. Но данных оказывается больше 65,535 и тут случается чудо значение переменной становится равно нулю и отсчет идёт заново. Пример кода:

...user->nameLength = getUserNameLength(&user->name) ;user->newDbCellLen = malloc(user->nameLength * sizeof(uint8_t))...

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

...int16_t checkLen(uint16_t firstNumber, uint16_t secondNumber){    uint16_t resultLength;    if (UINT_MAX - firstNumber < secondNumber)     {        //ошибка        return -1;    }    else    {        resultLength = firstNumber + secondNumber;    }    return resultLength;}

Преобразование типов

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

...unsigned int number = (unsigned int)ptr;number = (number & 0x7fffff) | (flag << 23);ptr = (char *)number;...

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

Выводы

Как видно из примеров в статье, С++ это язык, в котором нужно внимательно относиться к кажущимся мелочам, начиная от форматов данных и заканчивая типами переменных. Где брать примеры? Что делать с уязвимостями? К сожалению, универсального ответа нет, но можно постоянно работать и накапливать знания о языке и его особенностях. Начать можно здесь или здесь. Так же нужно использовать плагины и приложения, которые позволяют анализировать код на этапе сборки. Можно в этом случае ориентироваться на продукты вроде этого или этого.

Узнать подробнее о курсе "C++ Developer. Professional".

Смотреть открытый вебинар на тему Области видимости и невидимости.

Предыдущие статьи:

• раз: ESPboy гаджет для ретро игр и экспериментов с IoT

• два: Часть 2: Mодули и AppStore. ESPboy гаджет для ретро игр и экспериментов с IoT

В основе лежит старенький уже на сегодня чип ESP8266 c WiFi с подключенными к нему цветным экраном 128х128, кнопками, динамиком, RGB светодиодом и еще парой удобных дополнений.

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

В ESPboy есть слот расширения, на который выведены интерфейсы I2C, SPI, UART, I2S куда втыкаются штатные модули, которые при загрузке соответствующего софта превращают устройство в ретро игровую консоль, GSM телефон, GPS навигатор, FM радио, перехватчик радиопакетов, читалку/писалку rfid/nfc, MP3 плеер, погодную станцию, универсальный ИК пульт, LORA мессенджер и много чего еще.

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

Список опробованных модулей можно увидеть на сайте проекта www.espboy.com, весь софт, как уже говорилось, на GitHub для изучения и экспериментов. Много чего в работе и еще больше в планах. К сожалению не удалось поспеть в прошлом году довести модули до промышленного изготовления, все они в виде прототипов, но энтузиасты с помощью сообщества в проектном форуме и Discord чате собирают при желании любой без сложностей. Думаю, что в этом году часть модулей все же получится выпустить в заводском исполнении.

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

• Работает сайт, а также форум и Discord чат, где идеями и достижениями делятся друг с другом международное комьюнити.

• Устройства продаются на tindie.com во все концы света, а любители самостоятельно паять по открытым схемам собирают полнофункциональные самоделки ESPboy и модулей к ним.

• По предварительной оценке, активных устройств на сегодня штук 400 и их число растет.

• Работает онлайн ESPboy AppStore и улучшенный AppStore2 в экспериментальном режиме, куда, судя по статистике, за последние полгода пришло более 5000 тысяч запросов на загрузку приложений.

• Разработана и протестирована вторая версия девайса -- ESPboy2 в более компактном исполнении, симпатичном корпусе, единым USB и прочими мелкими улучшениями. При этом сохранилась полная совместимость с классическим ESPboy. В новом исполнении устройство выглядит более законченным и приятным для использования людьми, далеким от DIY.

• Портировано около сотни игр c платформы Arduboy и написано около десятка новых игр на Little Game Engine, улучшен эмулятор ZX Spectrum 48k и CHIP8/SCHIP, добавлен звук в эмулятор GameBoy

• Портирован думообразный свободно распространяемый 3Д шутер - Anarch

• Написан разнообразный полезный софт

  • WiFi analyzer

  • WiFi sniffer

  • WiFi packet monitor

  • WiFi deauther

  • Пинговщик

  • I2C scanner

  • UART terminal

  • RSS reader

  • Рожицы COZMO в качестве прикола и демонстрации использования в робото-проектах

  • Игры из библиотеки ESPpert

  • Игры проекта tinyjoypad.com

  • Порт известного в ZX Spectrum кругах музыкального однобитного движка Phaser1

  • и кое-что по мелочи

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

  • Дозиметр

  • Пульсометр

  • Каордиограф

  • Цифровой термометр диапазона -40-120С

  • Электронная рулетка

  • Сниффер и грабер радиосигналов Sub1Ghz Inspector

  • Универсальный ИК пульт

  • Bluetooth link (тестировался на мультиплеерной версии 3Д шутера Catacombs of the damned, портированного с Arduboy)

  • Генератор сигналов разной формы и частоты

• Переработан и улучшен софт прошлого года

  • GSM телефон

  • GPS навигатор

  • LORA пейджер

  • RFID/NFC читалка-писалка

В разработке еще с десяток модулей, которые неспешно собираются и тестируются.

Уже есть задумки по ESPboy3.

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

Заглядываясь на кикстартер успех FLIPPER ZERO, тоже посещают мысли о запуске компании на Kickstarter. Но такой разворот требует значительных усилий в сторону маркетинга, продаж, что далее неизбежно повлечет за собой масштабирование производства, логистики, поддержки, переход на новый уровень R&D и управление процессами в целом. Бросаться в такой омут очертя голову не охота. Хочется делать основательно, а в этом случае уже нужны заинтересованные люди, понимающие в бизнесе и инвестиции.

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

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

Да и просто поиграться с устройством в современные технологии довольно увлекательно и познавательно.

• Сайт проекта: www.espboy.com

• Лог проекта на hackaday.com https://hackaday.io/project/164830-espboy-the-ultimate-multi-gadget

• Предзаказ ESPboy2 https://forms.gle/nNGewLwkSyeA4K9L8

• Чат проекта в Discord: https://discord.gg/9HY4w2Y

• Фоум проекта: http://community.espboy.com

• YouTube: https://www.youtube.com/c/ESPboy/videos

• Софт: https://github.com/ESPboy-edu

• Схемы и плата ESPboy: https://easyeda.com/ESPboy/espboy_pcb_v3-82

• Tindie.com: https://www.tindie.com/products/18194/

Всем добра!

С уважением, РоманС

mailto: espboy.edu@gmail.com

Для будущих студентов курса "JavaScript Developer. Basic" подготовили перевод материала.

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

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

Ознакомившись с этой статьей, вы поймете:

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

• как использовать редактор Visual Studio Code, чтобы обойтись без Babel.

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

Что такое Babel и какую проблему он решает?

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

По мере развития браузеров добавляются новые функции API и ECMAScript. Различные браузеры развиваются с разной скоростью и расставляют акценты в качестве приоритетных для разных задач. Это ставит нас перед непростым выбором: как мы можем их все поддерживать и при этом использовать современные функции? Некоторые из них будут несовместимы.

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

Разница между транспилированием (transpiling) и полифилингом (polyfilling)

Транспилирование (Transpiling) это процесс преобразования синтаксиса нового языка, который старые браузеры не могут понять, в старый синтаксис, который они распознают.

Приведем пример переноса оператора let:

// the new syntax `let` was added in ECMAScript 2015 aka ES6let x = 11;// `let` transpiles to the old syntax `var` if your transpiler target was ES5var x = 11;

Полифилинг (Polyfilling) это процесс добавления недостающих методов, свойств или API к старым браузерам путем предоставления собственной версии недостающего родного кода.

Это можно рассматривать как дополнение недостающих элементов. Например, вот полифил (polyfill) для isNaN:

// check if the method `isNaN` exists on the standard built-in `Number` objectif (!Number.isNaN) {  // if not we add our own version of the native method newer browsers provide  Number.isNaN = function isNaN(x) {    return x !== x;  };}

Наилучшим способом для получения полифилов является использование core-js.

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

Альтернатива 1: не поддерживать древние браузеры

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

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

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

Чтобы определить, нужно ли поддерживать определенный браузер, задайте себе следующие вопросы.

1. Какие браузеры в настоящее время используют Ваши клиенты?

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

Если у вас не установлено аналитическое программное обеспечение, вы не будете знать, какие браузеры вам нужно поддерживать. Вы должны будете сделать обоснованное предположение. Если у вас есть корпоративные клиенты, гораздо больше шансов, что вам понадобится поддержка IE11 (Internet Explorer 11), чем если бы вы занимались маркетингом для фанатов web-literate (грамотное программирование) технологий.

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

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

2. Какие современные функции браузера вы хотите использовать?

Использование современных функций языка и API (Application Programming Interfaces) браузера делает написание кода проще, быстрее и интереснее. Это также делает ваш код более удобным в обслуживании.

Если вам нравиться писать ES5 (ECMAScript) и использовать XMLHttpRequest(), тогда определенно не нужен Babel, но может потребоваться какая-нибудь специальная процедура.

3. Какие современные функции браузера поддерживают браузеры ваших клиентов?

Эти данные доступны через Can I use (могу ли я использовать), но это напрасная трата времени на их поиск вручную. Теперь, когда вы знаете названия браузеров, которые вы хотите поддерживать, поиск совместимых функций может быть автоматизирован с помощью удивительного приложения Browserlist (подробнее об этом в следующем разделе).

Альтернатива 2: Используйте eslint-plugin-compat

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

• исключает любую зависимость от транспилиров (transpilers). Возвращает вам практический контроль над рабочим кодом.

• если имеется современная функция, без которой вы не можете жить, то ее можно использовать применив полифил (polyfill).

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

Создать тест

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

Ниже приведен современный код, который должна поддерживать наша целевая среда после переноса (transpiled).

После переноса (transportation) для каждой функции есть console.assert (метод записи сообщений на консоли для пользователя), чтобы убедиться, что она работает, как положено. В случае eslint-plugin-compat вместо этого проверим, что несовместимый код помечен в linting (Linting это процесс, выполняемый программой linter, которая анализирует исходный код на определенном языке программирования и отмечает потенциальные проблемы, такие как синтаксические ошибки, отклонения от предписанного стиля кодирования или использование конструкций, о которых известно, что они небезопасны).

test.js

// test nullish coalescing - return right side when left side null or undefinedconst x = null ?? "default string";console.assert(x === "default string");const y = 0 ?? 42;console.assert(y === 0);// test optional chaining - return undefined on non existent property or methodconst adventurer = {  name: "Alice",  cat: {    name: "Dinah",  },};const dogName = adventurer.dog?.name;console.assert(dogName === undefined);console.assert(adventurer.someNonExistentMethod?.() === undefined);// use browser API fetch, to check lintingfetch("https://jsonplaceholder.typicode.com/todos/1")  .then((response) => response.json())  .then((json) => console.log(json));

Использование eslint env свойства с помощью eslint-plugin-compat

Нам нужен обходной путь для объединения функций языка и API браузера.

Вы можете использовать eslint (Eslint это утилита, проверяющая стандарты кодирования на JavaScript) для проверки синтаксиса языка. Для этого измените свойство env наes2020.

Для проверки совместимости API браузера используйте eslint-plugin-compat. Он использует ту же самую конфигурацию Browserlist и остальные инструменты, что и Babel.

Полную инструкцию можно найти в eslint-plugin-compat repo. Мы воспользуемся browserlist defaults как предустановками по умолчанию. Замените их по своему выбору, основанному на аналитике.

Что такое browserlist?

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

Посмотрите список браузеров, поддерживаемых defaults для browserlist.

defaults использует быстрый доступ к таким версиям браузеров:

• > 0,5 процента (версии браузеров, выбранные по глобальной статистике использования)

• Последние две версии (каждого "живого (not dead)" браузера)

• Firefox ESR (Extended Support Release)

• Живые (not dead) (браузеры без официальной поддержки и обновлений в течение 24 месяцев).

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

Настройка eslint-plugin-compat для Visual Studio Code

Добавьте следующие пакеты в свой проект.

npm install --save-dev eslint eslint-plugin-compat

Добавьте следующее в package.json.

"browserslist": [    "defaults"  ]

Создайте следующий файл .eslintrc.json или добавьте эти настройки к существующим.

{  "extends": ["plugin:compat/recommended"],  "env": {    "browser": true,    "es2020": true  }}

Убедитесь, что у вас установлено расширение VS Code ESLint.

Теперь любой API браузера, несовместимый с конфигурацией browserlistв вашем package.json, отображается как ошибка linting. Вы можете отдельно контролировать, какую версию ECMAScript вы хотите поддержать, используя свойство env в файле .eslintrc.json.

Было бы неплохо, если бы eslint-plugin-compat автоматически добавил и возможности языка, но на данный момент это является нерешённой задачей.

IE 11 с выбранной настройкой

наш API fetch() помечен.

Поменяйте объект env на es6.

Вы сразу же увидите ошибку при попытке использовать nullish coalescing, который был запущен в составе Es2020.

Альтернатива 3: Используйте другое программное обеспечение для замены Babel

Прежде чем рассматривать альтернативы, давайте быстро рассмотрим, как использовать Babel.

Использование Babel для транспилирования (transpile) и полифилинга (polyfill)

Сначала создайте директорию мини-проекта и установите нужные нам взаимосвязи.

mkdir babel-testcd babel-testnpm init -ymkdir src distnpm install --save-dev @babel/core @babel/cli @babel/preset-envnpm install --save @babel/polyfill

Добавьте следующее в свой package.json.

"browserslist": "defaults",

Запишите файл test.js вsrc, а затем выполните следующую команду.

npx babel src --out-dir dist --presets=@babel/env

Наконец, запустите файл, чтобы проверить, что тесты все еще работают.

node dist/test.js

Ошибок ввода не должно быть, но будет сказано, что fetch is not defined, так как в Node.js нет метода fetch().

Вот результирующий транспилированный (transpiled) код. Обратите внимание на весь лишний мусор и хлам.

"use strict";var _ref, _, _adventurer$dog, _adventurer$someNonEx;// test nullish coalescing - return right side when left side null or undefinedvar x = (_ref = null) !== null && _ref !== void 0 ? _ref : "default string";console.assert(x === "default string");var y = (_ = 0) !== null && _ !== void 0 ? _ : 42;console.assert(y === 0); // test optional chaining - return undefined on non existent property or methodvar adventurer = {  name: "Alice",  cat: {    name: "Dinah",  },};var dogName =  (_adventurer$dog = adventurer.dog) === null || _adventurer$dog === void 0    ? void 0    : _adventurer$dog.name;console.assert(dogName === undefined);console.assert(  ((_adventurer$someNonEx = adventurer.someNonExistentMethod) === null ||  _adventurer$someNonEx === void 0    ? void 0    : _adventurer$someNonEx.call(adventurer)) === undefined,); // use browser API fetch, to check lintingfetch("https://jsonplaceholder.typicode.com/todos/1")  .then(function (response) {    return response.json();  })  .then(function (json) {    return console.log(json);  });

Преимущества и недостатки использования Babel

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

• Эта базовая установка была относительно несложной.

• У Babel есть большое сообщество для поддержки и постоянных обновлений с 36.8k GitHub звездами на момент написания статьи.

Недостатки:

• Медленное время компиляции

• Множество зависимостей (dependencies), даже если они являются зависимостями (dev-dependencies). (установлено 269 пакетов)

• 39М использованного дискового пространства, как сообщает du -sh

• 5728 установленных файлов, о чем сообщает find . -тип f | wc -l

Использование swc для транспилирования (transpile) и полифилинга (polyfill)

Swc новый конкурент Babel. Он написан на языке программирования Rust и в 20 раз быстрее. Это может быть очень важно, если вы долго ждете, чтобы построить свой проект.

Чтобы все устроить:

mkdir swc-testcd swc-testnpm init -ymkdir src distnpm install --save-dev @swc/cli @swc/core browserslist

Добавьте следующее в свой package.json.

"browserslist": "defaults",

Запишите конфигурационный файл .swcrc в корневую директорию проекта.

{  "env": {    "coreJs": 3  },  "jsc": {    "parser": {      "syntax": "ecmascript"    }  }}

Запишите ваш тестовый файл в src, затем выполните следующую команду для переноса (transpile).

npx swc src -d dist

Запустите полученный файл, чтобы проверить, что тесты все еще работают.

node dist/test.js

В итоге swc-transpiled (транспилированный) файл, выглядит вот так:

var ref, ref1;var ref2;// test nullish coalescing - return right side when left side null or undefinedvar x = (ref2 = null) !== null && ref2 !== void 0 ? ref2 : "default string";console.assert(x === "default string");var ref3;var y = (ref3 = 0) !== null && ref3 !== void 0 ? ref3 : 42;console.assert(y === 0);// test optional chaining - return undefined on non existent property or methodvar adventurer = {  name: "Alice",  cat: {    name: "Dinah",  },};var dogName =  (ref = adventurer.dog) === null || ref === void 0 ? void 0 : ref.name;console.assert(dogName === undefined);console.assert(  ((ref1 = adventurer.someNonExistentMethod) === null || ref1 === void 0    ? void 0    : ref1.call(ref1)) === undefined,);// use browser API fetch, to check lintingfetch("https://jsonplaceholder.typicode.com/todos/1")  .then(function (response) {    return response.json();  })  .then(function (json) {    return console.log(json);  });

Преимущества и недостатки использования swc

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

• swc намного быстрее

• Гораздо меньше зависимостей (установлено 43 пакета)

Недостатки:

• Не все функции Babel в настоящее время поддерживаются

• Меньшая пользовательская база и количество постоянных участников

Другие альтернативы: Google Closure Compiler и TypeScript

Я не включил Google Closure Compiler в качестве опции, потому что он, как это ни печально, сложен в использовании. Тем не менее, он может сделать хорошую работу по транспилированию (transpile) и полифилингу (polyfill). Если у вас есть свободное время, я рекомендую вам проверить его особенно если вы цените небольшой размер файла, так как встроенная функция минификации демонстрирует отличные результаты.

Вы также можете использовать TypeScript для переноса (transpile) и core-js для ручной полифил (polyfill) обработки, но это неуклюжее решение, которое может с легкостью создать больше проблем, чем решить их.

Заключение

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

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

Если вы выберете автоматический перевод, то SWC будет намного быстрее, чем Babel, и будет содержать гораздо меньше зависимостей. Также есть возможность использовать Google Closure Compiler или TypeScript, но для их настройки потребуется немного больше усилий.

LogRocket: Полная видимость ваших веб-приложений

LogRocket это передовое решение для мониторинга приложений, позволяющее воспроизводить проблемы так, как если бы они возникали в вашем собственном браузере. Вместо того, чтобы гадать, почему происходят ошибки, или спрашивать пользователей на скриншотах и дампах логов, LogRocket позволяет воспроизводить сеанс, чтобы быстро понять, что пошло не так. Он отлично работает с любым приложением, независимо от фреймворка, и имеет плагины для записи дополнительного контекста из Redux, Vuex и @ngrx/store.

В дополнение к регистрации действий и состояния Redux, LogRocket записывает журналы консольных сообщений, ошибки JavaScript, следы стеков, сетевые запросы/ответы в формате заголовок + тело, метаданные браузера и пользовательские журналы. Кроме того при помощи DOM (Document Object Model) позволяет записывать страницы HTML и CSS, воссоздавая превосходные в пиксельном отношении видео даже для самых сложных одностраничных приложений.

Узнать подробнее о курсе "JavaScript Developer. Basic".

Смотреть открытый вебинар Код как проект настройка окружения для разработки на JavaScript.

Перевод статьи подготовлен в преддверии старта курсаBackend-разработчик на PHP.

Шпаргалка по изменениям в PHP v7.x

После релиза PHP версии 7.3 я решил уделить больше внимания развитию PHP: что собственно развивается и в каком направлении искать понимание потенциала и оптимизации этого невероятно популярного языка программирования.

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

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

PHP 7.0

Поддержка анонимных классов

Анонимный класс может использоваться вместо именованного класса:

• Когда класс не нужно документировать

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

new class($i) {   public function __construct($i) {       $this->i = $i;   }}

Функция целочисленного деления - безопасный способ деления (даже на 0).

Возвращает целочисленный результат деления первого операнда на второй. Если делитель (второй операнд) равен нулю, функция пробрасывает EWARNING и возвращает FALSE.

intdiv(int $numerator, int $divisor)

Добавлен новый оператор объединения с null - ??

$x = NULL;$y = NULL;$z = 3;vardump($x ?? $y ?? $z); // int(3)$x = ["c" => "meaningfulvalue"];vardump($x["a"] ?? $x["b"] ?? $x["c"]); // string(16) "meaningfulvalue"

Добавлен новый оператор - spaceship (космический корабль)(<=>)

Используется для оптимизации и упрощения операций сравнения.

// Преждеf unction orderfunc($a, $b) {return ($a < $b) ? -1 : (($a > $b) ? 1 : 0);}// Используя оператор <=>function orderfunc($a, $b) {return $a <=> $b;}

Объявления скалярных типов

Это всего лишь первый шаг к реализации преимуществ более строго типизированного языка программирования в PHP - v0.5.

function add(float $a, float $b): float {return $a + $b;}add(1, 2); // float(3)

Объявления типов возвращаемых значений

Добавлена возможность возвращать типы помимо скалярных - классы, включая наследование. Хех, упустив при этом возможность сделать это необязательным (что будет введено в v7.1 :))

interface A {static function make(): A;}class B implements A {static function make(): A {return new B();}}

Групповые объявления use

// Явный use синтаксис:use FooLibrary\Bar\Baz\ClassA;use FooLibrary\Bar\Baz\ClassB;use FooLibrary\Bar\Baz\ClassC;use FooLibrary\Bar\Baz\ClassD as Fizbo;// Групповой use синтаксис:use FooLibrary\Bar\Baz{ ClassA, ClassB, ClassC, ClassD as Fizbo };

Делегация генератора

В теле функций генераторов разрешен следующий новый синтаксис:

yield from <expr>

Повышение производительности

PHP 7 почти вдвое быстрее, чем PHP 5.6.

Значительное сокращение использования памяти

Как видно из диаграмм, PHP 7.0 стал громадным шагом вперед с точки зрения производительности и использования памяти. Для страницы с запросами к базе данных версия 7.0.0 более чем в 3 раза быстрее, чем 5.6 с включенным opcache в 2.7 раза быстрее без opcache! С точки зрения использования памяти разница тоже существенная!

Интерфейс Throwable

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

Error и Exception теперь реализуют Throwable.

Иерархия Throwable:

interface Throwable|- Error implements Throwable|- ArithmeticError extends Error|- DivisionByZeroError extends ArithmeticError|- AssertionError extends Error|- ParseError extends Error|- TypeError extends Error|- ArgumentCountError extends TypeError|- Exception implements Throwable|- ClosedGeneratorException extends Exception|- DOMException extends Exception|- ErrorException extends Exception|- IntlException extends Exception|- LogicException extends Exception|- BadFunctionCallException extends LogicException|- BadMethodCallException extends BadFunctionCallException|- DomainException extends LogicException|- InvalidArgumentException extends LogicException|- LengthException extends LogicException|- OutOfRangeException extends LogicException|- PharException extends Exception|- ReflectionException extends Exception|- RuntimeException extends Exception|- OutOfBoundsException extends RuntimeException|- OverflowException extends RuntimeException|- PDOException extends RuntimeException|- RangeException extends RuntimeException|- UnderflowException extends RuntimeException|- UnexpectedValueException extends RuntimeException

Внимание! Вы можете реализовать Throwable только через Error и Exception.

Синтаксис кодирования Unicode \u{xxxxx}

echo "\u{202E}Reversed text"; // выводит Reversed textecho "maana"; // "ma\u{00F1}ana"echo "maana"; // "man\u{0303}ana" "n" комбинирована с символом ~ (U+0303)

Чувствительный к контексту лексер

С этим нововведением глобально зарезервированные словами стала полу-зарезервированными:

callable class trait extends implements static abstract final public protected private constenddeclare endfor endforeach endif endwhile and global goto instanceof insteadof interfacenamespace new or xor try use var exit list clone include includeonce throw arrayprint echo require requireonce return else elseif default break continue switch yieldfunction if endswitch finally for foreach declare case do while as catch die self parent

За исключением того, что по-прежнему запрещено определять константу класса с именем class из-за разрешения имени класса ::class.

Выражения return в генераторах

Единый синтаксис переменных

Поддержка уровня вложенности для функции dirname()

PHP 7.1

Обнуляемые типы

function answer(): ?int {return null; // ок}function answer(): ?int {return 42; // ок}function answer(): ?int {return new stdclass(); // ошибка}function say(?string $msg) {if ($msg) {echo $msg;}}say('hello'); // ок - выводит hellosay(null); // ок - ничего не выводитsay(); // ошибка - отсутствует параметрsay(new stdclass); // ошибка - не подходящий тип

Ничего не возвращающие функции

function shouldreturnnothing(): void {return 1; // Fatal error: A void function must not return a value}

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

Функция с типом возврата void или void функция может либо возвращать неявно, либо иметь оператор возврата без значения:

function lacksreturn(): void {// валидно}

Псевдотип Iterable

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

function foo(iterable $iterable) {foreach ($iterable as $value) {// }}

iterable также может использоваться в качестве возвращаемого типа, чтобы указать, что функция вернет итерируемое значение. Если возвращаемое значение не является массивом или экземпляром Traversable, будет проброшена TypeError.

function bar(): iterable {return [1, 2, 3];}

Параметры, объявленные как iterable могут использовать null или массив в качестве значения по умолчанию.

function foo(iterable $iterable = []) {// }

Closure из callable

class Closure {public static function fromCallable(callable $callable) : Closure {}}

Синтаксис квадратных скобок для деструктуририрующего присваивания в массиве

$array = [1, 2, 3];// Присваивает $a, $b и $c значения соответствующих элементов массива $array с ключами, пронумерованными от нуля[$a, $b, $c] = $array;// Присваивает $a, $b и $c значения элементов массива $array с ключами "a", "b" и "c" соответственно["a" => $a, "b" => $b, "c" => $c] = $array;

Синтаксис квадратных скобок для list()

$powersOfTwo = [1 => 2, 2 => 4, 3 => 8];list(1 => $oneBit, 2 => $twoBit, 3 => $threeBit) = $powersOfTwo;

Видимость констант класса

class Token {    // Константы по умолчанию public   const PUBLICCONST = 0;// Константы также могут иметь определенную пользователем видимостьprivate const PRIVATECONST = 0;protected const PROTECTEDCONST = 0;public const PUBLICCONSTTWO = 0;// Константы могут иметь только один список объявлений видимостиprivate const FOO = 1, BAR = 2;}

Перехват нескольких типов исключений

try {// Какой-то код} catch (ExceptionType1 | ExceptionType2 $e) {// Код обработки исключения} catch (\Exception $e) {// }

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

Читать ещё:

• Сделайте свое приложение масштабируемым, оптимизировав производительность ORM

Перевод статьи подготовлен в преддверии старта курсаBackend-разработчик на PHP

(Читать первую часть)

PHP 7.2

Расширение типа параметра

<?phpclass ArrayClass {public function foo(array $foo) { /*  / }}// Этот RFC предлагает разрешить расширение типа до нетипизированного, т.е. в качестве параметра может быть передан любой тип.// Любые ограничения типа могут быть отработаны с помощью пользовательского кода в теле метода.class EverythingClass extends ArrayClass {public function foo($foo) { /  / }}

Подсчет неисчислимых объектов

Вызов функции count() для скаляра или объекта, который не реализует интерфейс Countable возвращает 1 (что нелогично).

В этой версии добавлено предупреждение при вызове count() с параметром, который является скаляром, null или объектом, который не реализует Countable.

Завершающие запятые в групповом use синтаксисе

use Foo\Bar{ Foo, Bar, Baz, };

Хеширование пароля с помощью Argon2

Существующие функции password_* обеспечивают упрощенный интерфейс с прямой совместимостью для хеширования паролей. Этот RFC предлагает для использования в функциях password_* реализацию Argon2i (v1.3) в качестве безопасной альтернативы.

Отладка эмуляции подготовленного запроса PDO

$db = new PDO();// работает с запросами без связанных значений$stmt = $db->query('SELECT 1');vardump($stmt->activeQueryString()); // => string(8) "SELECT 1"$stmt = $db->prepare('SELECT :string');$stmt->bindValue(':string', 'foo');// возвращает не распаршенный запрос до выполненияvardump($stmt->activeQueryString()); // => string(14) "SELECT :string"// возвращает распаршенный запрос после выполнения$stmt->execute();vardump($stmt->activeQueryString()); // => string(11) "SELECT 'foo'"

PHP 7.3

JSON_THROW_ON_ERROR

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

До PHP v7.2 нам нужно было использовать обходное решение, чтобы получать ошибки из JSON, и оно не отличалось ни надежностью, ни изяществом в своей работе;

Вот пример:

jsondecode("{");jsonlasterror() === JSONERRORNONE // результат falsejsonlasterrormsg() // результат "Syntax error"

Итак, давайте же посмотрим, как мы можем использовать этот новый синтаксический сахар:

use JsonException;try {   $json = json_encode("{", JSON_THROW_ON_ERROR);   return base64_encode($json);} catch (JsonException $e) {   throw new EncryptException('Could not encrypt the data.', 0, $e);}

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

$e->getMessage(); // как jsonlasterrormsg()

$e->getCode(); // как jsonlasterror()

Добавлена функция iscountable

// До:if (isarray($foo) || $foo instanceof Countable) {// $foo является countable}// Послеif (iscountable($foo)) {// $foo является countable}

Добавлены функции массива arraykeyfirst (), arraykeylast ()

$firstKey = arraykeyfirst($array);$lastKey = arraykeylast($array);

Добавлена встроенная поддержка samesite cookie

Теперь есть две опции для cookie, использующего флаг samesite: Lax (нестрогий) и Strict (строгий). Разница между Lax и Strict заключается в доступности файла cookie в запросах, исходящих из другого регистрируемого домена с использованием метода HTTP GET. Файлы cookie, использующие Lax, будут доступны по GET, исходящему из другого регистрируемого домена, тогда как файлы cookie, использующие Strict, не будут доступны в GET запросе. Для POST методов разницы нет: браузер не должен разрешать доступ к cookie в POST запросе, исходящем из другого регистрируемого домена.

Set-Cookie: key=value; path=/; domain=example.org; HttpOnly; SameSite=Lax|Strict

Обновление PCRE до PCRE2

Улучшение хеширования паролей с помощью Argon2

Существующие password_* функции обеспечивают упрощенный интерфейс с прямой совместимостью для хеширования паролей. Этот RFC предлагает для использования в password_* функциях реализацию Argon2id в качестве безопасной альтернативы первоначально предложенному Argon2i.

Завершающая запятая в вызовах функций

$newArray = array_merge($arrayOne,$arrayTwo,['foo', 'bar'],// в вызовах функций можно использовать запятую);

Присвоение по ссылкам в list()

$array = [1, 2];list($a, &$b) = $array;

Это эквивалентно следующему:

$array = [1, 2];$a = $array[0];$b =& $array[1];

Устарели не чувствительные к регистру константы

PHP 7.4

Типизированные свойства

class User {   public int $id;   public string $name;   public function __construct(int $id, string $name) {       $this->id = $id;       $this->name = $name;   }}

FFI (Foreign Function Interface)

FFI - одна из фич, которые сделали Python и LuaJIT очень полезными для быстрого прототипирования. Он позволяет вызывать функции C и использовать типы данных C из чисто скриптового языка и, следовательно, более продуктивно разрабатывать системный код. Для PHP FFI открывает способ писать расширения PHP и биндинги к библиотекам C на чистом PHP.

Присваивающий оператор объединения с Null

// Следующие строчки делают одно и то же$this->request->data['comments']['userid'] = $this->request->data['comments']['userid'] ?? 'value';// Вместо повторения переменных с длинными именами используется присваивающий оператор объединения$this->request->data['comments']['user_id'] ??= 'value';

Предварительная загрузка

PHP использует кеши опкодов уже много лет (APC, Turck MMCache, Zend OpCache). Они дают значительный прирост производительности, ПОЧТИ полностью устраняя накладные расходы на перекомпиляцию PHP кода. Предварительная загрузка будет контролироваться только одной новой директивой php.ini - opcache.preload. Используя эту директиву, мы определяем PHP файл, который возьмет на себя задачу предварительной загрузки. После загрузки этот файл полностью выполняется - и может предварительно загружать другие файлы, инклюдя их или используя функцию opcachecompilefile() .

Всегда доступное хеш расширение

Это делает хеш расширение (ext/hash) всегда доступным, схожим образом с date. Хеш расширение предоставляет очень ценную утилиту со множеством алгоритмов хеширования, которая чрезвычайно полезна в современных приложениях, причем не только в коде юзерленда, но и во многом случаях во внутреннем коде.

На пути к PHP 8.0

JIT

В двух словах, когда вы запускаете PHP программу, Zend Engine парсит код в абстрактное синтаксическое дерево (abstract syntax tree - AST) и преобразует его в опкоды. Опкоды - это единицы выполнения для виртуальной машины Zend (Zend VM). Опкоды довольно низкоуровневые, поэтому их гораздо быстрее переводить в машинный код, чем исходный код PHP. В ядре PHP есть расширение OPcache для кеширования этих опкодов.

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

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

Стабильные typeErrors для внутренних функций

Сделайте так, чтобы API синтаксического анализа внутренних параметров всегда генерировали TypeError, если синтаксический анализ завершается неудачно. Следует отметить, что это также включает ArgumentCountError (дочерний элемент TypeError) для случаев, когда было передано слишком мало/много аргументов.

Сравнение производительности

Я составил простой тест, который поможет легко сравнить производительность различных версий PHP (с использованием Docker). Он даже позволил бы легко проверять производительность новых версий PHP, просто добавляя новые имена контейнеров.

Тестировалось на Macbook pro, Intel Core i7 2,5 ГГц.

PHP version : 5.6.40--------------------------------------test_math                 : 1.101 sec.test_stringmanipulation   : 1.144 sec.test_loops                : 1.736 sec.test_ifelse               : 1.122 sec.Mem: 429.4609375 kb Peak mem: 687.65625 kb--------------------------------------Total time:               : 5.103PHP version : 7.0.33--------------------------------------test_math                 : 0.344 sec.test_stringmanipulation   : 0.516 sec.test_loops                : 0.477 sec.test_ifelse               : 0.373 sec.Mem: 421.0859375 kb Peak mem: 422.2109375 kb--------------------------------------Total time:               : 1.71PHP version : 7.1.28--------------------------------------test_math                 : 0.389 sec.test_stringmanipulation   : 0.514 sec.test_loops                : 0.501 sec.test_ifelse               : 0.464 sec.Mem: 420.9375 kb Peak mem: 421.3828125 kb--------------------------------------Total time:               : 1.868PHP version : 7.2.17--------------------------------------test_math                 : 0.264 sec.test_stringmanipulation   : 0.391 sec.test_loops                : 0.182 sec.test_ifelse               : 0.252 sec.Mem: 456.578125 kb Peak mem: 457.0234375 kb--------------------------------------Total time:               : 1.089PHP version : 7.3.4--------------------------------------test_math                 : 0.233 sec.test_stringmanipulation   : 0.317 sec.test_loops                : 0.171 sec.test_ifelse               : 0.263 sec.Mem: 459.953125 kb Peak mem: 460.3984375 kb--------------------------------------Total time:               : 0.984PHP version : 7.4.0-dev--------------------------------------test_math                 : 0.212 sec.test_stringmanipulation   : 0.358 sec.test_loops                : 0.205 sec.test_ifelse               : 0.228 sec.Mem: 459.6640625 kb Peak mem: 460.109375 kb--------------------------------------Total time:               : 1.003

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

meskis/php-bench

Бенчмарки от PHP 5.6 и выше

Мне очень понравилась компиляция визуальной производительности всех основных версий от 5.6 и выше от servebolt.com. См. результаты в таблицах ниже.

Сводка по производительности

PHP 7.0.0 стал важной вехой со значительно улучшенной производительностью и меньшим использованием памяти, но у специалистов по сопровождению уже PHP попросту заканчиваются идеи по его улучшению. Один из оставшихся моментов - JIT (Just in time) компиляция. И она придет с PHP 8.0.

Направление развития

В версиях PHP 7.x прослеживается путь к более типизированному (и немного более объектному) и современному языку программирования. PHP любит перенимать изящные и полезные функции других языков программирования.

Вскоре мы можем увидеть еще несколько замечательных функций, таких как:

• Именованные аргументы

• Null безопасные вызовы

• Перечислимые типы (ENUM)

• Стрелочные функции

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

TL;DR

Чтобы еще больше все сократить, я выбрал наиболее важные по моему мнению изменения, учитывая последнюю версию версию на момент написания статьи - PHP 7.3. Вот они:

• Добавлен новый оператор объединения с null

• Объявления скалярных типов

• Объявления типов возвращаемых значений

• Интерфейс Throwable

• Обнуляемые типы

• Ничего не возвращающие функции

• Синтаксис квадратных скобок для деструктуририрующего присваивания в массиве

• Видимость констант класса

Ссылки

https://wiki.php.net/rfc

https://www.cloudways.com/blog/php-5-6-vs-php-7-symfony-benchmarks/

https://servebolt.com/articles/wordpress-5-0-php-7-2-vs-php-7-3-performance-and-speed-benchmark/

Узнать подробнее о курсе.

Всем привет. В преддверии старта курса "Scala-разработчик" подготовили для вас полезный перевод.

Еще в январе 2020 года я написал два поста (I, II) о подводных камнях, с которыми могут столкнуться новички в начале работы с ZIO. Прошло 9 месяцев. На этот период пришелся релиз ZIO 1.0, и среда ZIO значительно улучшилась с внедрением ZLayer.

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

С января я написал порядочное количество кода с использованием ZIO и за это время успел совершить и исправить несколько ошибок. Ниже я расскажу еще о 5 уроках, которые я усвоил, работая с ZIO. Темы будут затронуты очень разные: от оптимальных методов написания рекурсивного кода с помощью ZIO до правильного формулирования тестовых assert-проверок при использовании TestClock.

ФотографияIl VagabiondoнаUnsplash

1. Выполнение рекурсии, небезопасной для кучи

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

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

Рассмотрим упрощенный пример кода нашей реализации опроса и обработки сообщений потребителей в Kafka.

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

def pollLoop(running: Ref[Boolean],             consumer: Consumer            ): UIO[Unit] =  running.get.flatMap {    case true => for {      _ <- pollAndHandle(consumer)      result <- pollLoop(running, consumer)    } yield result    case false => ZIO.unit  }

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

def pollLoop(running: Ref[Boolean],                 consumer: Consumer                 ): UIO[Unit] =  running.get.flatMap {    case true =>       pollAndHandle(consumer)        .flatMap(_ => pollLoop(running, consumer))        .map(result => result)    case false => ZIO.unit  }

Мы решили полностью отказаться от использования рекурсивных методов в нашей кодовой базеGreyhound и вместо них применять оператор ZIOdoWhile, который гарантированно обеспечивает хвостовую рекурсию эффекта, безопасную для кучи. Для вышеприведенного случая мы изменили рекурсивный метод, чтобы он ограничивался только одной операцией опроса (pollOnce), а рекурсией управлял оператор doWhile:

pollOnce(running, consumer).doWhile(_ == true).forkDaemon

Таким образом, данная реализация pollOnce должна возвращать значение UIO[boolean], от которого зависит, будет ли рекурсия выполняться дальше:

def pollOnce(running: Ref[Boolean],                 consumer: Consumer                 ): UIO[Unit] =  running.get.flatMap {    case true => for {      _ <- pollAndHandle(consumer)    } yield true    case false => UIO(false)  }

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

2. Использование побочного эффекта одновременно с повторяющимся эффектом

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

def repeatedlyPublishQuote(stock: Stock) = {  publishQuote(stock).repeat(Schedule.fixed(1.second))}def publishQuote(stock: Stock) = {  println(s"getLatestQuote for $stock")  for {    quote <- grpcClient.getLatestQuote(stock)    _ <- sendToWebsocket(quote)  } yield ()}

Любой побочный эффект не из библиотеки ZIO, выполняемый в методе publishQuote, не будет повторен оператором repeat в repeatedlyPublishQuote. Оператор repeat повторяет только функциональные эффекты.

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

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

def publishQuote(stock: Stock) = {  val sendQuote = for {    _ <- console.putStrLn(s"getLatestQuote for $stock")    quote <- grpcClient.getLatestQuote(stock)    _ <- sendToWebsocket(quote)  } yield ()    sendQuote.catchAll(_ => UIO.unit)}

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

3. Неумышленное использование TestClock в коде периодической assert-проверки

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

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

Примечание. Этот пример написан с использованиемspecs2, однако тот же принцип работает и дляScalaTest.

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

Рассмотрим реализацию eventuallyZ:

def eventuallyZ[T](f: UIO[T])(predicate: T => Boolean): ZIO[Clock, Throwable, Unit] = {  f.repeat(Schedule.spaced(100.milliseconds) && Schedule.doUntil(predicate))    .timeoutFail(new RuntimeException)(4.seconds)    .unit}

С помощью Schedule из библиотеки ZIO заданное условие вызывается каждые 100 миллисекунд до тех пор, пока оно не станет истинным или не наступит тайм-аут спустя 4 секунды.

Но здесь и кроется проблема. eventuallyZ использует часы Clock в среде, но без уточнения, какие именно. Необходимо использовать Live Clock, но в нашем примере, поскольку в тесте используется TestClock, eventuallyZ также будет использовать TestClock, а это означает, что фактически циклическая проверка происходить не будет, так как TestClock.adjust не вызывается.

Решением данной проблемы будет указание правильных часов с помощью оператораZIO provideSomeLayer:

def eventuallyZ[T](f: UIO[T])(predicate: T => Boolean): ZIO[Clock, Throwable, Unit] = {  f.repeat(Schedule.spaced(100.milliseconds) && Schedule.doUntil(predicate))    .timeoutFail(new RuntimeException)(4.seconds)    .provideSomeLayer(Clock.live)    .unit}

Теперь эффекты ZIO, выполняемые в областиeventuallyZ,используютLiveClock и корректно проверяют условия каждые 100 миллисекунд. Это не влияет на остальной код теста, в котором можно и далее использоватьTestClock.

Полный фрагмент кода этого примера можно посмотреть здесь.

4. Не забываем связывать assert-проверки ZIO Test между собой

К вопросу о тестах: у меня также была возможность поработать с замечательной библиотекой ZIO Test. Рассмотрим простой пример: проверка, является ли число положительным и четным:

object NumbersTest extends DefaultRunnableSpec {  override def spec =      testM("positive and even") {        checkAll(Gen.fromIterable(Seq(0, 2, 4, 6))) { number =>            assert(number)(isPositive)            assert(number % 2 == 0)(Assertion.isTrue)          }      }}

Как видите, ее можно легко провести на генерируемом потоке значений, который, разумеется, может быть потоком случайных значений для тестирования свойств (например, положительных целых чисел:Gen.anyInt.filter(_ > 0)). Однако в приведенном выше коде есть небольшая проблема. В действительности будет выполняться только проверка isEven, поскольку первый assert не связан со вторым. Таким образом, тест будет пройден, несмотря на то что 0 не является положительным числом.

+ positive and even after additionRan 1 test in 660 ms: 1 succeeded, 0 ignored, 0 failed

Чтобы это исправить, достаточно связать две assert-проверки с помощью оператора&&:

assert(number)(isPositive) && assert(number % 2 == 0 (Assertion.isTrue)

Теперь тест завершается неудачей:

Ran 1 test in 685 ms: 0 succeeded, 0 ignored, 1 failed- positive and even after additionTest failed after 1 iteration with input: 00 did not satisfy isGreaterThan(0)

5. Прерывание волокна, исходящего из области Managed#Acquire

Волокна (fibers) ZIO это своего рода строительные блоки, из которых создаются функции для одновременного/асинхронного выполнения, предлагаемые ZIO.

Обычно мы создаем волокна с помощью встроенных операторов, таких как foreachPar.

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

И вот здесь важно помнить, что иногда волокна нельзя прервать! Примерами тому являются области ZManaged acquire и release (необходимо контролировать, что ресурсы приобретаются и высвобождаются безопасным образом), а также те случаи, когда вы указываете свойство uninterruptible:

criticalEffect.uninterruptible

В примере ниже область действия Managed.acquire используется для создания нового волокна, которое периодически посылает сигнальное сообщение heart-beat некому серверу в целях поддержания связи. ОбластьManaged.releaseиспользуется для прерывания (по завершении работы приложения).

object Server extends zio.ManagedApp {  def sendHeartBeat(): URIO[Console with Clock, Unit] =    console.putStrLn("heart-beat").repeat(Schedule.fixed(1.second)).ignore  override def run(args: List[String]): ZManaged[zio.ZEnv, Nothing, ExitCode] =    Managed      .make(sendHeartBeat().fork)(_.interrupt)      .map(_ => ExitCode(0))}

Проблема заключается в том, что данный fork нельзя прервать, поэтому приложение никогда не остановится и будет продолжать посылать сигнальные сообщения!

Решить эту проблему можно, явно указав интерпретатору ZIO, что это волокно должно быть прерываемым:

Managed.make(sendHeartBeat().fork.interruptible)(.interrupt)

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

sendHeartBeat().toManaged.fork

toManaged_ создает прерываемое волокно, в отличие от Managed.make.

Спасибо за внимание!

Предыдущие посты на эту тему:

• 5 ловушек, с которыми сталкиваются новички в начале работы с ZIO

• Еще 5 ловушек, с которыми сталкиваются новички в начале работы с ZIO

Если вы хотите быть в курсе всех моих перипетий работы с ZIO, подписывайтесь на меня в Twitter и Medium. Если что-то показалось непонятным или у вас есть замечания к написанному, можете оставить комментарий ниже.

Узнать подробнее о курсе.

Читать ещё:

• Применение ZIO ZLayer

• Определение серверной логики для конечной точки: три подхода

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

Паттерн Pipeline & Filter

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

ConditionAggregator - это конвейерный класс, в котором хранится коллекция Condition<T>. Filter<T> владеет ConditionAggregator или Condition<T> для применения условий (condition) фильтрации к набору данных. Когда вызывается функция apply (применить) Filter<T>, выполняется метод check (проверить) ICondition<T>. ConditionAggregator<T> имеет событие OnFilterChanged. Оно срабатывает, когда в классах модели представления изменяется значение коллекции или условия. В следующем разделе будет описано использование паттерна Filter моделью представления.

Код

Использование в модели представления

Объяснение паттерна MVVM можно найти по этой ссылке. Одна из обязанностей модели представления (View Model) в MVVM - обрабатывать взаимодействие с пользователем и изменения данных. В нашем случае изменения значений условий фильтрации должны быть переданы на бизнес-уровень, чтобы применить фильтры к определенной коллекции данных. Изменение значения условия в модели представления стригерит событие ConditionAggregator<T> OnFilterChanged, на которое подписан метод фильтра apply. Ниже приведена диаграмма классов модели представления.

Класс сущности Employee создан для хранения информации о сотрудниках. Generic тип T паттерна проектирования Filter будет заменен классом Employee. EmployeeList содержит список данных о сотрудниках и применяемые фильтры. Конструктор класса получает список условий и переходит к списку фильтров.

public EmployeeList(IEmployeesRepository repository, ConditionAggregator<employee> conditionAggregator)        {            this.repository = repository;            this.filters = new ConcreteFilter<employee>(conditionAggregator);            conditionAggregator.OnFilterChanged += this.FilterList;            _ = initAsync();        }

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

private void FilterList(){    this.Employees = this.filters.Apply(this.employeesFullList);}

EmployeesViewModel подключен к пользовательскому интерфейсу. В этом примере продемонстрирован только один фильтр свойства EmployeeTypeselected, но в ConditionAggregator можно передать множество фильтров. Следующий фрагмент кода - это метод-конструктор, в котором регистрируется условие фильтра.

public EmployeesViewModel(IEmployeesRepository repository)        {            this.repository = repository;            Condition<employee> filterEmployee = new Condition<employee>((e) => e.employeeCode == this.EmployeeTypeSelected);            this.conditionAggregator = new ConditionAggregator<employee>(new List<condition<employee>> { filterEmployee });            this.EmployeeList = new EmployeeList(repository, this.conditionAggregator);                    }  </condition<employee></employee></employee></employee>

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

Архитектура приложения

WPF.Demo.DataFilter - это представление пользовательского интерфейса WPF. Он имеет одну сетку и одно поле со списком для фильтрации. Проект WPF.Demo.DataFilter.ViewModels обрабатывает данные, фильтрует изменения и перезагружает данные для обновления пользовательского интерфейса. Проект WPF.Demo.DataFilter.Common представляет собой полную реализацию шаблона Pipeline & Filter. WPF.Demo.DataFilter.DAL загружает простенький json-файл в качестве хранилища данных.

Это основной интерфейс:

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

Привет, Хабр! Перевод статьи подготовлен в рамках курса "C++ Developer. Professional"

Один из участников моего семинара в рамках CppCon 2018 спросил меня: Может ли std::thread быть прерван (interrupted)?. Мой ответ тогда был нет, но это уже не совсем так. С C++20 мы можем получить std::jthread (в итоге все таки получили прим. переводчика).

Позвольте мне развить тему, поднятую на CppCon 2018. Во время перерыва в моем семинаре, посвященному параллелизму, я побеседовал с Николаем (Йосуттисом). Он спросил меня, что я думаю о новом предложении P0660: Cooperatively Interruptible Joining Thread. На тот момент я ничего не знал об этом предложении. Следует отметить, что Николай является одним из авторов этого предложения (наряду с Хербом Саттером и Энтони Уильямсом). Сегодняшняя статья посвящена будущему параллелизма в C++. Ниже я привел общую картину параллелизма в текущем и грядущем C++.

Из названия документа Cooperatively Interruptible Joining Thread (совместно прерываемый присоединяемый поток) вы можете догадаться, что новый поток имеет две новые возможности: прерываемость (interruptible) и автоматическое присоединение (automatically joining, здесь и далее присоединение блокировка вызывающего потока до завершения выполнения, результат вызова метода join() прим. переводчика). Позвольте мне сначала рассказать вам об автоматическом присоединении.

Автоматическое присоединение

Это неинтуитивное поведение std::thread. Если std::thread все еще является joinable, то в его деструкторе вызывается std::terminate. Поток thr является joinable, если ни thr.join(), ни thr.detach() еще не были вызваны.

// threadJoinable.cpp#include <iostream>#include <thread>int main(){        std::cout << std::endl;    std::cout << std::boolalpha;        std::thread thr{[]{ std::cout << "Joinable std::thread" << std::endl; }};        std::cout << "thr.joinable(): " << thr.joinable() << std::endl;        std::cout << std::endl;    }

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

Оба потока терминируются. На втором запуске поток th имеет достаточно времени, чтобы отобразить свое сообщение: Joinable std::thread.

В следующем примере я заменяю хедер <thread> на "jthread.hpp" и использую std::jthread из грядущего стандарта C++.

// jthreadJoinable.cpp#include <iostream>#include "jthread.hpp"int main(){        std::cout << std::endl;    std::cout << std::boolalpha;        std::jthread thr{[]{ std::cout << "Joinable std::thread" << std::endl; }};        std::cout << "thr.joinable(): " << thr.joinable() << std::endl;        std::cout << std::endl;    }

Теперь поток thr автоматически присоединяется в своем деструкторе, если он все еще является joinable, как, например, в этом примере.

Прерывание std::jthread

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

// interruptJthread.cpp#include "jthread.hpp"#include <chrono>#include <iostream>using namespace::std::literals;int main(){        std::cout << std::endl;        std::jthread nonInterruptable([]{                                   // (1)        int counter{0};        while (counter < 10){            std::this_thread::sleep_for(0.2s);            std::cerr << "nonInterruptable: " << counter << std::endl;             ++counter;        }    });        std::jthread interruptable([](std::interrupt_token itoken){         // (2)        int counter{0};        while (counter < 10){            std::this_thread::sleep_for(0.2s);            if (itoken.is_interrupted()) return;                        // (3)            std::cerr << "interruptable: " << counter << std::endl;             ++counter;        }    });        std::this_thread::sleep_for(1s);        std::cerr << std::endl;    std::cerr << "Main thread interrupts both jthreads" << std:: endl;    nonInterruptable.interrupt();    interruptable.interrupt();                                          // (4)        std::cout << std::endl;    }

Я запустил в main два потока, nonInterruptable, который нельзя прерывать, и interruptable, который можно (строки 1 и 2). В отличие от потока nonInterruptable, поток interruptable, получает std::interrupt_token и использует его в строке 3, чтобы проверить, был ли он прерван: itoken.is_interrupted(). В случае прерывания в лямбде срабатывает return и, следовательно, поток завершается. Вызов interruptable.interrupt() (строка 4) триггерит завершение потока. Аналогичный вызов nonInterruptable.interrupt() не сработает для потока nonInterruptable, который, как мы видим, продолжает свое выполнение.

Вот более подробная информация о токенах прерывания (interrupt tokens), присоединяющихся потоках и условных переменных.

Токены прерывания

Токен прерывания std::interrupt_token моделирует совместное владение (shared ownership) и может использоваться для сигнализирования о прерывании, если токен валиден. Он предоставляет три метода: valid, is_interrupted, и interrupt.

itoken.valid() true, если токен прерывания может быть использован для сигнализировании о прерывании

itoken.is_interrupted() true, если был инициализирован с true или был вызван метода interrupt()

itoken.interrupt() если !valid() или is_interrupted(), то вызов метода не возымеет эффекта. В противном случае, сигнализирует о прерывании посредством itoken.is_interrupted() == true. Возвращает значение is_interrupted()

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

std::jthread jthr([](std::interrupt_token itoken){    ...    std::interrupt_token interruptDisabled;     std::swap(itoken, interruptDisabled);     // (1)           ...    std::swap(itoken, interruptDisabled);     // (2)    ...}

std::interrupt_token interruptDisabled не валиден. Это означает, что поток не может принять прерывание между строками (1) и (2), но после строки (2) уже может.

Присоединение потоков

std::jhread представляет собой std::thread с дополнительным функционалом, реализующим сигнализирование о прерывании и автоматическое присоединение. Для поддержки этой функциональности у него есть std::interrupt_token.

Новые перегрузки Wait для условных переменных

Две вариации wait wait_for и wait_until из std::condition_variable получат новые перегрузки. Они принимают std::interrupt_token.

template <class Predicate>bool wait_until(unique_lock<mutex>& lock,                 Predicate pred,                 interrupt_token itoken);template <class Rep, class Period, class Predicate>bool wait_for(unique_lock<mutex>& lock,               const chrono::duration<Rep, Period>& rel_time,               Predicate pred,               interrupt_token itoken);template <class Clock, class Duration, class Predicate>bool wait_until(unique_lock<mutex>& lock,                 const chrono::time_point<Clock, Duration>& abs_time,                 Predicate pred,                 interrupt_token itoken);

Новые перегрузки требует предикат. Эти версии гарантированно получают уведомления, если поступает сигнал о прерывании для переданного им std::interrupt_token itoken. После вызовов wait вы можете проверить, не произошло ли прерывание.

cv.wait_until(lock, predicate, itoken);if (itoken.is_interrupted()){    // interrupt occurred}

Что дальше?

Как я и обещал в своей последней статье, следующая статья будет посвящена оставшимся правилам определения концептов (concepts).

Узнать подробнее о курсе "C++ Developer. Professional".

Смотреть запись демо-занятия по теме Области видимости и невидимости: участники вместе с экспертом попробовали реализовать класс общего назначения и запустить несколько unit-тестов с использованием googletest.

Я хочу сделать признание. Когда дело доходит до моего компьютера, я оставляю все в значительной степени сыром виде. Конечно, у меня есть любимые маленькие инструменты. Я использую плагины Chrome, такие как Wappalyzer, и множество расширений VS Code, таких как Chrome Debugger и Live Server. Но я сознательно не использую темы, шрифты, средства форматирования и другие приятные для глаз настройки. В далеком прошлом, когда я только начинал программировать, я тратил слишком много времени на перестройку своей индивидуальной настройки на разных компьютерах и на новом оборудовании. Постоянные настройки устарели, поэтому я решил по возможности сократить до стокового.

Это мое оправдание, почему я провел много месяцев, по большей части игнорируя продукт Microsoft Windows Terminal. В конце концов, время, которое я провожу в командной строке, ограничено и ничем не примечательно. Я настраиваю свое приложение, устанавливаю пакеты npm или Nuget и двигаюсь дальше. Проводить время в окне терминала означает заходить в темный угол операционной системы и делать то, что нужно.

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

Кодовой базе Windows Console 30 лет на самом деле она старше, чем разработчики, которые сейчас над ней работают. - Рич Тернер, менеджер по Microsoft

Терминал открыт

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

Терминал - это часть программного обеспечения, которое обрабатывает текстовый ввод и отображение. Вы вводите текст в командной строке терминала. Вы смотрите в окно терминала. Но за кулисами ваш терминал взаимодействует с программой оболочки, которая действительно выполняет эту работу. В современной Windows стандартная программа терминала - ConHost.exe, и, черт возьми, она старая.

Вы думаете, что запускаете PowerShell, но на самом деле вы запускаете интерфейс ConHost, который взаимодействует с PowerShell.

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

Вместо этого Microsoft начала создавать новый терминал под названием Windows Terminal. Он существует уже почти год, но еще не дошел до включения в ОС Windows. Это означает, что если вам нужен Терминал Windows, вы должны установить его из Windows Store. (Или вы можете загрузить его с GitHub и собрать самостоятельно, потому что новый терминал, естественно, имеет открытый исходный код.)

Почему терминал Windows?

Из-за того, как работают терминалы, в них не так много очевидного волшебства. Фактически, выполнение работы выполняется любой программой оболочки, которую вы используете. Но оказывается, что новый терминал Windows содержит множество практических удобств, которые могут сделать вас более продуктивным (или, по крайней мере, менее раздражающим) при выполнении повседневной работы. Вот несколько причин полюбить Windows Terminal:

• Несколько вкладок. Помните, когда в веб-браузерах была только одна вкладка? Как мы это ненавидели! Но мы терпели это в ConHost уже целое поколение. К счастью, Windows Terminal позволяет открывать столько вкладок, сколько нужно в одном окне.

  Иногда мелочи - это большие дела

• Несколько панелей. Это похоже на несколько вкладок, но вы можете видеть разные экземпляры терминала в аккуратном порядке бок о бок или сверху и снизу. И вы управляете всем этим с помощью удобных нажатий клавиш. Удерживая Alt + Shift, нажмите +, чтобы открыть новую панель справа, или -, чтобы открыть новую панель внизу. Затем вы можете переходить с панели на панель, удерживая Alt и нажимая клавиши со стрелками. Круто!

  

• Одновременное использование нескольких оболочек. Терминал Windows поддерживает любую стандартную программу оболочки. Вы можете использовать старую добрую PowerShell, почти устаревшую командную строку, Azure Cloud Shell (для управления онлайн-ресурсами Azure) и даже bash, если вы включили Windows Linux Subsystem. И вы можете запускать их все рядом, на разных вкладках или панелях одного и того же окна Терминала Windows.

  Оболочки сошли с ума

• Масштабирование, которое работает. Мое любимое сочетание клавиш масштабирования - удерживать Ctrl и вращать колесико мыши. Это работает и в ConHost, но при этом неудобно изменяет размер окна. Терминал Windows масштабирует более разумно, и он распознает удобное сочетание клавиш Ctrl + 0, чтобы вернуть все в нормальное состояние. И не повредит, что Windows Terminal поставляется с новым элегантным шрифтом Cascadia Code, который отлично смотрится при любом размере.

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

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

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

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

• Настраиваемая прозрачность с размытием фона. Вы даже можете настроить его на лету, удерживая Ctrl + Shift и вращая кнопку мыши. Но зачем?

• Цветовые схемы и пользовательские фоновые изображения.

• Анимированные фоны в формате GIF. (Привет, Windows Plus примерно из 1998 года.)

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

Краткое примечание о терминале VS Code

Если вы используете Visual Studio Code, вы, вероятно, знакомы с его интегрированным терминалом. Вы можете выбрать, какую оболочку использовать (например, PowerShell или bash), но вы всегда используете терминал VS Code, а не ConHost.

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

Последнее слово

Терминал Windows неуклонно продвигается к версии 2.0, которая ожидается этой весной, и в конечном итоге включение в Windows. Планируется длинный список новых функций, включая возможность отрывать вкладки и перемещать их из одного окна терминала. к другому, бесконечная прокрутка и приятный пользовательский интерфейс для управления настройками. Будет ли он вызывать безумную любовь, как VS Code или язык C #? Нет. Но иногда достаточно сделать жизнь менее болезненной.

Скачать Windows Terminal можно здесь.

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

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

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

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

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

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

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

Основные принципы и подходы:

I этап - подбор кандидатов:

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

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

II этап - отбор потенциальных стажеров:

1. Тестовое задание до личной встречи, что, как можно лучше, расскажет о теоретических знаниях (hard skills).

2. Личная встреча или общение, дает четкое понимание о личных качествах (soft skills) и представление о том насколько кандидат подходит и сможет вписаться в текущие процессы, разделить и перенять дух команды.

3. Импровизация от кандидата. Интересный кейс был в Vodafone Ukraine - когда кандидаты создавали свою презентационную видео визитку и раскрывали свои личности через креатив.

III этап - развитие молодых специалистов:

1. Обучение: формирование образовательного процесса и вовлечение в него стажеров.

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

3. Доступность: готовность отвечать на вопросы, уделять достаточно времени и быть открытым к диалогу.

4. Чуткость: понимание рабочего настроения и внутреннего ощущения стажера.

IV этап - вовлечение новых коллег:

1. Равноправие: стажеры - полноправные члены команды и нет никакого разделения.

2. Вовлеченность: все задачи из реальных процессов и их решение ведет к полноценному продукту или успешному завершению определенной продуктовой стадии.

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

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

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

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

Одним из наиболее успешных за последнее время стал кейс в инновационном направления Vodafone Ukraine:

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

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

В результате я увидел горящие глаза и высочайшую мотивированность, а уже через пару месяцев мы показывали proof of concept продукта.

Отзыв product owner Марины:

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

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

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

Иногда не хватало помощи в операционных водафоновских вопросах (прописать договор, создать какие-то внутренние заявки), поэтому у меня на них уходило много времени и они слегка дизморалили

Отзыв product owner Максима:

"Для меня стажировка принципе отложилась в памяти как супер крутое время и в том числе благодаря крутым наставникам.

Соответственно, самое позитивное:

1) готовность инвестировать время в мои знания. А с учетом постоянной нехватки времени - это супер круто

2) правильные советы и в нужное время

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

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

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

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

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

Отзыв tech lead Федора:

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

2. Думаю тут все сложилось. И я хотел попробовать в таком формате и ты предложил. win-win

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

4. Да, для меня это тоже развитие однозначно, пусть и не такое стремительное. Мне нравится эта роль в команде.

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

Отзыв fullstack backend разработчика Александра:

Кураторы адекватные, менторы толковые

Учат понятно, потенциал видят) поддержка есть)

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

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

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

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

Отзыв product ownerЭда:

В компании Vodafone я менял направление работы 3 раза: стажировка стратегом, работа PM партнерских развлекательных сервисов и, наконец, junior PM продуктов с собственной разработкой (eHealth, eLearning). Собственно последний этап и был самым интересным. Каждый день драйвило то, что именно вы с командой определяете список задач в гибких условиях, а от твоих действий зависит результат всего продукта. Эта зависимость и мотивировала гуглить новую информацию или спрашивать совет старших, а информация касалась буквально всего: интернет-маркетинг, брендинг, копирайтинг, кросс-функциональная коммуникация и многого другого.

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

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

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

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

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

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

• Искусственные нейроны

• Весы(weights) и смещения(biases)

• Активационные функции(activation functions)

• Слои нейронов(layers)

• Реализация нейронной сети на Java

Раскрывая нейронные сети

Во-первых, термин нейронные сети может создать снимок мозга в вашем сознании, в частности для тех, кто ранее познакомился с ним. В действительности это правда, мы считаем мозг большая и естественная нейронная сеть. Однако что мы можем сказать об искусственных нейронных сетях (ANN artificial neural network)? Хорошо, он начинается с антонима естественный и первая мысль, которая приходит в нашу голову это картинка искусственного мозга или робота учитывает термин искусственный. В этом случае, мы так же имеем дело с созданием структуры, похожей и вдохновленной человеческим мозгом; поэтому это названо искусственным интеллектом. Поэтому читатель, который не имел прошлого опыта с ANN, сейчас может думать, что книга учит, как строить интеллектуальные системы, включая искусственный мозг, способный эмулировать человеческое сознание, используя Java программы, не так ли? Конечно мы не будем покрывать создание искусственного мышления машин как в трилогии Матрицы; однако эта книга растолкует несколько неимоверных способностей и что могут эти структуры. Мы предоставим читателю Java исходники с определением и созданием основных нейросетевых структур, воспользоваться всеми преимуществами языка программирования Java.

Почему искусственные нейронные сети?

Мы не можем начать говорить про нейросети без понимания их происхождения, включая также термин. Мы используем термины нейронные сети (NN) и ANN взаимозаменяемо в этой книге, хотя NN более общий, покрывая также
естественные нейронные сети. Таким образом, что же такое на самом деле ANN? Давайте изучим немного историю этого термина.

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

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

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

Как устроены нейронные сети

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

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

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

Самый базовый элемент искусственный нейрон

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

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

Давая жизнь нейронам активационная функция

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

Четыре самых используемых активационных функций:

• Сигмоида (Sygmoid)

• Гиперболический тангенс(Hyberbolic tangent)

• Жесткая пороговая функция(Hard limiting threshold)

• Линейная(linear)

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

Фундаментальные величины весы(weights)

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

Важный параметр смещение

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

Части образующие целое слои

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

Нейронные сети могут быть составлены из нескольких соединенных слоев, которые называются многослойными сетями. Обычные нейронные сети могут быть разделены на 3 класса:
1. Input layer;
2. Hidden layer;
3. Output layer;
На практике, дополнительный нейронный слой добавляет другой уровень
абстракции внешней стимуляции, тем самым повышая способность
нейронных сетей представлять больше комплексных данных.

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

Изучение архитектуры нейронных сетей

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

1. Нейронные соединения:
1.1 Однослойные(monolayer) сети;
1.2 Многослойные(multilayer) сети;
2. Поток сигналов:
2.1 Сети прямой связи(Feedforward networks);
2.2 Сети обратной связи(Feedback networks);

Однослойные сети

Нейронная сеть получает на вход сигналы и кормит их в нейроны, которые в очереди продуцируют выходные сигналы. Нейроны могут быть соединены с другими с или без использования рекуррентности. Примеры таких архитектур: однослойный персептрон, Adaline(адаптивный линейный нейрон), самоорганизованная карта, нейронная сеть Элмана(Elman) и Хопфилда.

Многослойные сети

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

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

Сети прямой связи(feedforward networks)

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

Сети обратной связи(Feedback networks)

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

Специальная причина добавить рекуррентность в сеть это выработка динамического поведения, в частности когда сеть адресует проблемы, включая временные ряды или распознавание образов, которые требуют внутреннюю память для подкрепления обучающего процесса. Тем не менее, такие сети особенно трудны в тренировке, в конечном счете не в состоянии учиться. Многие feedback сети однослойные, такие как сети Элмана(Elman) и Хопфилда(Hopfield), но возможно и построить рекуррентную многослойную сеть, такие как эхо и рекуррентные многослойные персептронные сети.

От незнания к знаниям процесс обучения

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

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

Давайте начнем реализацию! Нейронные сети на практике

В этой книге мы покроем все процессы реализации нейронных сетей на Java. Java это объектно-ориентированный язык программирования, созданный в 1990-ые маленькой группой инженеров из Sun Microsystems, позже приобретенной компанией Oracle в 2010-ых. Сегодня, Java представлена во многих устройствах, которые участвуют в нашей повседневной жизни. В объектно-ориентированном языке, таком как Java, мы имеем дело склассами и объектами. Класс план чего-то в реальной жизни, а объект образец такого плана, например, car(класс, ссылающийся на все машины) и my car(объект, ссылающийся на конкретную машину мою). Java классы обычно состоят из атрибутов и методов(или функций), которые включают принципы объектно-ориентированного программирования(ООП). Мы собираемся кратко рассмотреть эти принципы без углубления в них, поскольку цель этой книги просто спроектировать и создать нейронные сети с практической точки зрения. В этом процессе четыре принципа уместны и нуждаются в рассмотрении:

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

• Инкапсуляция: Аналогично инкапсуляции продукта, при которой некоторые соответствующие функции раскрыты открыто (публичные(public) методы), в то время как другие хранится скрытым в пределах своего домена (частного(private) или защищенного(protected)), избегая неправильное использование или избыток информации.

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

• Полиморфизм: Во многом схожа с наследованием, но с изменениями в методах со схожими сигнатурами, представляющие разные поведения в разных классах.

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

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

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

Показанный следующий код имеет тестовый класс, главный метод объектом класса NeuralNet, названный n. Когда этоn метод вызывается (путем выполнения класса), он вызывает initNet () и printNet () методы из объекта n, генерирующие следующий результат, показанный на рисунке справа после кода. Он представляет собой нейронную сеть с двумя нейронами во входном слое, три в скрытом слое и один в выходном слое:

public class NeuralNetTest {    public static void main(String[] args) {        NeuralNet n = new NeuralNet();        n.initNet();        n.printNet();    }}

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

В сумме

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

От переводчика

Оригинал книги: Neural Network Programming with Java

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

Возникла необходимость сделать анимацию персонажа для игры, которую мы делаем на коленке". Чем нам не угодили mocap - анимации и анимации с mixamo.com:

• нужно искать наиболее подходящие анимации

• нужно много анимаций

• визуально анимации должны сочетаться

• очень трудно сделать что-то качественное из разношерстного набора анимационных сэмплов

Побираясь, как бездомный в чьем-то ведре, в поисках нужных анимаций в течении недели, мне удалось собрать некого Франкенштейна. Именно Франкенштейна потому, что анимаций надыбал отовсюду. Ходил персонаж как офисный работник, крался как эльф 80-го уровня, приседал как человек-паук. Шучу, все было не так уж и ужасно, конечно, для обывателя может и пойдет, а вот меня все же неустраивало разношерстность анимаций. Хотя блендинг и прочие процедурные фишки сильно улучшали дело... Да и ноги не прилипали к земле как надо. Меня это жутко раздражает, когда анимация персонажа не на 100% соответствует тому, что он делает, ноги проходят сквозь пол, руки сквозь стены... ну вы поняли, 21-й век как никак.

Что важно для анимации персонажа: нужно передать ощущение того как персонаж передвигается с учетом физики. Короче, анимация нужна процедурная. Это крайне важно для нашего 3D пазла от первого лица.

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

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

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

Отлично, цепляем все к телу, еще немного IK и получаем что-то типа (одно из приближений):

Обратите внимание на лодыжку. C ней вечно были проблемы. Дело в том, что наш робот сделан инженерами-конструкторами и соединения должны гнуться строго по оси и никак иначе. Хотя это далеко не последний вариант робота, но в целом все примерно так. (Спойлер: соединение ложыжки мы все же переделали. Инженеры поставили его на 3 гидропривода, что дало нужное число степеней свободы).

Далее используем наш ИИ для ноги. Не зря же нога у нас обучалась ходить сама по себе без тела XD Подключаем ИИ к ногам и говорим им болтаться:

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

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

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

Здесь экспериментирую с тем как робота придавливает плита. Робот должен корректно анимировать позицию своего тела:

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

Что хотелось бы добавить. Полностью избежать использования mocap анимации не удалось. Почему так? Дело в том, что роботу нужна индивидуальность, стиль перемещения. именно для этого ему даются наборы анимаций с которых он перенимает пластику движения и использует ее при расчете процедурной анимации перемещения. Как-то так.В тестах использовалась модель-аналог робота Федора. Извините, это неточная копия. Чертежей не было, собрали "на глаз" :D

Ссылки на наши некоторые наработки по игре (в виде скетчей):

Twitter

Instagram

VK