вторник, 1 января 2030 г.

О блоге

Более двадцати лет я занимался разработкой ПО, в основном как программист и тим-лид, а в 2012-2014гг как руководитель департамента разработки и внедрения ПО в компании Интервэйл (подробнее на LinkedIn). В настоящее время занимаюсь развитием компании по разработке ПО stiffstream, в которой являюсь одним из соучредителей. Поэтому в моем блоге много заметок о работе, в частности о программировании и компьютерах, а так же об управлении.

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

понедельник, 31 декабря 2029 г.

[life.photo] Характерный портрет: вы и ваш мир моими глазами. Безвозмездно :)

Вы художник? Бармен или музыкант? Или, может быть, коллекционер? Плотник или столяр? Кузнец или слесарь? Владеете маленьким магазинчиком или управляете большим производством? Реставрируете старинные часы или просто починяете примус? Всю жизнь занимаетесь своим любимым делом и хотели бы иметь фото на память?

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

вторник, 5 ноября 2024 г.

[prog.c++] Послесловие к релизу SO-5.8.3: будет ли SO-5.9 и если будет, то когда?

Осенью 2014-го года мы выпустили первую версию в ветке 5.5. Эта ветка затем развивалась пять лет без серьезных ломающих изменений. Я бы был не против и дальше обходится без заметных переделок, но, к сожалению, версия 5.5 набрала такой груз разнообразных фич, который стало уже тяжело нести. Накопился опыт, взгляды на какие-то вещи принципиально поменялись и было решено разгрести накопившийся наслоения не всегда хорошо сочетающейся функциональности. Так в 2019-ом появилась ветка 5.6.

Cчитаю, что в течении последних пяти лет именно эта ветка и развивается. Хотя, формально, мы сделали переход от 5.6 к 5.7, а затем и к 5.8, поскольку были пусть и небольшие, но ломающие совместимость изменения. Тем не менее, различия между 5.6 и 5.8 гораздо меньше, чем между 5.5 и 5.6. Так что для меня лично 5.6/5.7/5.8 -- это развитие одной и той же линии романа и изменение номера версии всего лишь дань формализму.

Сейчас заканчивается 2024-й год и получается, что семейство 5.6/5.7/5.8 поступательно развивается уже пять лет. Вроде бы повторяется история с пятилетним циклом жизни 5.5 и пора задумываться о том, что дальше.

На данный момент, в отличии от ситуации с 5.5, я не вижу каких-то фатальных недостатков в семействе 5.6/5.7/5.8. Необходимости разгрести авгиевы конюшни пока нет. ИМХО, у 5.8 еще есть запас прочности для продолжения в том же духе.

Поэтому какой-то насущной необходимости начинать ветку 5.9 нет.

Насущной нет, но есть вопрос с освоением новых стандартов C++. И в 2025-ом нужно будет всерьез задумываться над этим вопросом.

Пока что хватает и C++17. И для библиотеки хорошо, когда она отстает от самого-самого свежего стандарта -- тем самым больше проектов могут ее использовать. Но в какой-то момент возникает вопрос: а стоит ли это "хорошо для сторонних проектов" того, что мы отказываемся от плюшек современного C++?

В 2019-ом было решено, что невыгодно дальше держаться за C++11.

Полагаю, в ближайшие полтора-два года так же невыгодно станет держаться и за C++17. Вот тогда на горизонте и появится ветка 5.9.

Это один возможный сценарий развития событий.

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

Ведь сейчас в SObjectizer аллокации/деаллокации буквально на каждом шагу: за send-ом скрывается new, постановка заявки в очередь к агенту может вести к аллокациям, подписка или установка delivery filter требует аллокаций, даже смена состояния агента, если для состояния используется time_limit, требует аллокаций.

Подобное поведение автоматически ставит крест на применении SObjectizer в системах реального времени. Что иронично, т.к. SObjectizer вырос из SCADA Objectizer, создававшегося именно под реальное время. Но в этом я не вижу ничего страшного, ну нет и нет.

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

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

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

