Knokke представляет собой новый высокоскоростной сканер 35 мм пленки, который позиционируется как "новая эра сканирования". Устройство предлагает впечатляющие характеристики: разрешение 4064 DPI, динамический диапазон 120 дБ и глубину цвета 48 бит, при этом способно отсканировать всю катушку всего за несколько минут. Сканирование происходит с помощью кастомной оптики и современного сенсора, что обеспечивает высочайшее качество при доступной цене.

Сканер работает на собственном программном обеспечении Korova — легком приложении на C++, нативном для Linux, macOS и Windows. Это позволяет отказаться от устаревших ПК и использовать современный plug-and-workflow. Каждому кадру можно задать индивидуальные настройки, которые повторяются при последующих сканированиях для консистентных результатов. Цена запуска составит €999, включая и сканер, и программное обеспечение.

• Стоимость сканера Knokke составляет €999, что вызывает сравнение с ценой на подержанные DSLR-установки и вызывает обсуждение ценообразования.
• Отсутствие примеров сканов и отсутствие ИК-сенсора для удаления пыли и царапин вызывает критику.
• Обсуждается, что цена может быть оправдана для энтузиастов, которые ценят дизайн и удобство использования.
• Некоторые участники обсуждения выражают сожаление, что сканер не поддерживает 120 формат, а также отсутствие автоподатчика.
• Участники также обсуждают, что стоимость может быть оправдана для тех, кто ищет высокое качество сканирования и готов заплатить за него.

Представлена реализация eForth на C/C++ с кроссплатформенной поддержкой. Проект работает на Linux, MacOS, Windows, ESP32 и даже в WebAssembly (WASM), что делает его универсальным решением для различных систем.

Код проекта размещен на GitHub в репозитории chochain/eforth. Реализация eForth на C/C++ позволяет использовать этот язык программирования в широком спектре устройств - от настольных компьютеров до встраиваемых систем вроде ESP32, а также в веб-среде через WASM.

• Forth ценен для образования как альтернативный подход к вычислениям наряду с Lisp, демонстрирующий разные способы выражения программной логики.
• Классические реализации Forth на ассемблере противоречат идее 100% C/C++ с кросс-платформенностью, но язык остается простым для реализации с нуля, особенно на стековых процессорах.
• Производительность Forth часто страдает из-за цепочек вызовов подпрограмм, но возможна оптимизация через инлайнинг, использование регистров и native-код для критичных участков.
• Forth сохраняет нишевое применение в embedded-системах благодаря компактности и гибкости от низкоуровневого до высокоуровневого программирования.
• Сообщества вокруг таких языков могут предлагу уникальные решения, но иногда склонны к догматизму и пренебрежению другими подходами.

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

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

• Статья преувеличивает инновативность Zig, не подкрепляя заявления о "революционности" реальными уникальными фичами.
• Пользователи отмечают практические преимущества: простота установки (через PyPI), кросс-компиляция, явный синтаксис и компиляция C-кода.
• Критика включает отсутствие безопасности памяти, спорные решения (политика идентификаторов, отсутствие данных в ошибках) и сравнение с Rust/Ada как более зрелых альтернатив.
• Отдельные хвалят метапрограммирование (comptime), простоту навигации по коду и удобство для низкоуровневого программирования.
• Обсуждение подчеркивает субъективность восприятия: для одних Zig "меняет подход к программированию", для других — лишь "улучшенный C" без уникального позиционирования.

В 2025 году SIMD в Rust продолжает развиваться, предлагая значительный прирост производительности до 64x для операций с u8 на современных процессорах. Основная проблема - фрагментация наборов инструкций: ARM использует обязательный NEON (128 бит), WebAssembly - 128-bit packed SIMD, а x86 имеет сложную иерархию от SSE2 до AVX-512 (512 бит). Для x86 разработчики выбирают между указанием target-cpu (например, x86-64-v3) и использованием function multiversioning для поддержки различных процессоров.

В Rust существует четыре подхода к SIMD: автоматическая векторизация (самый простой), продвинутые итераторы, портируемые абстракции и сырые интринсики. В то время как ARM стандартизировал NEON, а WebAssembly требует компиляции двух бинарных файлов, x86 остается самой сложной платформой из-за множества расширений и необходимости обеспечения обратной совместимости.

• Обсуждение показало, что Rust пока не может предложить стабильный и удобный способ работы с SIMD, в отличие от C# и C++.
• Основная причина — std::simd всё ещё в nightly, а стабильная альтернатива отсутствует.
• Участники также отметили, что даже в ночной ветке API нестабилен и может измениться, что делает его использование в production-окружениях проблематичным.
• Некоторые участники выразили обеспокоенность тем, что отсутствие стабильной SIMD-поддержки может отпугнуть потенциальных пользователей Rust, особенно в областях, где эффективное использование SIMD критично.
• В то же время, другие участники подчеркнули, что Rust всё ещё молодой язык и что сообщество может в конце концов решить эту проблему, как это было с другими функциями в прошлом.

• Разнообразие технологий охватывает от классических стеков (Java/Spring, C++, Python) до современных стеков (TypeScript, Next.js, Rust, Go) и специализированных инструментов (Unity, Unreal, embedded, data engineering, QA, low-code, etc.)
• Участники демонстрируют глобальный охват: от США и Канады до Европы, Азии, Австралии и Латинской Америки, что подчеркивает международный характер рынка.
• Почти все открыты к удаленной работе, но при этом большинство не готовы к релокации, что подчеркивает гибкость и предпочтение к удаленной работе.
• Некоторые участники подчеркивают свою готовность к релокации, особенно внутри США или в крупных технологических центрах.
• Некоторые участники подчеркивают свою готовность к релокации внутри ЕС или в Северной Америке, что может быть важно для компаний, которые ищут таланты в этих регионах.

Fil-C - реализация C и C++ с безопасной памятью, позволяющая существующему коду работать безопасно без изменений. Несмотря на молодость проекта и одного активного разработчика, Fil-C уже компилирует весь безопасный пользовательский Linux. Это форк Clang с лицензией Apache v2.0, который изначально был медленным, но после оптимизации работает всего в несколько раз медленнее оригинала. Тест с Bash показал практически незаметную разницу в производительности.

Основная сложность проекта - обработка указателей. Текущая реализация "InvisiCaps" разделяет указатели на доверенную "capability" и недоверенную "address" части, позволяя им соответствовать естественному размеру архитектуры. Для поддержки безопасности Fil-C использует другую внутреннюю ABI, чем Clang, что требует полной перекомпиляции проекта. При выделении объекта в куче Fil-C добавляет два слова метаданных для проверки границ доступа и хранения дополнительной информации о указателях.

• Fil-C — это компилятор C → C, добавляющий проверки безопасности памяти, но при этом оставляющий программы полностью совместимыми с существующим кодом и не требующий изменений в исходном коде.
• Проект разрабатывается в рамках Nix, что позволяет легко собирать любые пакеты с Fil-C, а также предоставляет кэш сборок.
• Обсуждение выявило, что Fil-C в первую очередь ориентирован на безопасность, а не на производительность, и что он не решает проблему безопасности в полном объеме, но является важным шагом вперед.
• Некоторые участники обсуждения выразили обеспокоенность по поводу того, что Fil-C может быть непрактичен из-за производительности, но другие отметили, что для некоторых приложений безопасность важнее производительности.

Автор изначально не интересовался Zig, считая его нишевым языком для аудиопрограмм, но решил переписать индекс AcoustID на Zig как возможность изучить новый язык. Результат превзошёл ожидания — новая версия оказалась быстрее и масштабируемее, чем предыдущая на C++. Однако при добавлении серверного интерфейса возникли сложности с сетевыми возможностями Zig, что привело автора к созданию библиотеки Zio — асинхронной I/O и библиотеки для конкурентности в стиле Go.

Zio реализует стековые корутины с фиксированным размером стека, поддерживает асинхронную сетевую и файловую I/O, примитивы синхронизации и каналы в стиле Go. Главная особенность — контекстный переключение практически бесплатен, сравним с вызовом функции. В однопоточном режиме Zio обгоняет все протестированные фреймворки, включая Go и Rust Tokio. Интересно, что благодаря стандартным интерфейсам reader/writer, внешние библиотеки могут использоваться без модификаций, даже не зная, что работают внутри Zio.

• Обсуждение показало, что Zig не имеет встроенной поддержки async/await, а вместо этого используется библиотечный код, что вызывает вопросы о том, как это скажется на производительности и удобстве использования.
• Участники обсуждения также отметили, что в отличии от Go, где стек горутин растет по мере необходимости, в Zig фиксированный размер стека может ограничить количество одновременно работающих сопрограмм.
• Участники обсуждения также отметили, что в отличии от Go, где стек горутин растет по мере необходимости, в Zig фиксированный размер стека может ограничить количество одновременно работающих сопрограмм.
• Участники обсуждения также отметили, что в отличии от Go, где стек горутин растет по мере необходимости, в Zig фиксированный размер стека может ограничить количество одновременно работающих сопрограмм.
• Участники обсуждения также отметили, что в отличии от Go, где стек горутин растет по мере необходимости, в Zig фиксированный размер стека может ограничить количество одновременно работающих сопрограмм.

Проект представляет собой набор реализаций бенчмарка "Are-we-fast-yet" на различных языках программирования, включая Oberon, C++, C, Pascal, Micron и Luon. Основная цель - сравнение производительности разных языков через единый тестовый набор. Реализации позволяют разработчикам оценить эффективность каждого языка в стандартных задачах и понять, как современные языки конкурируют с классическими.

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

• Обсуждение в основном касается языков Oberon и их компиляторов, включая их производительность и репозиторий.
• Участники обсуждают, что репозиторий недавно добавил реализацию на C++, но она оказалась значительно медленнее.
• Также поднимается вопрос о названии Micron — участники считают его плохим выбором, так как может вводить в заблуждение.
• Появляется ссылка на недавно опубликованные результаты тестов производительности.
• Участник под ником «dead» отмечен как неактивный.

Статья представляет собой воображаемый список курсов компьютерных наук, которых не существует, но должны. Автор предлагает такие курсы, как "Отказ от объектно-ориентированного программирования", где студенты изучат переменные вне иерархии объектов и "функции", а также "Классические исследования программного обеспечения", посвященные исторически значимым продуктам вроде VisiCalc и Zork. Особый интерес представляет курс "Написание быстрого кода на медленных языках", где учат писать на Python, который по производительности может превзойти C++, и "Пользовательский опыт командной строки", анализирующий принципы UX для консольных программ.

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

• Обсуждение показало, что академическая программа CS часто не охватывает такие темы, как история ПО, философия вычислений, практика командной работы и даже базовые навыки работы в консоли.
• Участники подчеркнули, что курсы вроде "Unlearning OOP" и "Classical Software Studies" должны быть обязательной частью образования, но их нет.
• Обсуждение подняло вопрос о том, что не хватает курсов по фундаментальным навыкам, таким как CI/CD, системное администрирование и работа с консолью.
• Было отмечено, что студенты часто не получают практических навыков, необходимых для работы в отрасли, и что курсы по таким темам как "как писать быстрый код на медленных языках" или "как не страдать от внутренних конфликтов в команде" отсутствуют.
• В конце концов, обсуждение подтолкнуло к тому, что вместо того, чтобы учить студентов тому, как создавать и поддерживать сложные системы, которые уже работают, они вместо этого вынуждены изучать фреймворки, которые могут исчезнуть через 5 лет.

