И первым делом добавляют в язык GC, с подсчетом ссылок в куче и оптимизируют “stop the world”. Мы же сегодня задумаемся не об оптимизации байтиков, а об оптимизации архитектуры.

Но у нас же уже есть безопасный яп дома, папа!

Да, Rust экономит на сборщике мусора, но чето он слишком сложный: borrow checker, лайфтаймы и отдельная возня, как только объекты складываются в граф. Zig отдаёт память программисту, как и С, плюсы. Остальные живут с GC и его издержками.

Предлагаю попробовать добавить реактивность в это семейство.

Реактивный граф всегда знает, что и кого нужно дропнуть, а сборщик выясняет то же самое только обходом кучи. Значит, граф может сам освобождать память и ресурсы, и сборщик ему не нужен. Это мой эксперимент \ исследовательская деятельность: я попробовал сделать язык wire, где есть только граф. И конечно сделал замеры. Наглядный пример:

Excel, самый популярный реактивный ЯП в мире

Формулы в Excel это чисто функциональная программа, а с LAMBDA ещё и полная по Тьюрингу. Excel строит дерево зависимостей между ячейками, изменили ячейку — всё зависимое помечается dirty и пересчитывается. Никто не подписывается на A1 и никто от неё не отписывается, ссылка в формуле и есть подписка. Стёрли формулу и её зависимости исчезли вместе с ней. Сборщика мусора для формул там нет и никогда не было. Им бы только виртуальный рендеринг добавить

Бухгалтеры так живут с VisiCalc 1979 года. А мы пишем subscribe() в каждом компоненте.

Откуда реактивные ноги растут

У Алана Кэя в Smalltalk главное это сообщения и позднее связывание, он так сформулировал в письме 2003 года: «OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things». Кто ответит решается в момент обращения, но актуальность состояния поддерживают руками, MVC придумали чтобы удобнее контролировать состояние как раз. Pull-реактивность доводит позднее связывание до значения: сколько это равно, тоже решается в момент обращения.

Дмитрий Карловский в 2017 году назвал эту парадигму Объектно Реактивным Программированием (ОРП). Метод при вызове запоминает что прочитал, кеширует результат и сбрасывает кеш когда прочитанное поменялось.

Сборщик не всегда спасает от утечек

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

Сборщик убирает память и ничего не знает про сокеты, файлы и таймеры. В Java для этого был finalize(), его признали ошибкой, и с Java 18 (JEP 421) финализацию собираются удалить. Поэтому в языках со сборщиком ресурсы закрывают руками: try-with-resources, using, defer.

Отдадим должное Erlang. Процесс владеет своими портами и ETS-таблицами, умер процесс и всё его закрылось, куча у каждого процесса своя, поэтому общего stop-the-world нет. Косяк в том, что рантайм не знает нужен ли кому то этот процесс. Еще и руками нужно значения проталкивать

Аутбокс это костыль, который нам навязали

Типичный кейс: сервис заказов пишет в базу и событие в Кафку, между двумя записями падает, это dual write. Лечат это через transactional outbox: событие кладут в таблицу той же транзакцией, а воркер фоном шлёт его в Кафку. Потом кто-то читает из Кафки и пишет свой аутбокс, чтобы отослать данные дальше. И так далее и так далее…

А зачем всё это? Например, складу нужно знать сколько соли свободно. Это просто «было минус заказали». В Excel это одна формула со ссылкой на ячейку с заказами. На бэке вместо ссылки цепочка из таблиц, воркеров и Кафки, только чтобы склад узнал, что заказы поменялись. Ещё и следят, чтобы одно событие не пришло дважды, а то два раза спишется.

На wire остаток читает заказы, как формула ячейку:

object $bog_wire_salt_orders {

	solid ids( next?: list text ) {
		return next ?? []
	}

	solid order( id: text, next?: int ) {
		return next ?? 0
	}

	sum(): int {
		return ids.map( order ).sum
	}

	action add( id: text, count: int ) {
		ids( [ ...ids, id ] )
		order( id, count )
	}

}

object $bog_wire_salt_balance {

	orders: $bog_wire_salt_orders

	total(): int {
		return 10
	}

	free(): int {
		return total - orders.sum
	}

}

object $bog_wire_salt {

	solid orders() {
		return $bog_wire_salt_orders()
	}

	solid balance() {
		return $bog_wire_salt_balance {
			orders <= orders
		}
	}

}

object $bog_wire_salt_app {

	solid salt() {
		return $bog_wire_salt()
	}

	action main() {
		salt.orders.add( "o1", 3 )
		salt.orders.add( "o2", 2 )
		print( "свободно {salt.balance.free}" ) \\ свободно 5
		salt.orders.order( "o2", 5 )
		print( "свободно {salt.balance.free}" ) \\ свободно 2
		salt.orders.order( "o1", 0 )
		print( "свободно {salt.balance.free}" ) \\ свободно 5
	}

}

Нативная программа на wire начинается с action main().

order это канал, как в $mol. Один метод и читает, и пишет:

  • order( "o2" ) читает заказ, а если его не было, отдаёт 0;

  • order( "o2", 5 ) записывает 5, и всё, что читало этот заказ, пересчитается.