Но что делать когда крах при bad_alloc-е ну такое себе? Вот тот же прокси-сервер с 200k одновременных подключений... Он рестартует, это OK. Вполне вероятно, что он рестартует за считанные секунды, а то и быстрее. Тогда как восстановление этих 200k соединений -- это же не быстрый процесс. Это неизбежно скажется на впечатлении пользователей от качества сервиса. Но, что хуже, у нас нет устойчивости против подобных падений в будущем. Допустим, мы принимаем 200k подключений и работаем нормально, но затем приходит одно специфическое подключение, при работе с которым мы вынуждены активно потреблять память и это ведет нас напрямую к очередному bad_alloc-у. И мы опять падаем роняя 200k соединений. А через какое-то время все повторяется вновь.

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

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

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

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

Вот под добавление в SObjectizer чего-то подобного я бы начал ветку 5.9 не раздумывая прям завтра (но не сегодня, сегодня уже поздновато). Но...

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

суббота, 2 ноября 2024 г.

[prog.c++] Новые версии SObjectizer и so5extra: 5.8.3 и so5extra. Мои личные впечатления

Мы зафиксировали новые версии SObjectizer и so5extra: 5.8.3 и 1.6.2. На Хабре опубликована статья с описанием нововведений, так что не буду здесь повторяться. Озвучу здесь свои личные впечатления от работы над этими релизами.


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

Получилось не сказать, чтобы красиво и эргономично, поэтому не удивлюсь, если msg_hierarchy в итоге останется невостребованным. Возможностей C++17 (и моих знаний этих самых возможностей) хватило только на этот вариант. Была бы в C++ рефлексия, можно было бы сделать и покрасивши. Так что будем ждать принятия рефлексии в C++26, затем дождемся года 2029-го или даже 2030-го, чтобы безопасно перейти на компиляторы с нормальной поддержкой C++26... 🙂

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

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

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

Ну а дальше уже дело техники, как-то все само-собой раскрутилось. Отдельным вопросом был, конечно же, способ обхода иерархии классов в run-time. Но и с этим удалось разобраться, хоть и получилось достаточно коряво из-за ограничений C++.

Принципиальным моментом была именно идея о разных receiving_mbox-ах. Которую пришлось ждать больше трех лет и которая не желала появляться на свет "на заказ".

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


Когда писал статью для Хабра об этом релизе, то поймал себя на неожиданном ощущении.

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

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

А вот сейчас работая над текстом, даже мысли такой не возникало.

Как бы не первый год пилим и пилим. Кому могли "продать", тем уже "продали". Миллионов нам SObjectizer не принес. Ну так чего выделываться?

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

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

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


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

В завершении вынужден повторить банальность: если вдруг вам что-то потребовалось от SObjectizer-а, а вы этого там не нашли, то дайте знать. Мы не сможем сделать то, о чем даже и не подозреваем. А вот если нам сказать, то кто знает. Может года через три поймаем очередное "озарение" ;)

пятница, 1 ноября 2024 г.

[life.cinema] Очередной кинообзор (2024/10)

Подошло время очередного кинообзора. Традиционно в начале каждого из списков идет то, что понравилось больше, а в конце -- то, что понравилось меньше или же совсем не понравилось.

Фильмы

Дэдпул и Росомаха (Deadpool & Wolverine, 2024). Если понравились первые две части Дэдпула, то нужно обязательно смотреть и третью. Правда, в какой-то момент плотность юмора превысила мои способности к восприятию происходящего, так что, боюсь, многое прошло мимо меня. Если же вы хорошо помните персонажей из вселенных "Людей X" и "Мстителей", то наверняка заметите гораздо больше отсылок и подколок, чем получилось у меня.

Ограбление (Napad, 2024). В общем-то неплохо, мне зашло. Напомнило фильмы в духе соцреализма. Хотя к сюжету в нескольких местах есть вопросы, но если не придираться, то в общем-то неплохо.

Ячейка 234 (Unit 234, 2024). Бюджетненько, но вполне себе смотрибельно.