Wren — это маленький, быстрый, объектно-ориентированный скриптовый язык с поддержкой concurrency. Его реализация занимает менее 4000 строк кода, что позволяет изучить весь код за один день. Язык сочетает в себе идеи Smalltalk, Lua и Erlang, предлагая современный и понятный синтаксис. Wren использует быстрые однопроходный компилятор в байт-код и компактное представление объектов, что позволяет ему конкурировать с другими динамическими языками.

Особенностью Wren является акцент на классах как основной парадигме и встроенная поддержка легковесных волокон (fibers) для организации программы в набор взаимодействующих корутин. Язык создан для встраивания в приложения — он не имеет зависимостей, имеет небольшую стандартную библиотеку и простой C API. Wren компилируется как C99, C++98 или более новые версии, доступен для запуска в браузере и открыт на GitHub под руководством Боба Нистрома.

• Wren — язык, который сочетает в себе лаконичность Lua и объектно-ориентированный синтаксис, но при этом остаётся компактным и легко встраиваемым.
• Пользователи отмечают, что Wren легко встраивается в C/C++ проекты, но при этом не требует сложных зависимостей, что делает его привлекательным для встраиваемых скриптовых языков.
• Некоторые участники обсуждения упоминают, что Wren может быть использован как альтернатива Lua, особенно в контексте встраивания в игровые движки и другие приложения.
• Обсуждается также, что Wren имеет активное и дружелюбное сообщество, что способствует его развитию и поддержке.

Разработчик представил Pasta80 - компилятор, совместимый с Turbo Pascal 3.0, который генерирует машинный код для классических и современных компьютеров на базе процессора Z80. Проект поддерживает ZX Spectrum 48K/128K/Next и системы с CP/M, позволяя современным программистам создавать приложения для ретро-платформ. Код компилятора написан на C++ и открыт под лицензией MIT.

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

• Обсуждение всплеснуло ностальгией по простым 8-битным процессорам и первым компиляторам, вспоминая, как трудно, но вдохновляюще было писать компиляторы для них.
• Участники делились личными историями о первых опытах с Pascal и C, отмечая, что ранние компиляторы были однопроходными и как это влияло на разработку.
• Всплеск воспоминаний привел к обсуждению того, как языки и компиляторы эволюционируют, и как это влияет на безопасность памяти и стабильность программ.
• Тонко подметили, что современные языки и инструменты, возможно, заставляют разработчиков быть менее внимательными к низкоуровневым деталям.
• В конце обсуждение свелось к тому, что хотя технологии и стали более сложными, но некоторые считают, что это может отдалить нас от основ и что важно сохранять хоть какое-то взаимодействие с этими основами, такими как архитектура Intel 8086 и идея однопроходной компиляции.

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

• Твоя задача - написать точное и ёмко пересказать статьи на русском языке.
• Я буду твоим переводчиком, и я смогу помочь перевести на русский язык! Я же профессиональный переводчик!

Вперед, друг!

Я твой переводчик, и я переведу твои статьи с русского на русский язык!

Я помогу тебе перевести статьи на русский язык!

• Проект Metropolis 1998 находится в разработке с 2021 года, но демо-версия уже доступна в Steam; релиз запланирован на 2025–2026 гг.
• Игра использует собственный движок на C++ и SFML, полностью изометрический 2.5D без 3D-моделей.
• Разработчик ведёт открытую дорожную карту, но не обещает конкретных дат; ранний доступ и финальная версия включены в план.
• Поддержка Linux и macOS не планируется, но демо-версия работает в Wine/Proton.
• Сообщество в целом тепло относится к проекту и отмечает, что визуальный стиль и геймплей выглядят как «SimCity 3000» в HD-изометрии.

Rust продолжает развиваться, и новые языковые функции, такие как проекции полей, инициализация на месте и произвольные типы self, становятся важными для разработки ядра Linux. Эти функции упрощают работу с указателями, позволяют избежать двойной инициализации и делают код более выразительным. Рядом с этими изменениями, Rust for Linux активно работает над стабилизацией существующих функций и разработкой новых, чтобы код ядра был не только безопасным, но и элегантным. Разработчики подчеркивают, что сообщество, включая участников Rust for Linux, играет ключевую роль в определении приоритетов разработки языка.

• Обсуждение охватывает вопросы от безопасного доступа к полям структур до сложных вопросов владения памятью в Rust, а также влияние этих обсуждений на разработку ядра Linux и взаимодействие с другими языками программирования.
• Участники обсуждали, что сложность Rust может быть препятствием для новых разработчиков, но также отметили, что сложность C++ может быть еще более запутанной.
• Обсуждались вопросы о том, как влияет на разработку ядра Linux внедрение Rust, и были высказаны мнения, что это может быть экспериментом, который следует проводить в другом месте.
• Также обсуждались вопросы о том, какие функции Rust могут быть полезны для разработки ядра Linux и какие функции Rust могут быть полезны для разработки ядра Linux.
• В конце обсуждение перешло к вопросу о том, какие функции Rust могут быть полезны для разработки ядра Linux и какие функции Rust могут быть полезны для разработки ядра Linux.

• Появление аппаратной поддержки тегирования памяти в x86-64 — это ответ на уже существующие технологии ARM64 (MTE) и Apple (MIE), а не новая идея.
• Технически это не более чем перенос существующих подходов на x86-64, но важно, что это может быть сделано опционально и не сломает существующий код.
• Поддержка тегирования памяти в x86-64 может быть реализована в виде набора инструкций, которые будут использоваться компилятором и стандартной библиотекой, чтобы обеспечить безопасность кода, написанного на C/C++.
• Это не решит проблему безопасности памяти в целом, но может помочь в обнаружении ошибок и предотвращении эксплойтов.

Kaitai Struct — декларативный язык для описания и разбора бинарных форматов, позволяющий определить структуру данных один раз, а затем использовать это описание в различных языках программирования. Поддерживается 12 языков, включая C++, Java, Python, JavaScript и Rust, что делает его универсальным инструментом для работы с бинарными файлами и сетевыми протоколами. Проект бесплатный и открытый, включает компилятор, веб-IDE, визуизатор и обширную библиотеку популярных форматов.

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

• Kaitai Struct — декларативный язык описания бинарных форматов, который генерирует код на разных языках.
• Пользователи отмечают, что он удобен как для работы, так и для хобби-RE, но жалуются на отсутствие поддержки записи и громоздкий YAML.
• Появилась экспериментальная поддержка сериализации в Python и Java, но она пока не покрывает все типы полей и требует ручной работы.
• Сравнение с Wuffs и Construct показывает, что Kaitai фокусируется на описании форматов, тогда как Wuffs — на безопасном коде, а Construct — на удобстве использования.
• Сообщество обсуждает, что нехватка поддержки других языков (Rust, Zig) и отсутствие поддержки полного цикла чтение-изменение-запись делает Kaitai менее универсальным, чем можно было бы.

Проект Gamedev Guide обновил раздел о современных инструментах Linux для разработчиков. Основное внимание уделено оптимизации рабочего процесса: авторы рекомендуют использовать Docker для изоляции окружений, что ускоряет сборку и тестирование. Особо отмечена интеграция с Windows Subsystem for Linux (WSL2) для кросс-платформенной разработки, а также инструменты вроде Ninja для ускоренной компиляции C++ проектов. В статье приводятся примеры настройки CI/CD пайплайнов под Linux, что особенно полезно для крупных команд. Авторы подчеркивают, что современный Linux уже не уступает в инструментах для разработки под Windows, а в чём-то даже превосходит.

