Filip Pizlo выпустил проект Fil-C, добавляющий проверку безопасности памяти в clang и включающий параллельный сборщик мусора. Инструмент демонстрирует высокую совместимость с существующим кодом, позволяя с минимальными исправлениями собирать полный Linux userspace. По измерениям, производительность составляет 1-4x (и более широкий диапазон по другим тестам), что для многих рабочих нагрузок является приемлемым. Проект основан на долгой линии исследований в области безопасности памяти, включая работы самого автора в Apple, где некоторые предыдущие итерации уже используются в производстве.

Несмотря на преимущества, Fil-C имеет ограничения: он динамически, а не статически предотвращает ошибки, программы все еще могут аварийно завершаться, есть накладные расходы на память (3-6x), и он не решает проблему гонок данных. Автор отмечает интересную возможность применения - проверки границ Fil-C могут сделать указательный код на C безопаснее, чем небезопасный Rust, и предлагает идею адаптации для компиляции небезопасных блоков Rust с дополнительными проверками.

• Почти все программы имеют пути, которые могут привести к краху, но это не означает, что они будут достаточно часто встречаться, чтобы быть проблемой.
• Fil-C обеспечивает безопасность памяти, но требует сборщика мусора и может быть медленнее, чем Rust.
• Стоит ли переписывать код на Rust, если Fil-C может обеспечить безопасность памяти без переписывания.
• Стоит ли переписывать код на Rust, если Fil-C может обеспечить безопасность памяти без переписывания.

Разработчик Ruby-гема Karafka столкнулся с редким, но критическим багом, когда 2700 идентичных ошибок NoMethodError: undefined method 'default' for an instance of String обрушили систему. Ошибка возникала при доступе к elem[:partition] в FFI::Struct, хотя код нигде не использовал метод #default, характерный для Hash.

Исследование показало, что проблема в версиях FFI ниже 1.17.0, где отсутствуют write-барьеры, позволяющие сборщику мусора Ruby освобождать внутренние Hash-объекты. После освобождения память могла перераспределяться под другие объекты, например, строки. Баг проявляется с вероятностью "один к миллиону", но катастрофичен по последствиям. Пользователи использовали Alpine Linux с musl libc, что могло усугубить ситуацию из-за особенностей компиляции и выравнивания структур.

• Обсуждение выявило, что причиной проблемы была давно исправленная ошибка в ffi, а не в Ruby или в коде клиента.
• Участники спора оспаривают, стоит ли считать статью «LLM-шлаком» из-за плохого стиля, даже если сама техническая информация в ней точна.
• Некоторые участники считают, что стиль может быть вызван тем, что автор предпочитает кодить, а не писать, и что технически важная информация была доставлена.
• Другие участники спора отмечают, что статья была полезна и что важно сосредоточиться на техническом содержании, а не на стиле написания.