Откуда balance берёт заказы? orders: $bog_wire_salt_orders это свойство без тела, его задаёт владелец через orders <= orders, как в view.tree.

free считается, когда его читают. Поменяли заказ, и следующий print выводит новое число. Событий нет, дублей нет.

Отмена это просто order( "o1", 0 ), без «компенсации\САГИ» и прочей ерунды.

Пример лежит в репозитории, вместе с тестами.

wire: реактивный ЯП без GC

Реализация реактивности взята из $mol_wire, но там TS всё таки, невозможно полностью на реактивный граф перейти: переменную или таймер всегда можно завести мимо него. Поэтому я сделал wire, там мимо графа ничего не положить:

  • переменных нет, лямбд нет, в map, find, upsert передаются именованные методы;

  • состояние это параметр next?, писать в него можно только из action;

  • тела мемо чистые, это проверяет компилятор;

  • solid это модификатор метода, а не вызов где-то в теле.

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

Компилятор на TS, генерирует C и собирает его zig cc. Каждый метод становится обычной функцией, вся реактивность сидит в wire_read. Вот free из примера с солью:

static void F_bog_wire_salt_balance__free( wire_obj* self, const wire_val* keys, const wire_val* next, wire_val* out ) {
	wire_val t77 = wire_read( self, &M_bog_wire_salt_balance__total, NULL, NULL );
	wire_val t79 = wire_read( self, &M_bog_wire_salt_balance__orders, NULL, NULL );
	wire_val t80 = wire_read( t79.obj, &M_bog_wire_salt_orders__sum, NULL, NULL );
	wire_val t76 = { .i = t77.i - t80.i };
	*out = t76;
}

Это free(): int { return total - orders.sum }. Так можно писать и руками на C против rt/rt.h, язык нужен только чтобы компилятор не дал завести таймер мимо графа)

Весь «сборщик мусора» рантайма:

static void reap( void ) {
	while( rt.touched.len || rt.orphans.len ) {
		wire_ids touched = ids_take( &rt.touched );
		for( int i = 0; i < touched.len; ++i ) evict( touched.items[ i ] );
		ids_free( &touched );

		wire_ids orphans = ids_take( &rt.orphans );
		for( int i = 0; i < orphans.len; ++i ) {
			wire_node* node = get( orphans.items[ i ] );
			if( node && !node->has_owner && !node->root ) destroy( orphans.items[ i ] );
		}
		ids_free( &orphans );
	}
}

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

Сколько это стоит

Сделал бенч с солью: список ids и канал order( id ) на каждый заказ. 10 000 заказов добавить, перезаписать, отменить и после каждой фазы посчитать сумму. На каждый заказ создаётся строка, которая читает свой заказ и должна умереть после отмены. Одно и то же на пяти стеках:

  • wire, граф без сборщика;

  • rust-wire, Rust с моим wire.rs, тот же граф на арене;

  • Node.js с $mol_wire, тот же граф поверх сборщика;

  • Go обычным push: подписка на заказ и ручная отписка при отмене;

  • Rust без всякой реактивности: вектор, словарь и цикл.

Процессор померил в инструкциях, память по пику занятой оперативки. macOS, arm64:

  • wire: 5,5 млрд инструкций, 24 МБ памяти;

  • rust-wire: 3,2 млрд инструкций, 19 МБ;

  • Node.js: 523 млрд инструкций, 385 МБ;

  • Go: 0,12 млрд инструкций, 10 МБ;

  • Rust: 0,45 млрд инструкций, 2,8 МБ.

После всех отмен живых строк ноль на всех стеках, то есть утечек нет нигде.

Репо: wire/bench

Ноду легко обогнать) а вот Go быстрее wire в 46 раз. Часть этого разрыва в самом бенче: в графе ids( [ ...ids, id ] ) копирует весь список на каждом добавлении, а отмена вычёркивает заказ проходом по списку, тогда как Go правит сумму на разницу. Остальное это цена графа: каждое чтение идёт через wire_read и узел атома. Куча работы ещё в общем

Где граф не поможет

Граф освобождает то, что стало ненужным. Иногда нужно держать по другой политике: кеш «пока хватает памяти», предзагрузка ассетов до того, как их кто-то прочитал, вариации анимаций, которые вот-вот понадобятся. Такую политику всё равно придётся описать, граф её не угадает. Описать её можно тоже реактивно, «что лежит в очереди, то и загружено», но думать о ней придётся.

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

Реактивность не бесплатна ?

Нет, как и GC. Я вижу большой потенциал для развития, а вы ? Пишите в комментариях

На Rust есть демо. Потом хочу сделать что то подобное на Go, С, С++, Zig

Кого начать препарировать первым ?)


Пишу про реактивность, $mol и свой язык в тг-канале @Dev_cmuser

Только зарегистрированные пользователи могут участвовать в опросе. Войдите, пожалуйста.
Нравиться ли вам идея с реактивными ЯП?
66.67%да6
33.33%нет3
Проголосовали 9 пользователей. Воздержался 1 пользователь.