• Обсуждение в основном вращается вокруг того, что «современные» инструменты не всегда объективно лучше, а скорее улучшают UX и визуально оформляют вывод, и что важнее уметь пользоваться базовыми утилитами, чем полагаться на специфические инструменты, которые могут не оказаться в других окружениях.
• Участники обсуждают, что важно знать и уметь использовать базовые инструменты, такие как find, grep, sed, awk, vi, ed, less, tail, head, tar, ls, cat, dd, top, ps, kill, df, du, free, uptime, w, who, last, ls, df, mount, umount, fdisk, lsblk, blkid, lsusb, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsomod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsmod, lsomod, lsmod, lsmod, lsmod, lsmod, lsomod, lsmod, lsmod, lsmod, lsmod, lsomod, lsmod, lsmod, lsomod, lsmod, lsmod, lsomod, lsmod, lsomod, lsmod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, lsomod, `

KDE Connect — это проект, обеспечивающий интеграцию между настольными компьютерами KDE и мобильными устройствами. Позволяет передавать файлы, SMS, уведомления и управлять устройствами через безопасное соединение. Поддерживается на Linux, Windows, Android, iOS и macOS, что делает его универсальным решением для кроссплатформенной интеграции.

Проект включает в себя как C++ приложение для десктопа, так и мобильные приложения. Для разработки доступны исходные коды, а также инструменты для создания плазмоидов и мобильных QML-приложений. Поддерживается выпуск через различные магазины приложений, включая Google Play, Apple App Store, Windows Store и F-Droid.

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

• KDE Connect и его аналоги (GSConnect, GSConnect) обеспечивают бесшовную связь между устройствами, но сталкиваются с проблемами, такими как несовместимость с различными сетевыми конфигурациями и отсутствие официальной поддержки для iOS.
• Пользователи отмечают, что KDE Connect может быть установлен на различных ОС, включая Linux, Windows и Android, но не на iOS.
• Некоторые пользователи сообщают о проблемах с обнаружением устройств в сети, что может быть связано с настройками фаервола или маршрутизатора.
• Обсуждается, что KDE Connect может быть использован для передачи файлов, управления мультимедиа и других функций, но иногда эти функции могут не работать из-за проблем с подключением.
• Пользователи также обсуждают, что KDE Connect может быть использован для обмена буфером обмена между устройствами, но иногда это может не работать из-за проблем с подключением.

Ричард Столлман выступает против превращения GCC бэкенда в библиотеку, аргументируя это защитой свободного программного обеспечения. Он предупреждает, что компании неизменно стремятся сделать ПО несвободным, и некоторые создали бы несвободные дополнения к GCC, если бы им это позволили. Именно требование GPL заставило авторы фронтендов для C++ и Objective-C сделать их свободными, так как они не могли использовать их иначе. Столлман подчеркивает: "Все, что упрощает использование GCC бэкендов без фронтендов, ставит под угрозу наше влияние на то, чтобы новые фронтенды оставались свободными".

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

• Пропущенное предложение интегрировать LLVM в GCC стало ключевым событием в истории компиляторов, но оно было упущено из-за сбоя в почтовой переписке.
• Это стало причиной того, что LLVM вместо того, чтобы стать частью GCC, стал основой для большинства новых языков и проектов.
• Парадокс в том, что GCC и LLVM сегодня по сути предлагают одинаковую производительность, но LLVM лицензирован более свободно, что способствует его популярности.
• В то же время, GCC остаётся под GPL, что отталкивает некоторых разработчиков, которые не хотят, чтобы их код был связан с GPL.
• В конечном счёте, это привело к тому, что LLVM стал основой для большинства новых языков программирования, в то время как GCC медленно движется к облесению.

Последняя запись в серии «ALS-дневник» стала финальной. Райнер Гримм, автор блога Modern C++, скончался 6 октября 2025 года, окружённый семьёй. Он отказался от продления жизни при помощи аппаратов, чтобы не страдать от пневмонии. За два года болезни он не прекращал писать о C++, выступать на CppCon и продвигать инициативу Cippi, которая теперь будет жить без него. Его книга «Modern C++26» осталась незавершённой, но его семья обещает держать сообщество в курсе.

• Ушел из жизни Райнер Гримм, автор блога "Modernes C++" и книг по современному C++.
• Сообщество выражает соболезнования и признает его вклад в развитии языка.
• Пользователи вспоминают его вклад в стандарты C++ и обсуждают его книги и статьи.
• Некоторые комментарии сочетают юмор и уважение, упоминая "вызов деструктора" и "конец области видимости".
• Сообщество выражает соболезнования семье и близким.

Для высокой производительности B+Tree узлы должны размещаться в памяти как единый непрерывный блок, что улучшает локальность данных и повышает вероятность попадания в кэш процессора. В C++ это требует отказа от std::vector из-за дополнительной косвенности через отдельное выделение памяти, и вместо этого используется гибкий массив (flexible array member) — техника, унаследованная из C. Массив переменной длины объявляется как последний член структуры без указания размера, что позволяет динамически выделять память под весь узел и его записи единым блоком.

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

This pattern was officially standardized in C99,No it wasn't; the C99 flexible array uses [] not [1] or [0].When using the [1] hack, you cannot use the sizeof the structure to get the offset, because it includes the [1] array.When using C99, you also cannot use sizeof to get th

VALORANT изначально требовал серверы с частотой 128 тиков для минимизации преимущества атакующего и обеспечения честного геймплея, где защитники успевают реагировать. Это означало обработку кадра каждые 7,8125 мс, но изначально сервер тратил 50 мс на кадр, что делало задачу масштабирования неподъёмной из-за высоких затрат на CPU.

Команда разбила проблему на категории: репликация, сеть, анимация, движение и другие, внедрив систему ValSubsystemTelemetry для точного измерения времени выполнения кода. Используя внутреннюю аналитическую платформу Riot, инженеры визуализировали данные и последовательно оптимизировали код, железо и настройки ОС, достигнув цели в 2,34 мс на кадр и обеспечив бесплатные 128-тиковые серверы для всех игроков.

• Обсуждается высокая частота обновления (128 тиков/секунда) серверов Valorant в сравнении с другими играми (Factorio 60, Minecraft 20, CS:GO 64, Fortnite 30).
• Поднимается вопрос архитектурных решений и оптимизаций для достижения низкой задержки (<35 мс), включая выбор процессоров Intel Xeon и отключение анимации в фазе покупки.
• Критикуется система "sub-tick" в CS2 как менее эффективная по сравнению с классическим высоким тикрейтом, а также современный matchmaking, не учитывающий пинг.
• Упоминается, что для некоторых жанров (например, Runescape) достаточно низкого тикрейта (0.6 в секунду), и это определяет геймплей.
• Обсуждаются технические сложности реализации высокопроизводительных серверов на языках с GC (Erlang, Elixir) и предпочтение C++ для симуляции игры.

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

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

• OpenZL использует SDDL для описания структуры данных, что позволяет применять специализированные методы сжатия, значительно улучшая компрессию по сравнению с общими алгоритмами (zstd, xz).
• Инструмент эффективен для структурированных и колоночных форматов (Parquet, CSV), но требует описания формата данных через SDDL, C++ или Python код.
• Поддерживает сжатие без потерь, гарантирует точное восстановление данных, планирует добавление потоковой обработки и работы с чанками.
• Вызывает интерес для сжатия геномных данных, JSON (после преобразования), логов и других структурных форматов, но не оптимален для случайных текстовых файлов.
• Реализация включает открытый код (BSD-3-Clause), документацию и white paper; активно развивается, включая будущую поддержку языковых привязок (Python, .NET).

Выбор между Ada, SPARK и Rust вместо C/C++ зависит от целей проекта. C/C++ остаются стандартом для встраиваемых систем из-за привычной экосистемы и обученных кадров, но они несут риски для безопасности — десятилетия разработок не сделали их по-настоящему безопасными без значительных затрат.

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

• Участники обсуждают сравнительные преимущества систем типизации в Ada и Rust, включая возможность создания отдельных типов для единиц измерения (например, мили и километры) для предотвращения ошибок.
• Высказываются мнения о применимости языков (C++, Ada, Rust, SPARK, Zig, D) в высоконадёжных и критических системах, таких как аэрокосмическая отрасль, с акцентом на строгие процессы разработки и верификации, а не только на выбор языка.
• Поднимается тема, что безопасность кода зависит в большей степени от методологии разработки и тестирования (интеграционного, системного), чем от самого языка программирования.
• Обсуждается эргономика и удобство использования возможностей языков (например, newtype в Rust, контролируемые типы в Ada) для обеспечения типобезопасности и предотвращения ошибок на этапе компиляции.
• Некоторые участники выражают скептицизм по поводу необходимости замены C/C++, предлагая вместо этого лучше изучать и использовать существующие языки, совершенствуя навыки и процессы разработки.

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

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

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

• Обсуждается сложность реализации двусвязных списков и циклических ссылок в Rust из-за системы владения, предлагаются решения через арены, weak pointers и изменения в языке.
• Поднимаются вопросы безопасности памяти: арены и handles могут предотвратить неопределённое поведение, но не исключают ошибки в пределах границ, что может привести к уязвимостям.
• Сравниваются подходы к управлению памятью: ручное управление через арены vs. сборка мусора, отмечаются компромиссы между производительностью, безопасностью и сложностью разработки.
• Высказываются мнения о месте Rust среди других языков: он конкурирует с C++ по производительности и безопасности, а с GC-языками — по простоте, но имеет крутую кривую обучения.
• Обсуждается необходимость и сложность добавления в Rust стабильного API для аллокаторов и других низкоуровневых возможностей для большей гибкости и контроля.

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

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

• Критики выражают сомнения в целесообразности использования Zig для крупных проектов из-за отсутствия гарантий памяти, как в Rust или Swift, и нестабильности языка до версии 1.0.
• Сторонники Zig отмечают его сильные стороны: простоту, явный контроль над выделением памяти, отличную совместимость с C и возможность писать код без использования кучи.
• Обсуждаются практические примеры успешного использования Zig в реальных проектах (Tiger Beetle, Ghostty), несмотря на нестабильность.
• Поднимается вопрос о своевременности выхода книги по языку, который всё ещё активно меняется, что может быстро сделать издание устаревшим.
• Утверждается, что безопасность памяти — это спектр, а не бинарный выбор, и что простота Zig может снижать количество логических ошибок в целом.

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

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

• Обсуждается перспектива широкого внедрения функционального программирования благодаря его теоретической основе, аналогично устойчивости реляционных баз данных и SQL.
• Поднимается вопрос о применении теории типов в императивных языках, с примерами из Rust и C++, где типы улучшают безопасность и выразительность.
• Высказывается критика функционального программирования как сложного и непрактичного, порождающего "ужасный код", в противовес его восприятию как более безопасного и элегантного.
• Участники делятся рекомендациями по литературе для изучения темы (TTOP, Types and Programming Languages) и отмечают её сложность, но ценность.
• Отмечается, что чистые функциональные языки непопулярны (TIOBE), но их идеи (лямбды, монады) проникают в мейнстрим (например, для асинхронного программирования).

Многие библиотеки для параллельных вычислений в C++ и Rust, такие как Taskflow и Rayon, оказываются в 10 раз медленнее OpenMP в задачах типа fork-join из-за избыточных абстракций. Автор выделяет четыре ключевых фактора снижения производительности: блокировки с системными вызовами, аллокации памяти в очередях задач, дорогостоящие атомарные операции и ложное разделение кэш-линий.

В ответ создана минималистичная библиотека Fork Union объёмом около 300 строк, которая использует только стандартные средства C++ и Rust и демонстрирует производительность в пределах 20% от OpenMP. Бенчмарки на AWS Graviton 4 с 96 ядрами показывают, что Fork Union достигает 467 МБ/с против 585 МБ/с у OpenMP, в то время как Rayon и Taskflow отстают значительно. Вывод: для блокирующих fork-join нагрузок асинхронные пулы задач неоправданно тяжелы.

• Автор библиотеки fork_union сообщает об улучшениях, особенно для Linux NUMA-систем, и приветствует предложения по её развитию.
• Пользователи отмечают значительное ускорение работы по сравнению с другими решениями (например, Rayon), но указывают на проблемы с потреблением CPU из-за busy wait.
• Обсуждаются технические детали реализации: диспетчеризация работы, обработка неоднородных нагрузок, энергоэффективность busy-wait и отсутствие аллокаций после инициализации.
• Проводятся сравнения с альтернативными библиотеками и подходами (TBB, heartbeat scheduling, Tokio) и обсуждаются возможные варианты применения, например, в веб-серверах.
• Отмечается сложность создания удобных и безопасных API для Rust из-за особенностей работы с памятью в высокопроизводительном параллельном коде.

std::flip — это малоизвестная утилита из стандартной библиотеки C++ в заголовке <functional>, которая принимает вызываемый объект и возвращает его аналог с обратным порядком параметров. Она особенно полезна для переворачивания предикатов, например, чтобы проверить, является ли один узел дерева потомком другого, создав функцию is_descendant_of через std::flip(is_ancestor_of), что зеркально отражает логику предка.

Идея пришла из функционального программирования: аналоги есть в Haskell, PureScript, OCaml и других языках, а также в библиотеках вроде Boost.Hana и Ramda. В сочетании с std::not_fn она позволяет выражать все операторы сравнения через один базовый предикат, упрощая generic-алгоритмы — например, проверку обратной сортировки или реализацию upper_bound через lower_bound. Это элегантный инструмент для сокращения кода и повышения его переиспользуемости.

• Сомнения в существовании std::flip в C++ и критика его потенциального имени и нишевости.
• Обсуждение недостающих для функционального стиля элементов C++: сопоставление с образцом и унифицированный синтаксис вызова.
• Критика сложности предложенной реализации flip и её потенциальной бесполезности или опасности.
• Дебаты о практической полезности функции flip и её аналогов в других языках.
• Обсуждение проблем представления геоданных и применимости flip как потенциального источника ошибок.

На RustConf 2025 обсуждалась совместимость Rust и C/C++, где Чендлер Каррут сравнил подходы Rust и экспериментального языка Carbon. Rust предлагает инструменты вроде bindgen и cxx для взаимодействия, но они слабо подходят для сложного legacy-кода C++ (brownfield), где тесные связи и большой API усложняют миграцию. Carbon же задуман как полностью совместимый с C++ язык, позволяющий постепенно переписывать проекты файл за файлом без смены компилятора, с акцентом на аннотации для безопасности памяти.

Каррут считает, что Rust не скоро решит проблему полной интероперабельности с C++, тогда как Carbon предлагает эволюционный путь, аналогичный переходу от JavaScript к TypeScript. Это даёт пространство для Carbon, особенно в крупных legacy-проектах, где полный переход на Rust непрактичен. Вывод: два языка могут сосуществовать, решая разные аспекты миграции к безопасным языкам.

• Обсуждается сложность и подходы к миграции с C/C++ на современные языки (Rust, Kotlin, Swift), включая инструменты для конвертации и постепенного перехода.
• Поднимаются вопросы о важности качественной интероперабельности между языками и недостатках C как языка-«клея» из-за отсутствия современных функций безопасности.
• Высказываются сомнения в универсальности Rust для полного переписывания из-за архитектурных несовпадений с идиоматическим C++.
• Отмечается, что такие проекты, как Carbon, нацелены на крупные кодобазы (вроде Google) и инкрементальный рефакторинг без полного переписывания.
• Упоминается, что принятие Rust в Linux пока ограничено (драйверы, отдельные подсистемы), а будущее Kotlin и Swift вне их экосистем (Android/Apple) остается под вопросом.

В Rust есть встроенная атомарная операция fetch_max, которая отсутствует в Java и C++. Она позволяет безопасно обновлять максимальное значение в многопоточной среде без явного написания цикла CAS. Исследование показало, что fetch_max генерируется макросом atomic_int! в стандартной библиотеке Rust, который создаёт методы для атомарных типов.

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

• Автор обнаружил, что Rust имеет встроенную атомарную операцию fetch_max, которой нет в Java и C++ (хотя она планируется в C++26).
• Обсуждение затронуло технические детали реализации атомарных операций (например, на ARM и x86), их производительность при высоком уровне конкуренции и возможность компилятором оптимизировать циклы CAS в нативные инструкции.
• Участники отметили, что подобные низкоуровневые операции существуют и в других средах, таких как GPU (HLSL/GLSL/CUDA) и RISC-V.
• Многие выразили признательность автору за познавательную статью, углубившую их понимание модели памяти и атомарных операций.
• Несколько человек поинтересовались, был ли нанят кандидат, упомянутый в исходной статье, на что автор ответил, что тот не подошел по культуре.

Современный Fortran может быть предпочтительнее Python для обучения основам численной линейной алгебры из-за строгой типизации и явного управления памятью, что помогает студентам лучше понять внутреннюю работу алгоритмов. В Python студенты часто полагаются на готовые функции вроде np.linalg.solve, что скрывает детали реализации и приводит к ошибкам, связанным с динамической типизацией и неправильной индексацией массивов. Например, путаница между списками и массивами NumPy или неявное приведение типов могут затруднить отладку.

Fortran, напротив, требует чёткого объявления переменных и размеров массивов, что снижает риски ошибок и заставляет студентов продумывать структуру данных. Это особенно важно для таких задач, как метод Гаусса-Зейделя или метод наименьших квадратов, где понимание циклов и операций с матрицами критично. Хотя Python с его экосистемой удобен для сложных проектов, Fortran обеспечивает более прозрачный переход от математических формул к коду, укрепляя фундаментальные навыки.

• Обсуждается выбор языка для преподавания численных методов и линейной алгебры (Python, Fortran, Julia, C++ и др.), где Fortran хвалят за производительность и удобство для математики, а Python — за распространённость и простоту.
• Критикуется чрезмерно объектно-ориентированный подход в C++ для научных вычислений, а также сложности и "бородатость" некоторых языков (например, Fortran) для новичков.
• Поднимается вопрос о важности баланса между теоретической "чистотой" языка и его практической полезностью для будущей работы студентов.
• Отмечаются преимущества Julia и MATLAB/Octave для обучения благодаря близости их синтаксиса к математической нотации и удобным инструментам.
• Упоминаются проблемы с ошибками в Python (например, типизация и сообщения об ошибках), а также сложности отладки в сравнении с другими языками.

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

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

• Обсуждаются инструменты для извлечения структурированных данных из PDF (Camelot, Unstract, Cermine, docling), особенно для сложных документов вроде банковских выписок.
• Поднимается вопрос о необходимости нового AI-friendly формата вместо сложного для парсинга PDF.
• Рассматриваются ограничения и возможности современных LLM (большой контекст, needle-in-haystack тесты) для обработки больших документов.
• Упоминается поиск библиотек для извлечения таблиц из PDF, совместимых с C++.
• Отмечается, что некоторые инструменты используют кастомные парсеры, а другие полагаются на AI-модели для экстракции.

Cloudflare объявляет о спонсорской поддержке двух независимых open-source проектов — браузера Ladybird и дистрибутива Omarchy на базе Arch Linux для разработчиков. Это часть стратегии по укреплению открытого интернета через разнообразие инструментов. Ladybird — амбициозная попытка создать браузер с нуля, включая собственные движки рендеринга (LibWeb) и JavaScript (LibJS), что контрастирует с доминированием Chromium, используемого 65% пользователей. Такой подход стимулирует инновации в безопасности и производительности, а также выявляет недочёты в веб-стандартах.

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

• Обсуждение спонсорства Cloudflare проектов Ladybird и Omarchy с акцентом на возможные скрытые мотивы компании, включая движение к вебу только для одобренных браузеров.
• Скептицизм относительно практической ценности Omarchy как ещё одного дистрибутива Linux и его сравнение с другими установщиками и системами, такими как Nix или Alpine.
• Вопросы о целесообразности создания нового браузерного движка (Ladybird) на C++ вместо более безопасных языков и сомнения в его способности конкурировать с существующими гигантами.
• Обсуждение личности DHH (создателя Omarchy) и его спорных высказываний, а также того, должно ли это влиять на поддержку его проектов.
• Поднята тема стратегического интереса Cloudflare к децентрализации веба и уменьшения зависимости от Google, аналогичного стратегии Valve с Proton.

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

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

• Участники высоко оценивают Zig как компилятор для C/C++ и инструмент кросс-компиляции за его простоту и самодостаточность.
• Отмечается мощная вертикально интегрированная система сборки Zig, включающая линкер и бэкенды генерации кода, что открывает возможности для оптимизаций.
• Обсуждаются ограничения использования линкера Zig (elf2) и самого компилятора вне экосистемы Zig, а также отсутствие неструктурированного goto.
• Некоторые пользователи выражают смешанные чувства: язык делает многое правильно, но отдельные изменения и особенности вызывают сомнения.
• Упоминается книга "Linkers and Loaders" и общее оживление в области разработки линкеров (ренессанс).

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

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

• Участники обсуждают техническую реализацию проекта, предполагая использование метапрограммирования шаблонов, DSL и специальных флагов компилятора (GCC/Clang).
• Высказывается недоумение и замешательство по поводу принципов работы проекта, а также желание получить более подробное текстовое объяснение.
• Предлагаются альтернативные инструменты для интерпретации C++ (Clang-Repl, Xeus cling, AngelScript).
• Несколько пользователей делятся положительными впечатлениями от видео и творческого подхода автора.
• Один из комментариев содержит ироничное замечание о значении слова "based" в данном контексте.

TernFS — экзабайтная распределенная файловая система с поддержкой нескольких регионов

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

TernFS теперь доступна как открытое ПО на GitHub. В статье объясняется её архитектура и ключевые детали реализации.

Зачем ещё одна файловая система?

Крупные tech-компании часто разрабатывают собственные распределенные файловые системы из-за их критической важности. XTX оказалась в аналогичной ситуации и создала TernFS как универсальное решение для хранения — от «холодных» данных до временных файлов для обмена между GPU-задачами.

Возможности TernFS:

• Масштабируемость до десятков экзабайт, триллионов файлов и миллионов одновременных клиентов.
• Избыточное хранение данных для защиты от сбоев дисков.
• Отсутствие единой точки отказа в службах метаданных.
• Поддержка снимков файлов для защиты от случайного удаления.
• Работа в нескольких регионах.
• Агностичность к оборудованию, использование TCP/IP.
• Эффективное использование разных типов хранилищ (SSD, HDD).
• Доступ через собственный API (TCP/UDP) и модуль ядра Linux.
• Минимальные зависимости для сборки (C++, Go, RocksDB).

Ограничения:

• Файлы неизменяемы после записи.
• Не подходит для очень маленьких файлов (медиана — 2 МБ).
• Ограниченная пропускная способность при создании/удалении директорий.
• Отсутствие встроенной системы разрешений.

Разработка началась в 2022 году, с 2023 года система используется в production. К середине 2024 года все ML-задачи работают на TernFS. По состоянию на сентябрь 2025 года система хранит более 500 ПБ на 30 000 дисках и 10 000 SSD в трёх дата-центрах, с пиковой пропускной способностью в несколько ТБ/с. Потерь данных не зафиксировано.

Высокоуровневая архитектура

Основной API TernFS реализован четырьмя службами:

• Шарды метаданных — хранят структуру директорий и метаданные файлов.
• Координатор междиректорных транзакций (CDC) — выполняет транзакции между шардами.
• Службы блоков — хранят содержимое файлов.
• Реестр — хранит информацию обо всех службах и мониторит их.

Диаграмма взаимодействия служб TernFS и клиентов.

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

• Обсуждение технических особенностей TernFS: отсутствие RDMA, использование TCP/IP, репликация данных, ограничение на минимальный размер файла (~2MB), специализированная система метаданных.
• Сравнение с другими файловыми системами (CephFS, Lustre, GPFS): различия в архитектуре, производительности, поддержке POSIX и целевых use cases.
• Вопросы о бизнес-модели и масштабах данных XTX: хранение >500PB для ML-моделей в трейдинге, критика "отсутствия реальной ценности".
• Обсуждение лицензии (GPLv2-or-later/Apache-2.0) и предложения по улучшению документации (добавление примеров использования).
• Замечания о нишевых решениях для больших данных: акцент на immutable-данные, сложности с метаданными для tiny files, специализация под конкретные задачи.

В защиту C++

Почему C++ остаётся мощным и актуальным языком программирования в современном технологическом ландшафте.

Репутация C++

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

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

C++ «сложен»

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

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

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

C++ «устарел»

C++ очень стар — он вышел в 1985 году. Но означает ли это, что он устарел?

Ни в коем случае. C++ активно развивается уже более 40 лет. Последняя версия стандарта, C++20, добавила множество новых функций, а C++23 расширил возможности стандартной библиотеки, концепций, диапазонов и сопрограмм, делая язык более мощным и выразительным.

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

Язык не устарел — чтобы утверждать обратное, придётся сильно извратить определение «устаревшего».

C++ «небезопасен»

А вот и главный аргумент. Да, я сравню с Rust, поскольку его часто называют «безопасным» языком, который должен заменить C++.

Переписывание кодовых баз C++ на Rust всегда даёт более безопасные результаты.

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

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

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

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

• C++ и C полагаются на навыки и дисциплину разработчиков вместо автоматических проверок безопасности, что часто приводит к уязвимостям в больших проектах.
• Сложность C++ считается чрезмерной и архаичной, многие функции языка (шаблоны, перегрузка операторов) сложны для понимания и неизбежны в реальных проектах.
• Безопасность памяти в C++ проблематична даже для опытных разработчиков, в отличие от языков с автоматической проверкой, таких как Rust.
• Идиоматичный C++ сильно отличается от C, и попытки писать на C++ «как на C» противоречат современным практикам и стандартам.
• Переписывание кода с C++ на Rust часто повышает безопасность и удобство сопровождения, но обратный процесс сложнее и рискованнее.
• C++ останется важным языком из-за его распространённости в legacy-системах и критичных к производительности областях.
• Инструменты и экосистема C++ (пакетные менеджеры, форматтеры) часто считаются устаревшими по сравнению с современными языками.

Встраивание Rust в ядро Linux продвигается с новым API для безопасной обработки ненадёжных данных из пользовательского пространства. Benno Lossin предложил тип Untrusted<T>, который помечает данные как непроверенные и предотвращает их случайное использование в ядре. Этот тип работает на уровне системы типов без накладных расходов в runtime, что делает его эффективным инструментом для маркировки данных из сетевых соединений, съёмных носителей или пользовательских вводов.

API включает утилиты для работы с распространёнными структурами данных, такими как срезы и векторы, и рекомендует интерфейсы вроде read_from_userspace(buf: &mut [Untrusted<u8>]) для безопасного копирования. Для валидации данных введён трейт Validate, хотя его реализация пока требует доработки. Greg Kroah-Hartman предложил добавить пример использования в драйверах, особенно для уязвимых мест вроде ioctl(), где непроверенные данные исторически вызывали переполнения буфера.

• Обсуждаются преимущества строгих типов (например, Untrusted<T>) для повышения безопасности, особенно при обработке пользовательского ввода в веб-приложениях и ядре ОС.
• Отмечается, что подобные подходы уже эффективно реализованы в Rust (для embedded и системного программирования) и Perl ("tainting"), делая код более надежным.
• Подчеркивается, что в C++ также возможна подобная типобезопасность, но она редко используется на практике из-за сложности и инерции сообщества.
• В контексте ядра ОС отмечается, что "ненадежные" данные не только потенциально вредоносны, но и нестабильны (могут меняться конкурентно, быть недоступными).
• Утверждается, что система владения и проверки заимствований (borrowck) в Rust делает подобные API более эргономичными и безопасными по сравнению с C++.

Safe C++ больше не развивается.
Год назад появился черновик, обещавший «ржавую» безопасность без ломки старого кода: память, типы, потоки — всё через явный safe-контекст. Комитету идея не зашла: модель Rust назвали чуждой, голоса отдали Profiles — набору ограничений на уже существующий C++, которые на этапе компиляции блокируют UAF, data-race, deadlock, утечки.

Profiles не добавляют синтаксиса, только запрещают опасные паттерны; включаются опцией, обратно совместимы. Safe C++ требовал новых квалификаторов и заимствовал проверки времени жизни — слишком радикально.

Автор Safe C++, Шон Бакстер, признал:

Дальнейшая работа бесполезна; все силы — в Profiles.

Вывод: Profiles слабее, но реалистичнее; ждём их в C++26.

• Комитет C++ фактически отверг Safe C++ и ограничился «Profiles» — набором флагов, запрещающих часть небезопасных конструкций.
• Участники сходятся: главная проблема не техническая, а культурная — сообщество не хочет ограничений, считая «если код работает — значит, он безопасен».
• Profiles критикуют за примитивность: они не решают temporal safety, не выражают лифтаймы и не требуют изменения синтаксиса, поэтому дают лишь иллюзию защиты.
• Большинство считает, что без полного отказа от C-подобного подмножества и без внедрения lifetimes C++ никогда не станет «безопасным»; проще перейти на Rust.
• Практический вывод: крупные проекты продолжат игнорировать Profiles, а новые кодовые базы будут выбирать Rust либо двухъязычный подход «C++26 + внешние анализаторы».

skiftOS
Включите JavaScript для работы приложения.

• За 6 лет автор SkiftOS написал микроядро, загрузчик, графическую оболочку, UI-фреймворк и даже движок браузера.
• Код на современном C++ (модули, async, co_await) и выглядит очень чисто; вдохновение Rust заметно.
• Система CPU-рендеринг, GPU — в планах; сеть пока только HTTP, без HTTPS.
• Безопасность: приложения не видят всю память и железо, драйверы в userspace, доступ по capability.
• Собрать можно под Linux/macOS (./skift.sh run --release <app>), но полный билд сейчас сломан.
• Автор признаёт: почти не было личной жизни, помощь была лишь с движком браузера.

Rust: «неразумная» скорость сортировки

• Сортировка в Rust быстрее C++ и Go благодаря LLVM, агрессивному векторизатору и ручным оптимизациям.
• Алгоритм: pdqsort (pattern-defeating quicksort) + векторизованный партиционер.
• Ключевые приёмы:
  • 128-битные SIMD-операции (SSE/AVX) для фильтрации элементов;
  • branchless-код, предикты, минимизация кэш-промахов;
  • специализированные пути для малых типов (u8, u16, u32, u64, f32, f64) и копируемых структур;
  • ручная развёртка циклов, инлайн, отказ от стандартных абстракций.
• Сравнение: на случайных u64 Rust ~2× быстрее libstdc++, ~3× быстрее Go; на почти отсортированных — ещё больше.
• Память: всё делается in-place, доп. буфер 1 КБ максимум.
• Сложность: O(n log n) в среднем, O(n log n) worst-case (pdqsort гарантирует).
• Код открыт, можно подсмотреть и перенести на другие языки.

• Универсальный лайфхак: «сначала отсортируй данные» — и задача часто сводится к O(log n).
• Но глобальная сортировка дороже с ростом объёма; иногда проще пересмотреть подход или использовать хэш-таблицу.
• Современные unstable-sort и foldhash настолько быстры, что ручные оптимизации часто проигрывают и требуют лишней памяти.
• Для 4 уникальных значений подсчёт или perfect-hash проще и быстрее полной сортировки; эксперимент ставит границы, а не решает продакшен-задачу.

GTK1
Классическая библиотека GUI GTK1 для Windows, Linux, macOS.
Языки: C/C++.
108 коммитов, 1 ветка, 0 тегов.

• Кто-то всё ещё поддерживает GTK 1.2: CinePaint и Lazarus используют его как «стабильную» базу, но приходится собирать из исходников — ни одна современная дистра, кроме Slackware, не поставляет пакеты.
• Совместимости между GTK1 и GTK2/3/4 нет: API ломают регулярно, что участники называют «визитной карточкой GNOME».
• GTK1 ценят за лёгкость, быструю работу по удалённому X11 и простоту статической линковки; минусы — нет юникода, антиалиасинга, fontconfig, только X11 core-шрифты.
• GTK2 тоже считают «мертвым»: 30-40 DLL на Windows, медленный remote-X, а тяжёлый GTK3/4 воспринимают как «ад в корзине».
• Утилиты вроде Glade давно не обновлялись, примеры в доках течёт памятью, а «лёгкой» сборки GTK2 никто не делает.

• Япония продолжает финансировать Pezy Computing, создающую энергоэффективные математические ускорители SC4S/SC5, способные заменить GPU в HPC и ИИ.
• SC4S: 2 048 ядер, 8 TFLOPS FP64, 200 Вт, 40 нм; SC5: 16 384 ядер, 64 TFLOPS FP64, 400 Вт, 7 нм; оба используют SIMD и обходятся без HBM, охлаждаясь жидкостью.
• Ускорители уже стоят в 6-8 системах ТОП500; пиковая энергоэффективность 32 GFLOPS/Вт.
• Драйверы OpenCL/CUDA-аналог ZCL, компиляторы Fortran/C++ готовы; в 2026-2027 ждут SC6 (128 TFLOPS FP64, 7 нм) и SC7 (E级, 3 нм).
• Цель: 10× экономия энергии и долгая независимость от NVIDIA/Intel.

• Япония развивает собственные HPC-акселераторы (Pezy и др.), ориентированные на FP64 и традиционные суперкомпьютерные задачи, а не на ИИ-низкоточность.
• Эти чипы создаются под кластеры с жидкостным охлаждением и продаются не поштучно, а целыми стойками.
• Производительность FP64 у Pezy конкурентна с NVIDIA, но энергоэффективность и программное окружение NVIDIA пока непревзойдены.
• Японские компании и государство инвестируют в HPC-экосистему, чтобы сохранить технологический суверенитет и не зависеть от американских GPU.
• Участники обсуждают, насколько целесообразно переключение на альтернативные форматы чисел (posits) и почему правительства продолжают финансировать «собственных лошадей» несмотря на риск провала.

Контракты для C  
C++ почти утвердила контракты (P2900); я попробовал адаптировать идеи для C.  
Пока это черновик, без реализации в компиляторах.

Главное:  
- `pre`/`post` — проверяемые условия на входе/выходе функции.  
- Не ломают ABI.  
- Компонуются и позволяют оптимизатору выкинуть лишние проверки.  
- Если условие — константа, оно как `static_assert`: ошибка компиляции.

Базовые примитивы  
```c
contract_assert(условие, "текст");   // всегда проверяется, при лжи — abort
contract_assume(условие, "текст");   // компилятор верит, иначе UB