включ) 3. При (0) в 0. (0 и 0 в 0. Ты в ко 0. (0) и не и (0) сок в

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

Разработка BASIC-интерпретатора в 2025 году: реализация строковых переменных и сборка мусора

Проект по созданию BASIC-интерпретатора для платформы Intellivision ECS 1983 года выпуска перешёл на новую стадию — добавление поддержки строковых переменных. Изначально система могла работать лишь с числовыми данными, но теперь добавлена работа со строками (A$, B$, C$), включая операции присваивания, ввода и вывода, а также конкатенацию.

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

Реализация включает функции для работы со строками, такие как конкатенация, функции LEFT$, RIGHT$, MID$ и другие. Всё это работает на процессоре CP1610 с тактовой частотой 894 кГц, демонстрируя, что даже на ограниченных системах возможна эффективная работа со строками.

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

• В 1978 году Хэл Финни написал 2-килобайтный интерпретатор BASIC для Intellivision, который стал первым встроенным языком программирования для игровой системы.
• Участники обсуждали, что в те годы размер кода и экономия памяти были критически важны, и как это влияло на дизайн и сообщения об ошибках.
• Обсуждение затронуло вопросы раннего периода персональных компьютеров, включая такие редкие темы, как Oregon Trail и TRS-80.
• Ностальгия по тем временам, когда даже простейшие вещи, такие как строки ошибок, были предметом гордости разработчиков, и как это сравнивалось с современными стандартами.

В .NET 10 сборщик мусора получает серьёзные улучшения, которые могут вдвое или втрое сократить использование памяти и повысить производительность. Ключевые изменения включают расширенный escape-анализ для выделения объектов на стеке, оптимизацию делегатов и настройку размеров регионов кучи. Также активирована система DATAS, автоматически адаптирующая сборку мусора под поведение приложения, особенно в контейнерах.

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

• Пользователи отмечают значительное повышение производительности в .NET 10 по сравнению с .NET 8, особенно в приложениях для анализа аудио и текста.
• Высказываются опасения, что оптимизации .NET могут отдалить его от совместимости с WASMGC, что критично для использования в браузере.
• Обсуждаются потенциальные риски, такие как переполнение стека в программах, которые ранее работали стабильно, и сложность настройки GC.
• Упоминаются альтернативные фреймворки для кроссплатформенной разработки (Avalonia, Flutter, MvvmCross) на фоне скептического отношения к стабильности и будущему MAUI.
• Поднимаются вопросы о применимости .NET для high-frequency trading и оптимизации LINQ, а также о сравнении с JVM и другими языками (F#, Java).

Завершена работа над Wasm 3.0

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

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

• 64-битное адресное пространство. Память и таблицы теперь могут использовать i64 вместо i32, расширяя доступное пространство с 4 гигабайт до 16 эксабайт (теоретически). На вебе 64-битная память ограничена 16 гигабайтами, но для невеб-экосистем это открывает возможности для работы с огромными приложениями и наборами данных.

• Множественная память. Теперь один модуль может объявлять и напрямую использовать несколько областей памяти, включая копирование данных между ними. Это позволяет инструментам вроде wasm-merge работать со всеми модулями Wasm и открывает новые возможности для безопасности, буферизации и инструментирования.

• Сборка мусора. Wasm добавляет поддержку автоматически управляемого хранилища через сборщик мусора. Компиляторы могут объявлять layout структур данных через типы struct и array, а также нетипизированные целые числа — всё остальное, включая представление значений исходного языка, остаётся их ответственностью. Wasm предоставляет только базовые строительные блоки, избегая встроенных объектных систем.

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

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

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

• Расслабленные векторные инструкции. (Описание сокращено)

• Переход на 64-битную адресацию по умолчанию снимает ограничения для ресурсоёмких веб-приложений, таких как видеоредакторы.
• Добавлена низкоуровневая поддержка сборки мусора (GC), позволяющая компиляторам управлять структурой данных.
• Сообщество выражает разочарование отсутствием прямого доступа к DOM и JS-объектам из WebAssembly.
• Множественные памяти и улучшенная типизация ссылок могут оптимизировать взаимодействие с API (например, WebGPU).
• Разработчики отмечают проблемы с опытом использования (DX) и сложность компиляции в WASM.
• Обсуждаются потенциальные применения новых возможностей для языков C#, Java, Go и Python.
• Остаются нерешённые вопросы, такие как работа на микроконтроллерах и поддержка сокетов.

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

Fil-C вставляет pollchecks — проверки на необходимость остановки — на каждом обратном ребре управления в коде. Это короткая инструкция вроде testb, которая при срабатывании переходит к медленному пути обработки. Такой подход гарантирует, что GC может прервать поток только в безопасных точках, избегая проблем с регистрами или векторными инструкциями, и сохраняя корректность без invasive изменений в компиляторе.

• Fil-C использует механизм pollchecks для остановки потоков (stop-the-world), что необходимо для корректной работы fork(2), но поддержка vfork(2) пока отсутствует и требует нестандартных решений.
• Внедрение safepoint-ов в ассемблерный код рискованно и может нарушить предположения Fil-C о безопасности памяти; в долгосрочной перспективе планируется создать способ написания безопасного ассемблерного кода.
• Подход Fil-C к сборке мусора с опросом точек остановки (polling) создает нагрузку в tight loops, что решается разными оптимизациями (например, разверткой циклов), в отличие от асинхронных сигналов в Go.
• Мнения о читаемости и понятности реализации Fil-C разделились: одни участники находят ее интересной и хорошо объясненной, другие признаются, что не до конца понимают детали.
• Утверждение, что Java использует исключительно compacting GC, является упрощением, учитывая множество доступных конфигураций сборщика мусора в разных реализациях JVM.

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-переписей.

Проект LISP
Репозиторий krig/LISP заархивирован 28 авг 2025 г. и доступен только для чтения.
Разработка перенесена на Forgejo.

• Участники обсудили, что минималистичность Lisp объясняется простотой синтаксиса (s-выражения) и всего трёх базовых форм: quote, cond, lambda.
• @krig показал свой 750-строчный интерпретатор на Odin, подчеркнув, что это учебный проект, а не продакшн-решение.
• Появились вопросы по синтаксису Odin (различие := и =), а также замечания о скорости и полезности такого «игрушечного» кода.
• Упомянули полезные ссылки: оригинальную статью Маккарти, объяснение Грэма, описание semi-space GC от Andy Wingo.
• Некоторые участники поделились личными впечатлениями о создателе Odin и культуре обсуждений вокруг языка.

LISP FROM NOTHING
344 стр., 2025, Lulu Press, 6"×9", 19 иллюстраций, код бесплатно.

Купить: мягкий переплёт | твёрдый | PDF
Исходники | Превью (PDF) | Опечатки | Видео-обзор

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

Примеры кода

• Метациркулярный интерпретатор: CL, Scheme
• Компилятор (~400 строк): liscmp.lisp.html
• Система: lisp.lisp.html
• Сборщик мусора: gc.lisp.html

Весь код книги (~100 КБ)
λ-исчисление в Scheme (~6 КБ)
Генератор перфокарт Postscript
Обложка главы «Let There Be LISP»

• Читатели восторженно отзываются о сайте и книгах Нильса М. Хольма, называя их «личной поэзией» и «культурными артефактами», созданными ради самого процесса.
• Автор подтверждает: главное для него — красота и простота изложения, а не практическая польза или научная новизна.
• Покупатели жалуются на выбор: «хочется всё сразу», но автор советует начать с одной книги и прислал шпаргалку «какую выбрать».
• Обсуждаются входные требования: книга не для новичков; рекомендуют The Little Schemer, ANSI Common Lisp и A Gentle Introduction.
• Возник спор о названии «Lisp from Nothing» при пометке «не вводная книга»; автор уточняет, что «nothing» значит «с нуля», а не «для нулевых».

Go всё ещё плох

Кратко: автор 10+ лет критикует Go за архитектурные ошибки, которые легко было избежать.

1. Ошибки: неверная область видимости

bar, err := foo()
if err != nil { … }
if err = foo2(); err != nil { … }
// err висит до конца функции, хотя нужен только в двух строках

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

2. Два вида nil

var i interface{}
var s *S
fmt.Println(s == nil, i == nil, s == i) // true, true, false
i = s
fmt.Println(s == nil, i == nil, s == i) // true, false, true

Один «billion-dollar mistake» не хватило — сделали два.

3. Непереносимость

Условная компиляция через комментарии в начале файла — «аристотелевский» подход: теория без практики. Реальные проекты страдают.

4. append без чёткого владения

a := []string{"hello", "world", "!"}
foo(a[:1]) // внутри append
fmt.Println(a) // результат зависит от капасити слайса

Поведение неочевидно и требует знания внутренностей.

5. defer вместо RAII

В Java и Python ресурс закрывается автоматически при выходе из блока.
В Go приходится вручную писать defer foo.Close() и гадать, какие ресурсы вообще требуют закрытия.

• Go хвалят за простоту, быструю компиляцию, встроенные инструменты и удобную конкурентность.
• Критикуют «двойной nil», слабую систему типов, проблемы GC, неинтуитивный defer и скудные абстракции.
• Многие считают его «достаточно хорошим» для бэкендов и CLI-утилит, особенно при скорости разработки.
• Крупные проекты жалуются на «смерть тысячей порезов» и трудности отладки из-за строгости компилятора.
• Часть сообщества видит в Go компромисс между Node/Python и Rust, другие — устаревший язык без современных фич.

tinylisp — лисп-интерпретатор всего на 99 строк C.
Включает 21 примитив, сборщик мусора и REPL.
Доступны варианты с оптимизацией хвостовой рекурсии для ускорения и экономии памяти.

• Участники обсуждают крошечную реализацию Lisp, которую, по словам одного комментатора, могли писать для карманного компьютера Casio AI-1000 1989 г.
• Код раскритикован за «ужасный» стиль на C: злоупотребление double, нарушения strict aliasing и эндиан-зависимость.
• Предложены альтернативы: 100-строчный Lisp на Python, tinylisp, lispy.py Питера Норвига.
• Найдена синтаксическая ошибка в tinylisp (лишняя скобка) и отмечено отсутствие TCO, из-за чего Y-комбинатор не работает без доработки.

bolt — компактный встраиваемый язык на C:

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

Основное

• репозиторий: Beariish/bolt
• лицензия: MIT
• компилятор ~150 КБ, зависимости отсутствуют

Возможности

• синтаксис C-подобный, сборка мусора без пауз
• FFI к C «из коробки»
• компиляция AOT/JIT, кроссплатформенность (x86, ARM, RISC-V)

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

git clone https://github.com/Beariish/bolt
cd bolt && make
./bolt examples/hello.bt

hello.bt

import std.io;

fn main() {
    io.println("Привет, bolt!");
}

• Пользователи одобрили идею быстрого статически типизированного скрипт-языка для встраивания, но сразу спутали «embedded» с «embedded-systems» и отметили отсутствие поддержки ARM/32-бит и отказ от целочисленных типов.
• Критика синтаксиса import a, b from module: неудобен для автокомплита и повышает риск конфликтов имён; автор готов добавить псевдонимы.
• Сомнения в заявленной скорости: несколько человек привели замеры, где Bolt проигрывает LuaJIT и даже обычной Lua 5.4.
• Подняты вопросы о полноте типовой системы (генерики, полиморфизм), отладке, LSP, сборке мусора и долгосрочной поддержке.
• Плюсы: понятный C/Python-подобный синтаксис, удобный Result-тип, потенциальная замена Lua в играх и редакторах.