Игра киллера (The Killer's Game, 2024). Отличный аттракцион чтобы отключить мозги. Но если вам не нравится жанр абсолютно несерьезных комедийных боевиков, то лучше воздержаться.

Спящая (La mujer dormida, 2024). Смотреть было интересно, но развязка фильма откровенно разочаровала.

Револьвер (Ribolbeo, 2024). Откровенно слабо. В принципе, можно и пройти мимо.

Не говори никому (Speak No Evil, 2024). Мне не зашло совершенно, не возникло ощущение реальности происходящего. Хотя отметить отличную игру Джеймса Макэвоя нужно, такое впечатление, что он там единственный органично смотрелся.

Субстанция (The Substance, 2024). Не понравилось. Потенциально хорошую идею превратили в какую-то муть, а финал фильма -- откровенный треш. В общем, смотреть противно, а потраченного на просмотр времени жаль.

Сериалы

13 клиническая (первый сезон, 2022). Мне вот прям зашло. Посмотрел все восемь серий первого сезона за два дня на одном дыхании.

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

Идеальная пара (The Perfect Couple, первый сезон, 2024). Красиво снятая неинтересная история с никакой детективной составляющей. Такое впечатление, что основной задачей было показать, что за внешним лоском скрывается куча скелетов в шкафах. Это-то показали, но сделали это так, что жалко потраченного на просмотр сериала времени.

Кино вне категории

Затерянные (2024). Пожалуй единственное, что хочется сказать, так это то, что никакой это не "триллер", это чистой воды драма. Похоже, автор фильма пытался вложить какой-то смысл, возможно глубоко личный, в это кино. Но я этого самого смысла не понял.

четверг, 24 октября 2024 г.

[prog.c++] Впечатления от Google-овского sparsetable

Давеча довелось применить sparsetable из Google-овского sparsehash для представления разреженного вектора значений. Разреженный вектор в моем случае -- это вектор с обычной индексацией от 0 до N, где части элементов нет физически. Обращения к элементам идут именно по целочисленным индексам (к тому же индексы в моём случае были представлены std::uint32_t).

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

Тогда как sparsetable показал себя здесь очень и очень хорошо.

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

При том, что класс sparsetable отлично зарекомендовал себя именно как специализированная структура данных, не могу не отметить несколько неприятных особенностей реализации sparsetable, обусловленных как старым C++ стандартом, в рамках которого написан sparsetable (а это C++03), так и подходом к разработке софта в Google.

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

Итак, поехали.

Поскольку sparsetable написан для C++03, то он не поддерживает move semantic. Вообще. Причем как для самого sparsetable -- там нет ни конструктора, ни оператора перемещения, хотя swap для sparsetable есть. Но, самое плохое, sparsetable не поддерживает movable-only типы, вроде std::unique_ptr. Т.е. из коробки не получится хранить в sparsetable экземпляры std::unique_ptr 🙁

Еще sparsetable не поддерживает strong exception safety. Там прямо в комментариях в коде написано, что следовало бы реализовать обработку ситуации, когда конструктор копирования для помещаемого в контейнер объекта бросает исключение. Если такое произойдет, то контейнер останется в хз каком состоянии.

И с exception safety там есть еще один прикольный момент: дело в том, что sparsetable выполняет переаллокацию памяти даже при удалении элемента. Т.е. да, вы вызываете erase, внутри erase sparsetable решает заменить блок из которого элемент изъят блоком меньшего размера, для чего обращается к аллокатору... А аллокатор, в принципе, может бросить исключение. Т.е. из erase может вылететь bad_alloc 🙁 Что неприятно, т.к. время от времени я пишу код, в котором для выполнения отката ранее внесенных изменений при исключении делаются erase для возврата модифицированных контейнеров к исходному виду. Представьте себе что в блоке catch или даже в деструкторе объекта вы вызываете erase для sparsetable, а он бросает bad_alloc 🥴

Ну и работа с памятью там имеет одну важную особенность. По умолчанию sparsetable использует собственный аллокатор под названием libc_allocator_with_realloc. Этот аллокатор, как следует из его названия, полагается на Си-шный realloc при переаллокации блоков данных. Но вот если std::realloc возвращает NULL, то sparsetable просто... прерывает работу программы через вызов std::exit. Понятно, что это особенности Google-овского софта, под нужды которого sparsetable и писался, но блин, представьте себе, что у вас сервер, который держит в ОП информацию о десятках тысяч текущий сессий. И вдруг весь этот сервер одномоментно падает из-за того, что при обработке запроса в рамках одной из сессий не удалось переаллоцировать блок в одном sparsetable. Как-то печально, как по мне 🙁

Плюс к тому исходный sparsetable содержит методы для какой-то странной сериализации/десериализации. Полагаю, что в Google от sparsetable это требовалось. Но зачем это всем остальным -- хз.

И совсем отдельная история -- это отношение sparsetable к несуществующим элементам. Так, константная версия operator[] возвращает константную ссылку. В том числе и на несуществующие элементы! Если значения по индексу i нет, то operator[] вернет константную ссылку на статический объект типа T. Что, помимо прочего, означает, что тип T должен быть default-constructible.

Из-за того, что sparsetable выдает несуществующие элементы за существующие, но с общим дефолтным значением, проистекает и то, что у sparsetable есть два типа итераторов. Обычный итератор, который возвращается посредством begin/end, и который итерируется, в том числе, и по несуществующим элементам. И специальный nonempty-итератор + специальные методы nonempty_begin/nonempty_end, которые следует использовать, если хочется пробежаться только по существующим элементам.

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


В общем, под нужды заказчика sparsetable из sparsehash был вытащен, избавлен от части ненужного хлама, слегка доработан напильником для устранения проблем с компиляцией под C++20 и использования std::allocator. Но до глубокой модернизации sparsetable руки так и не дошли. Однако желание сделать это осталось. Буду надеятся, что это получится сделать.


Если кто-то из читателей никогда не слышал про sparsetable, то впечатление можно составить вот из этого описания: Implementation of sparse_hash_map, dense_hash_map, and sparsetable. Там первая часть как раз sparsetable и посвящена. Описание лаконичное, но толковое.

пятница, 18 октября 2024 г.

[prog.flame] Адекватен ли выбор языка программирования для такой задачи (Rust для Radicle)?

Часто говорят, что язык программирования нужно подбирать под задачу. Мол, не нужно брать C++ для того, что легко делается на Python. И не нужно брать Python там, где потребуется что-то более быстрое и менее ресурсоемкое.

Недавно узнал о Radicle -- это что-то вроде GitLab и Gitea, т.е. инструмент для совместной работы над программным кодом.

Radicle написан на Rust-е.

Не на Python-е. Не на Ruby. Не на Node.js. Не на Java или C#. Не на Go. А на Rust-е.

Как по мне, так это почти тоже самое, что и GitLab, написанный на C++. С поправкой на то, что, во-первых, Rust -- это можно и молодежно. И, во-вторых, для программирования Web-приложений все-таки Rust побезопаснее C++ будет. Но, в общем-то, тоже самое, вид в профиль.

Посему лично я в недоумении и сам бы для проекта, подобного Radicle, точно бы не стал брать C++ или Rust. Как по мне, так здесь достаточно языка со сборкой мусора: Java, Kotlin, C#, возможно даже Go (простите, динамика в лице Python/Ruby/JavaScript идет лесом, т.к. не из тех мазохистов, которые делают что-то большое на динамически-типизированных языках).

А вот брать нативный язык без GC с претензией на околосистемность... Зачем?

Собственно, непонимание и привело к появлению этого поста. Надеюсь, в комментариях мне напихают в панамку и объяснят насколько я дебил и отстал от современных трендов. Ибо я реально не понимаю, почему в 2020-х нужно отказываться от всего, что накопилось в мире безопасных языков с GC и трахать себе мозг Rust-ом в задаче, где не нужна ни супер-пупер производительность, ни супер-пупер экономия ресурсов, ни тотальный контроль за происходящим.


Если не лень, то напишите в комментариях, плиз, какой бы вы язык программирования предпочли для реализации проекта по типу Radicle/GitLab/Gitea. Я бы лично выбирал бы между C#, Kotlin и Go (хотя не на одном из них не программировал), но точно бы не C++ и не Rust.