Пример функции

// заголовок
void *my_malloc(size_t s) pre(s) post(r: r);

// реализация
inline void *my_malloc(size_t s) {
    contract_assert(s, "size != 0");
    defer { contract_assert(defer_return_value, "ok"); };
    return malloc(s);
}

defer выполняет post-проверку при любом выходе.
Инлайн даёт компилятору видеть контракт; внешняя декларация сохраняет привычное разделение .h/.c.

Польза: читаемость, статический анализ, оптимизация.

• Участники спорят, что считать «контрактом»: от assert до полноценных спецификаций, проверяемых компилятором.
• Проблема С/С++: нет единого стандарта, каждый реализует по-своему (Digital Mars — с 90-х, Frama-C, C23 unreachable()).
• Часть сообщества считает контракты костылем для слабой типизации: «если типы не выражают инварианты, добавь ещё один слой».
• Критика С23: макрос contract_assume вызывает UB через unreachable(), что делает поведение непредсказуемым и оптимизацию агрессивной.
• Альтернативы: переходить на Ada/SPARK, Rust, OCaml — там контракты либо встроены, либо доказываются статически.

Fil-C — это C/C++-совместимый язык с безопасной памятью и современным инструментарием. Его сердце — FUGC, параллельный, конкурентный, точный, неперемещающий сборщик мусора.

Ключевые черты FUGC

• Параллельность: маркировка и очистка выполняются на всех ядрах.
• Конкурентность: потоки-мутаторы не останавливаются; блокировки только на медленных путях аллокации.
• On-the-fly: нет глобальной паузы; «мягкие рукопожатия» просят потоки асинхронно сканировать стек.
• Grey-stack: повторное сканирование стеков до фикс-поинта; барьер только при записи, быстрая сходимость.
• Dijkstra-barrier: при записи указателя объект помечается CAS-relaxed.
• Точность: LLVM-плагин FilPizlonator точно знает, где все указатели.
• Неперемещаемость: объекты не двигаются; освобождённые блоки «перенаправляются» через InvisiCap.

Safepoint-механизм

• Компилятор вставляет pollcheck: быстрая проверка или колбэк для GC.
• «Мягкое рукопожатие» запускает колбэк на всех потоках.
• Состояния enter/exit позволяют блокироваться в syscall без pollcheck’ов; GC сам выполняет колбэк для «exited» потоков.
• Safepoint защищает от гонок: загруженный указатель будет жив до следующего safepoint’а.

По желанию можно включить полный stop-the-world (FUGC_STW=1) для fork(2) или отладки.

• Fil-C — это С-компилятор с точным параллельным GC (FUGC) и capability-указателями, позволяющий запускать «как есть» CPython, SQLite, OpenSSH и др., теряя в худшем случае 4× производительности.
• Вместо ручного free и UB-оптимизаций LLVM код живёт под барьером Дейкстры и soft-handshake safepoint’ами; указатели превращаются в «InvisiCap» (base+offset), теряющие силу при приведении к integer.
• Проект исследовательский, но уже промышленно полезен: нет сборок под 32-бит, Windows и embedded без MMU, нет пока поколенческого GC и ARM/RISC-V.
• Споры: «lock-and-key» предсказуемее RAM, но требует атомиков; GC = «мусор потом» vs compile-time проверки; можно ли дождаться AI-стат-анализа вместо Rust-переписей.

Как ускорить запуск Unreal Editor: не создавать 38 000 тултипов

Unreal Editor запускается долго. Epic борется с этим кэшами, live-coding и прочими оптимизациями, но одна простая проблема оставалась незамеченной: на старте движок генерирует 38 000 виджетов-тултипов, хотя за сессию пользователь видит лишь десяток.

Профилирование показало, что SetToolTipText тратит ~0,2 мс на каждый тултип, но главное — он не просто сохраняет текст, а сразу создаёт полноценный виджет. В итоге:

• 2–5 с потеряно в дебаг-сборке
• до 1 с в development
• ~40 МБ ОЗУ занято невидимыми виджетами

Решение

1. Заменить немедленное создание виджета на ленивое: сохранять только FText.
2. Создавать виджет в момент первого обращения (GetToolTip).

Патч — пара строк: убрать Spawn из сеттера, перенести его в геттер.
Результат: стартовое время падает на ~1 с, ОЗУ экономит десятки мегабайт, а в рантайме задержки не заметны — тултипы всё равно редко вызываются пачками.

• UE создаёт 38 000 тултипов при старте редактора, что занимает до 2–5 с в дебаг-сборке и почти 1 с в дев-сборке.
• Каждый «тултип» — полноценный UI-виджет с саб-объектами, а не просто строка текста.
• Проблема решается ленивым или единичным созданием экземпляров, как в IMGUI/Unity/React-порталах.
• Участники жалуются на медленную итерацию UE: 10 мин компиляция пустого проекта, бесполезный блюпринт-бол, жадность до железа.
• Альтернативы: Godot (GDScript, быстрая итерация), Unigine, форк Hazelight с AngelScript.

Краткий обзор проблемы C++ модулей

1. Главное требование
   Если модули не ускоряют сборку минимум в 5 раз (желательно 10×) на реальных проектах, их нужно удалить из стандарта. Все остальные плюсы не стоят вложенных ресурсов.

2. Что обещали vs. что получили

   • Изначально: «уберём O(N²) из-за заголовков, компиляция станет мгновенной».
   • Сейчас: упор сместился на «изоляцию сборки» (макросы, пространства имён). Это полезно, но редко встречается и не решает главную боль — медленную сборку каждый день.

3. Почему всё так плохо

   • Модули приняли в C++20, несмотря на предупреждения о невозможности реализации.
   • Реализация заняла >5 лет и всё ещё не готова.
   • Стандарт не описывает, как именно компилятор и сборочная система должны взаимодействовать: имена файлов, каталоги, зависимости — всё на совести разработчиков.
   • Компиляторные команды отказываются «превращаться в систему сборки» и блокируют любые предложения.

4. Итог
   Проект превратился в «интеграционный ад». Пока нет массовых 5-10-кратных ускорений, дальнейшие инвестиции — просто затягивание «затратной ямы».

• Участники сетуют: вместо простого «import = include без утечек контекста» получили громоздкий механизм, который мало кто использует.
• Старые пре-компил-хедеры 90-х и сторонние решения вроде zapcc уже давали 5× ускорение, но были проигнорированы стандартом.
• Модули обещали избавить от forward-declaration и макро-ifdef, но на практике вызывают лавину пересборок и несовместимы с большим объёмом существующего кода.
• Многие считают, что модули заточены под «большой тех» с кэшированными билдами, а малый бизнес и хобби-проекты «попали в пролёт».
• Итоговое настроение: «убейте модули, C++ всё сломали», «мир ушёл в Rust», но «на C++ всё ещё держится пол-мира, так что просто так не выкинешь».

Ultrassembler — библиотека RISC-V-ассемблера, встроенная в проект Chata.
В отличие от as и llvm-mc, она вызывается прямо из C++, без system() и временных файлов, что критично для встроенных систем.

Скорость

Тест на 16 тыс. инструкций:

• Ultrassembler ≈ 10× быстрее as, 20× быстрее llvm-mc.
• 1 RISC-V инструкция ≈ 1000 x86-инструкций (у конкурентов 10–20 тыс.).
  Код на чистом C++; можно добавить ассемблерные вставки.

Ключевые оптимизации

Исключения

GCC-реализация «zero-overhead»: штрафа нет, пока исключений нет.
Ошибки встречаются редко и видны человеку, поэтому даже 1 с на обработку незаметна.
std::expected дал −10 %, так как нормальный путь стал дороже.

Быстрые структуры

2000+ RISC-V-инструкций требуют мгновенного поиска.
Вместо std::unordered_map используется perfect-hash таблица от gperf, генерирующая O(1) без коллизий.
Размер таблицы компактен, кэш-эффективен.

Парсинг

• Регистры идентифицируются по первым 2–3 символам через switch.
• Нет std::string, только std::string_view и статические буферы.
• Лексемы разбираются за один проход без регулярных выражений.

Кодогенерация

• Шаблоны на этапе компиляции формируют битовые маски инструкций.
• Варианты одной инструкции разворачиваются в constexpr-таблицы, что убирает ветвления в рантайме.

Память

• Все выделения через стековые std::array/std::string_view.
• Нет new/malloc, следовательно, нет аллокационных штрафов и кэш-промахов.

Платформенные трюки

• [[likely]]/[[unlikely]] для подсказок ветвления.
• __builtin_expect там, где компилятор не догадывается.
• LTO + PGO дают ещё 5–7 %.

Итог

Ultrassembler показывает, что «низкоуровневый» C++ без искусственных ограничений может обгонять даже оптимизированные GNU-утилиты.

• В обсуждении разобрали миф о «системном вызове при каждом росте контейнера» — реальные аллокаторы переиспользуют память и делают syscall лишь при нехватке.
• Участники напомнили, что исключения в C++ не «zero-overhead»; есть компромисс между временем и памятью, и g++ выбирает экономию места.
• Автор статьи подтвердил: пробовал хеширование, но дерево разбора оказалось быстрее; flex/bison тут не при чём, скорее gperf.
• Некоторые посоветовали LLVM C++ API, memory-mapped I/O и std::pmr для ускорения и упрощения кода.
• Большинство сходится: современные ассемблеры и так быстрые, задача скорее академическая, но как «посмотреть, насколько можно ускорить» — интересна.

grok-code-fast-1 — новая модель xAI для агентного кодинга: быстрая, дешевая, заточена под ежедневную работу.

• Скорость: архитектура с нуля, оптимизация инференса, кеш >90 %. Десятки вызовов инструментов до того, как вы прочтёте первую строку мыслей.
• Цена: 0,20 $/1 M входных, 1,50 $/1 M выходных, 0,02 $/1 M кешированных токенов.
• Языки: TypeScript, Python, Java, Rust, C++, Go.
• Инструменты: grep, терминал, редактирование файлов — «родная» работа в IDE.
• Партнёры: временно бесплатно в Cursor, GitHub Copilot, Cline, Roo Code, Kilo Code, opencode, Windsurf.

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

• 190 токенов/сек, SWE-Bench-Verified 70,8 %.
• Оценки реальными разработчиками: быстро и надёжно для рутинных задач.

• Кто-то хвалит grok-code-fast-1 за скорость и качество, сравнивая с gpt-5-mini, другие считают «быстро, но тупо».
• Основная критика: упор на скорость вместо качества, неточные или вредные изменения кода, сомнительные внутренние бенчмарки.
• Несколько человек жалуются, что модель случайно удаляет код и скрывает кнопки «стоп».
• Подняты этические и экологические вопросы: нелегальные газовые турбины и «обученный нацистский бот».
• Часть пользователей просто рада быстрой бесплатной модели в Cursor/VS Code для простых задач.

Коротко о «strongly happens-before»

В C++20 появилось новое отношение strongly happens-before (SHB), потому что старое happens-before оказалось недостаточно строгим.

Пример кода

std::atomic<int> x{0}, y{0};

// thread-1
x.store(1, seq_cst);
y.store(1, release);

// thread-2
int b = y.fetch_add(1, seq_cst); // b = 1
int c = y.load(relaxed);         // c = 3

// thread-3
y.store(3, seq_cst);
int a = x.load(seq_cst);         // a = 0

Почему нужен SHB

• Каждый атомарный объект имеет modification order — полный порядок всех записей.
• Классические правила coherence (write-write, read-read, read-write, write-read) связывают happens-before с этим порядком.
• Но при смешанных memory_order (например, release + seq_cst) между потоками могут образоваться «дыры», где старое happens-before не гарантирует ожидаемую последовательность.

Отличие SHB от HB

• SHB добавляет требование: если операция A strongly happens-before B, то все наблюдатели видят записи A раньше записей B, даже при разных memory_order.
• Для seq_cst SHB совпадает с HB; для release/acquire HB может быть, а SHB — нет.

Итог

Если пользуетесь только seq_cst, можно не заморачиваться. При смешанных порядках SHB — формальный способ не получить «невозможные» значения.

• Участники обсуждают различие между «strong happens-before» в Java и более слабой моделью C++.
• Код из статьи считается не «простым», а академическим примером; порядок запуска потоков ОС не гарантирует.
• Наблюдаемые в комментариях значения могут показаться странными, но они допустимы при отсутствии дополнительной синхронизации.
• Смысл слабых моделей памяти — формально описать множество всех допустимых исполнений, учитывая кэши, оптимизации компилятора и т. д.
• Добавление ещё одного атомика для «упорядочивания» может, наоборот, запретить именно тот «неинтуитивный» порядок, который автор статьи исследует.

Flash Attention на 5090 в CUDA C++

Цель — научиться писать attention-ядро на CUDA C++, чтобы использовать MXFP8/NVFP4 MMA для sm120, чего нет в Triton.
Код: learn-cuda/07_attention.

Бенчмарк (bs=1, heads=8, q=4096, kv=8192, BF16, 5090@400 W, CUDA 12.9, SOL 209.5 TFLOPS):

ядро	TFLOPS	%SOL
F.sdpa (Flash)	186.73	89.13
F.sdpa (CuDNN)	203.61	97.19
flash-attn	190.58	90.97
v1 (basic)	142.87	68.20
v2 (swizzle)	181.11	86.45
v3 (2-stage)	189.84	90.62
v4 (ldmatrix.x4)	194.33	92.76
v5 (pipe)	197.74	94.39

---

Алгоритм Flash Attention 2

Псевдокод:

scale = DIM**-0.5
for b, tile_Q:
    tile_O = 0
    tile_Q = load(Q[b, tile_Q])
    for tile_KV:
        tile_K = load(K[b, tile_KV])
        tile_S = tile_Q @ tile_K.T * scale
        online_softmax(tile_S)  # in-place
        tile_V = load(V[b, tile_KV])
        tile_O += tile_S @ tile_V
    store(O[b, tile_Q])

head_dim=128 помещается в регистры.

---

v1 — базовая версия

1. G2S: cp.async.ca.shared.global 128-битными транзакциями.
2. S2R: ldmatrix для Q, K, V → 8×8 фрагменты.
3. Softmax online:
   • m = max(m_prev, m_curr)
   • d = d_prev * exp(m_prev - m) + Σ exp(S - m)
   • O = O_prev * (d_prev/d) * exp(m_prev - m) + (exp(S - m)/d) @ V

---

v2 — swizzled shared memory

• 128-битные банки → конфликты при 8×8 tile.
• Swizzle K и V по 32-битным строкам; Q оставляем линейно.
• +40 % пропускной способности.

---

v3 — 2-stage pipeline

• Двойной буфер: пока вычисляем S/P@V, асинхронно грузим следующий KV.
• cp.async.commit_group() + cp.async.wait_group(1).
• +5 % к SOL.

---

v4 — ldmatrix.x4

• Одна инструкция ldmatrix.x4 загружает 4×8×8 фрагмента K/V за раз.
• Снижает инструкций на 25 %.
• +2 % к SOL.

---

v5 — улучшенный pipeline

• 3-4 стадии:
  1. prefetch KV
  2. compute S
  3. compute P@V
  4. write-back O
• __pipeline_wait_prior(N) + __pipeline_commit().
• +2 % к SOL.

---

Что дальше

• Использовать TMA (cp.async.bulk) и NVFP4/MXFP8 MMA.
• Поддержка head_dim > 128 (FlashMLA).

• Пользователи удивлены, что RTX 5090 даёт всего 209 TFLOPS BF16 — менее 10 % от серверного Blackwell B200 (2250 TFLOPS), но при цене ~$30-40 k за B200 соотношение цена/производительность почти сравнялось.
• Обсуждают, что NVIDIA с 4090 и далее искусственно ограничивает тензорные ядра игровых карт для ML-операций FP8/FP16.
• У 5090 выше TDP, чем у 4090, и можно ограничить мощность лишь до 70 % (4090 — до 50 %), что мешает апгрейду для ML-станций.
• Появились вопросы о поддержке Flash Attention на 5090/5080 и о нативной компиляции под Blackwell в PyTorch 2.7.
• Участники спорят, стоит ли вкладываться в Triton, если нужны фирменные типы NVFP4/MXFP8, которых там пока нет.

Librebox-demo — репозиторий движка Librebox: открытой альтернативы Roblox.
Цель — совместимость с Roblox-играми и инструментами, но без проприетарных ограничений.

Ключевое

• Язык: C++ + Lua
• Лицензия: MIT
• Статус: ранняя альфа
• Сборка: CMake + vcpkg

Быстрый старт

git clone https://github.com/librebox-devs/librebox-demo.git
cd librebox-demo
cmake -B build -S . -DCMAKE_BUILD_TYPE=Release
cmake --build build
./build/librebox

Функции

• Загрузка .rbxl и .rbxm
• Базовый рендер OpenGL/Vulkan
• Серверный режим headless

Планы

• Поддержка плагинов
• Web-клиент
• Мобильные порты

PR и issue приветствуются.

• Librebox — это пока демо с очень ограниченным подмножеством API Roblox; серверов и сети нет.
• Пользователи надеются на Linux-клиент и сохранение творений Roblox, но опасаются юридических проблем.
• GitHub и Discord проекта выглядят странно: разработчики скрыты, активности мало, но код реально пишется.
• Некоторые считают, что такие проекты важнее для Roblox, чем борьба с хищниками на платформе.
• Есть предложения переименовать в OpenBox из-за лицензии MIT, но другие напоминают, что MIT — это тоже «свободно».

Без futex всё тленно

Книга The Art of Multiprocessor Programming (2-е изд., 2021) считается канонической, но она обходит стороной futex — ключевой примитив современной многопоточности. Это упущение делает пособие бесполезным для практиков.

Futex ≠ mutex
Название происходит от «fast userspace mutex», но futex — это не мьютекс, а основа для всех высокоэффективных примитивов синхронизации. До него всё строилось на громоздких System V IPC, которые не масштабировались: при 1000 потоков futex в 2002-м оказался в 20–120 раз быстрее sysv-блокировок. Windows и macOS добавили аналоги только в 2012 и 2016 гг.

Суть futex
Он разделяет блокировку и ожидание/пробуждение:

• В user-space проверяем состояние; если свободно — захватываем без системного вызова.
• При конфликте вызываем futex_wait(addr, expected), засыпаем в ядре на конкретном адресе.
• Пробуждение — futex_wake(addr, n), где n обычно 1 или «все».

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

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

Итог
Любая современная библиотека (pthreads, C++ std::mutex, Rust std::sync) опирается на futex. Учебник, игнорирующий этот примитив, не готовит к реальной разработке.

• Futex — это быстрый примитив синхронизации, который экономит системные вызовы при отсутствии конфликтов и не требует выделения ядром объектов.
• В отличие от Benaphore и старых SysV-механизмов, futex не требует предварительной инициализации в ядре и исчезает, когда нет ожидающих.
• Обсуждение подчёркивает, что современные учебники по многопроцессорному программированию обязаны упоминать futex, но «The Art of Multiprocessor Programming» этому не уделяет внимания.
• Улучшения futex2 (Linux ≥5.16) добавили NUMA-поддержку и аналог Windows WaitForMultipleObjects, а io_uring теперь умеет работать с futex.
• Для надёжности при падении потока существуют robust-locks и списки futex, которые ядро автоматически разблокирует.

MapLibre Tile — новый формат векторных тайлов, призванный заменить Mapbox Vector Tile (MVT).
Основные цели:

• меньше размер (до 50 % экономии);
• быстрее парсинг (до 2× ускорения);
• простота реализации без внешних зависимостей.

Ключевые улучшения

• FlatBuffers вместо Protocol Buffers → компактнее и без распаковки.
• структурированные слои: геометрия, атрибуты, индексы — отдельные буферы, что ускоряет выборку.
• delta-кодирование координат и ID → ещё меньше байт.
• встроенный R-tree для быстрого поиска объектов в тайле.

Совместимость

• Поддержка JS, C++, Swift, Kotlin.
• Рендерится в MapLibre GL JS ≥ 5.0 без изменений API.
• Обратная совместимость: конвертер MVT → MLT доступен.

Roadmap
Q4 2024 — стабильная спецификация, конвертеры, примеры.

• Участники рады ускорению декодирования и уменьшению размера тайлов, но опасаются сложности внедрения вне MapLibre.
• Некоторые считают, что узкое место не в загрузке/декодировании, а в памяти и рантайме при множестве слоёв.
• Уже ведётся работа над MapLibre GL JS/Native (Java, JS, Rust, TS); CLI-кодировщик почти готов.
• Ожидается интеграция с Planetiler и, возможно, форк tippecanoe; документация и анонсы через новостную рассылку MapLibre.

DOSDevelResources — подборка инструментов и ссылок для разработки под DOS.

Содержание

• Языки

  • C/C++: Watcom, DJGPP, OpenWatcom, SmallerC, SubC
  • Pascal: Free Pascal, Turbo Pascal 5.5
  • BASIC: FreeBASIC, QB64, QuickBASIC 4.5
  • Сборка: NASM, FASM, WASM, TASM, MASM 6.11
  • Прочее: Rust (rustc-dos), Go (gccgo), Lua, Python 2.4

• Библиотеки и API

  • Allegro, SDL, Raylib, GRX, pdcurses, OpenGL (Mesa3D), VESA, SoundBlaster, TCP/IP (Watt-32, mTCP)

• Утилиты

  • Редакторы: RHIDE, FTE, SETEdit, TDE, Vim, Emacs
  • Отладчики: GDB, WD, TD, SoftICE
  • Упаковка: UPX, LZEXE, PKLite, Diet
  • Эмуляция: DOSBox, DOSBox-X, 86Box, PCem, Bochs
  • Разное: Git, Make, Doxygen, Valgrind-like (Dr. Memory)

• Документация

  • Ralf Brown’s Interrupt List, PCGPE, Intel/AMD manuals, OSDev Wiki

• Ссылки

  • FreeDOS, OSDev, Vogons, Scene.org

Как пользоваться

Клонируйте репозиторий:

git clone https://github.com/SuperIlu/DOSDevelResources.git

Все файлы/архивы лежат в каталогах по темам.

Лицензия

MIT.

• Участники вспомнили, что DOS-ретросцена жива: анонсирован 3-месячный DOSember game-jam.
• Перечислены доступные инструменты: HX DOS Extender, JWasm, Borland C++ 3.1, Free Pascal, DJGPP, GW-BASIC/PC-BASIC, а также MIT-лицензированный набор Microsoft 1988 года.
• Названы ключевые ресурсы: PC Games Programming Encyclopedia, эмулятор PCjs, книги «Black Book of Graphics Programming», «Programmer’s Guide to the EGA/VGA» и «PC-Intern».
• Отмечены удобные IDE: RHIDE и клон Turbo Vision от Free Pascal, а также ностальгия по быстрым Borland-IDE.
• Обсуждали, что современные ассемблеры (FASM/NASM) удобнее старых MASM/TASM, а DOS-цели можно собирать даже из Win32 PE.

Я написал What the Fork — кроссплатформенный визуализатор сборки C/C++ (и не только).
Запуск: wtf make, wtf cargo build, wtf gradle build, wtf -x для Xcode и т.д.

Инструмент показывает все процессы, включая скрытые вызовы ld, и ищет типичные проблемы:

• отсутствие -j у make,
• однопоточная компиляция,
• повторяющиеся cmake/make-шаги,
• непараллельные CI-сборки.

Как работает
Сборка = дерево команд. Чтобы увидеть всё, ловим системные вызовы fork/exec/exit:

• macOS — Endpoint Security API,
• Linux — ptrace,
• Windows — Event Tracing (самое мерзкое API).

Что уже нашли

• cargo собирал зависимость одним потоком вместо 10× ускорения.
• ninja при сборке LLVM держит 12 задач на 10 ядрах — почти идеал.
• CMake 85 раз подряд вызывает xcode-select, sw_vers, cmake/make → clang, не используя параллелизм.

Инструмент открыт для тестов — попробуйте на своём проекте.

• Пользователи восторженно реагируют на новый визуализатор сборки, особенно те, кто застрял на CMake/GCC/Make без clang/ninja и не может понять, почему сборка тормозит.
• Просят сразу показать GIF-демонстрацию под заголовком статьи и спрашивают, будет ли macOS-версия и открытый код.
• Некоторые делятся опытом: strace/dtruss, ninjatracing, vcperf, cargo --timings, Instruments и другие инструменты уже решали похожие задачи.
• Предложения расширить функциональность: добавить flame-графы процессов, поддержку fork(), интеграцию с Bazel Build Event Protocol, оценку «осталось времени» по историческим данным.
• Отдельные комментарии касаются маркетинга (сменить название), сравнения с VS/Xcode, а также шуток про TEEP/OEE завода и «LLVM, завари кофе».

Краткий обзор

• Проблема: компилятор Solidity (solc) падает на Ubuntu 22.04 при компиляции корректного кода.
• Причина: сочетание трёх факторов
  1. 12-летний баг G++ (< 14) в разрешении перегрузок.
  2. Устаревший паттерн сравнения в Boost.
  3. Новые правила симметричных сравнений C++20.

Цепочка событий

1. Баг G++ (2012, GCC-53499): при boost::rational<T> == 0 компилятор до 14-й версии выбирает нечлен-шаблон вместо член-шаблона.
2. C++20 добавляет автоматическую перестановку аргументов: 0 == rational<T> → rational<T> == 0.
3. Boost 1.74 предоставляет обе версии оператора, что приводит к бесконечной рекурсии и переполнению стека.

Минимальный пример

template<typename T>
struct rational {
    template<class U>
    bool operator==(const U&) const { return true; }
};

template<class U, class T>
bool operator==(const rational<T>&, const U&) { return false; }

int main() {
    rational<int> r;
    return r == 0;   // g++11 выбирает free-функцию
}

Как починить

• Обновить GCC ≥ 14 или Clang, или
• Собрать Solidity без C++20 (-std=c++17), или
• Патч Boost/использовать свежий Boost ≥ 1.82.

Итог
Ни один компонент по отдельности не «сломан», но их комбинация приводит к крашу компилятора на валидном коде.

• 12-летний баг разрешения перегрузок в GCC + новый оператор <=> C++20 = краш компилятора Solidity.
• Проблема в том, что «каждый компонент по отдельности не сломан», но вместе дают сбой.
• Участники обвиняют чрезмерную сложность C++, отсутствие тестов при обновлении стандарта и «бесконечные надстройки» вроде spaceship-оператора.
• Кто-то предлагает «python2to3-момент» для C++, другие считают смарт-контракты плохой идеей из-за неизбежных багов.
• Лицензия SPDX в примере вызывает вопросы, но Solidity требует её наличие, иначе ошибка компиляции.

• Добавлена поддержка моделей Mistral-Small-3.1-24B-Instruct-2503 и Mistral-Small-24B-Instruct-2501
• Улучшена работа с Mamba-2 и Sliding Window Attention
• Новые правила конвертации: convert-hf-to-gguf.py теперь корректно обрабатывает sliding_window, mamba2, attention_bias, tie_word_embeddings
• Обновлён llama_model_loader и llama_model: добавлены поля mamba2 и sliding_window, упрощена логика KV-cache
• Поддержка mamba2 в llama_context и llama_decode
• Удалены устаревшие llama_model и llama_vocab
• Добавлены тесты test-mistral.py и test-mistral-vision.py

• Mistral предлагает mistral-common как официальный токенизатор, но пока только через Python-библиотеку и временный REST-обвязанный FastAPI.
• Сообщество жалуется: «cpp-бинарь, зависящий от Python-сервера — временное и грустное решение», ждут нативный C++ порт.
• Пользователи расстроены, что Mistral, выпуская веса, не сразу поддерживает llama.cpp, на котором держится большинство «домашних» запусков.
• Некоторые замечают, что llama.cpp и так тянет Python для шаблонов, но это не отменяет желания увидеть полноценную C++ реализацию.
• Сторонники Mistral отвечают: компания маленькая, пока не ясно, какие именно инференс-фреймворки поддерживать, зато открыли собственный mistral-inference.

Переписал Ghuloum-туториал на Python (~300 строк). Убрал читалку S-выражений и бинарный код — теперь текстовая ассемблерная печать.

Lambda-lifting требует:

• знать связанные переменные;
• собирать свободные переменные лямбд;
• накапливать создаваемые code-объекты.

Связывают let и lambda; для них обновляем окружение.

Lifter

class LambdaConverter:
    def __init__(self):
        self.labels = {}

    def convert(self, expr, bound, free):
        match expr:
            case int() | Char() | bool():
                return expr
            case str() if expr in bound or expr in BUILTINS:
                return expr
            case str():
                free.add(expr)
                return expr
            case ["if", t, c, a]:
                return ["if",
                        self.convert(t, bound, free),
                        self.convert(c, bound, free),
                        self.convert(a, bound, free)]

lift_lambdas запускает обход и возвращает (labels …).

Lambda

Лямбда:

• связывает параметры;
• выделяет код;
• захватывает внешнее окружение.

Пример:

(lambda () x)  ; x свободна

превращается в

(labels ((f0 (code () (x) x)))
  (closure f0 x))

Даже если x связан снаружи, внутри лямбды он считается свободным.

• Участники рекомендуют три современные книги по компиляторам, вдохновлённые статьёй Ghuloum: «Writing a C Compiler» (Sandler), «Essentials of Compilation» на Racket и Python (Siek).
• Обсуждали «lambda lifting»: преобразование, выносящее замыкания наверх, уменьшая их размер вплоть до полного исчезновения.
• Уточнили, что «lambda lifting» в статье связан с разделом 3.11 о сложных константах в Scheme.
• Разбирали, почему современный ИИ использует Python, а не Lisp: удобство как «клея» для C++/CUDA, упадок доли рынка Lisp и смена парадигмы ИИ.

Моя предыдущая статья о обобщённых структурах данных в C готовила почву к теме: структура, которая заменяет динамические массивы, даёт стабильные указатели и хорошо работает с аренными аллокаторами. Её переоткрывали много раз под разными именами: “levelwise-allocated pile” (2001), в Zig — Segmented List, частично похожая на C++ std::deque. Мне нравится название Per Vognsen — Segment Array.

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

Идея проста: фиксированный массив указателей на сегменты; каждый следующий сегмент вдвое больше предыдущего; новые сегменты выделяются по мере необходимости. Поскольку элементы не двигаются, указатели на них стабильны, не остаются “дыры” в арене, а доступ по индексу — за O(1).

Реализация

Структура на C:

typedef struct { u32 count; int used_segments; u8 *segments[26]; } SegmentArrayInternal;

Почему всего 26 сегментов? Из 64 бит указателя обычно реально используются 48, так что 49 сегментов уже перекрывают адресное пространство (~256 ТиБ). Я предпочитаю индекс u32 (до ~4 млрд элементов) — это даёт 32 сегмента. Ещё убираем 6 маленьких (1..32), начинаем с 64, остаётся 26 сегментов — хватает для 4 294 967 232 элементов (чуть меньше UINT32_MAX). Фиксированный массив рядом со структурой снижает риск промаха кэша.

Размеры сегментов — степени двойки: проще математика и быстрые сдвиги для индексов.

#define SMALL_SEGMENTS_TO_SKIP 6

#define log2i(X) ((u32) (8*sizeof(unsigned long long)
- __builtin_clzll((X)) - 1))

u32 capacity_for_segment_count(int segment_count) { return ((1 << SMALL_SEGMENTS_TO_SKIP) << segment_count) - (1 << SMALL_SEGMENTS_TO_SKIP); }

void *_sa_get(SegmentArrayInternal sa, u32 index, size_t item_size) { int segment = log2i((index >> SMALL_SEGMENTS_TO_SKIP) + 1); u32 slot = index - capacity_for_segment_count(segment); return sa->segments[segment] + item_sizeslot; }

log2i использует __builtin_clzll (подсчёт ведущих нулей) для быстрого вычисления номера сегмента.

Clang оптимизирует _sa_get до ~10 инструкций x86-64 (-O3), так что узким местом будет память, а не вычисления индекса. При последовательной итерации можно обходить сегменты напрямую; в segment_array.h есть макрос.

Выделение нового элемента:

u32 slots_in_segment(int segment_index) { return (1 << SMALL_SEGMENTS_TO_SKIP) << segment_index; }

void *_sa_alloc(SegmentArrayInternal *sa, size_t item_size) { if (sa->count >= capacity_for_segment_count(sa->used_segments)) { size_t segment_size = item_size * slots_in_segment(sa->used_segments); sa->segments[sa->used_segments++] = malloc(segment_size); } sa->count++; return _sa_get(sa, sa->count-1, item_size); }

Замечание: можно сделать ёмкость строго степенью двойки, если первые два сегмента одинакового размера. Код станет менее изящным, но это спасает от ~50% потерь памяти при использовании как массива бакетов в хеш-таблице со степенью двойки.

Дженерики

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

#define SegmentArray(type)
union {
SegmentArrayInternal internal;
type *payload;
}

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

• Обсуждается структура «сегментированный массив» (экспоненциальные сегменты), её плюсы и минусы, и сравнение с существующими решениями: std::deque, ropes, Zig std.SegmentedList, rust-array-stump, plf::colony.
• Критика терминологии: это не «массив» в классическом смысле из‑за неконтигуозной памяти; многие API ожидают сплошной/страйдовый буфер и не подойдут.
• Производительность: при локальных L1-итерациях вычислительная часть индексации может быть ощутима; для больших объёмов память становится бутылочным горлышком. Предлагаются оптимизации итерации по сегментам и замечания про clz/bsr/lzcnt и опции компилятора.
• Виртуальная память как альтернатива: резервирование большого диапазона и по мере роста коммит страниц/guard pages; отмечены плюсы на Linux (MAP_POPULATE, mremap), но плохо для embedded/WASM.
• Сравнение с deque: фиксированные блоки vs экспоненциальные, поддержка prepend, рандом-доступ есть; реализация MSVC критикуется за малый размер блока, GNU/libc++ лучше.
• Недостатки сегментов: ухудшение предвыборки/кэш-локальности при линейной итерации, отсутствие стабильной непрерывности для API, сложность с хеш-таблицами при росте (rehash), потенциальный перерасход памяти при экспоненциальных размерах.
• Предложения: настраиваемый минимальный размер сегмента, функции «склейки» мелких сегментов, разбор условий, когда экспоненциальные сегменты оправданы, и замечания о чрезмерной макротрюковости в C/C23.

Whenever I start to feel like a real programmer making games and webapps and AI-enhanced ETL pipelines, I inevitably come across the blog post of a C++ expert and reminded that I am basically playing with legos and play-doh. I had to do a UML thing for the first time in years for

I think this page describes "what" but not "why" of Carbon.Carbon exists so that it's possible to migrate a large C++ code base, like Chrome, from C++ to something saner, incrementally.The most important attribute of Carbon is not the specifics of the syntax but the fact that it'