Как я сделал язык True и интерпретатор Simple и еще один язык..
Боль
Года 3-4 назад я был Lead Android Developer, местами Teamlead, местами Techlead, местами стартапер (и до этого еще и местами фрилансером :) ). Опыта в разработке мобильных приложений вагон и маленькая тележка, плюс всякого разного нахватался по десктоп-разработке и плагиностроению под Chrome (и это все без AI! тогда).
В тот период я искал работу на новом проекте и упорно ходил по собеседованиям. Меня упорно отфулболивали, что-то вежливо отвечали, но итог один: работы не было. Тогда я решил проводить время с пользой и подтянуть скиллы, которые проседали на фоне остальных. Одним таким было решение алгоритмических задач на LeetCode.
Я начал решать задачки, смотрел разборы, снова решал, и достаточно быстро приноровился. То, что раньше мне казалось скучнейшим и никому ненужным занятием, стало для меня даже интересным, типа как головоломки решать. Я всегда был прикладным программистом, и решение реальных задач для меня было приоритетнее решения абстрактных, но теперь я распробовал и их на вкус.
Так вот, решая те задачки с литкода, я обнаружил, что нахожу существующие инструменты для решения таких задач недостаточно удобными, и увидел, что можно сделать лучше, удобнее.
Первое: не хватает наглядности. Многие вещи приходится держать в уме, додумывать, что создаёт большое поле для ошибок. Чем о больших вещах я догадываюсь, тем меньше я могу быть действительно уверен, что так и есть на самом деле. Плюсом к тому быстро расходуется ментальный ресурс, что снижает продуктивность в целом, вызывает усталость и заставляет тратить больше ресурсов на восстановление сил чем обычно. Есть и плюсы: раскачивается когнитивная функция как от пространственного и математического мышления, но все же.. (я могу и судоку поиграть или в Цивилизацию ;)
Второе (я думал об этом ещё раньше, и тут снова вспомнилось): что в математике, что в программировании у нас исполнитель всегда остаётся за кадром вычислений. Его как будто и нет, и он как бы не влияет на процесс вычисления, и вычисления могут происходить в каком-то идеальном вакууме. Но исполнитель, тот кто производит вычисления, тот кто выполняет инструкции, он ведь всегда есть, и он неотрывная часть любых вычислений. Любая цепочка бесконечного ряда обрывается как минимум когда исполнитель(выходит "покурить") прекращает своё функционирование, будь то человек или машина. Они могут умереть в процессе вычислений. Возьмём к примеру многопоточность, многопроцессность: если поток умирает, то что он делал, умирает вместе с ним.
И если сделать исполнителя явным, то он будет у нас на виду, и мы будем учитывать его в своих расчётах при работе с кодом. И снова: мы будем меньше додумывать, сколько у нас там запущено потоков, агентов, процессов и т.п., какие из них работают, а какие уже завершились. Мы просто бегло посмотрим и увидим: ага, вот они все, вот те активны, те остановились. И так во всем, в обходе структур данных тоже есть свои исполнители.
Третье: работа со структурами данных и с данными в целом переусложнена и сокрыта за названиями и терминами. И снова нужно многое держать в уме и додумывать. Проход в цикле по списку тоже надо прокручивать в уме, что легко когда он один, и становится сложнее с каждым вложенным.
Обратите внимание: всё, что я обозначил, заставляет нас разработчиков тратить ежедневно огромное количество энергии, догадываться об огромном количестве вещей одновременно. И при этом мы неизбежно делаем огромное количество ошибок. И вокруг этих ошибок даже выстроена целая инфраструктура по тестированию, правильному написанию кода, код-ревью, правильному менеджменту, правильной оценке задач. Восстановлению после выгорания. Да там целый ряд отраслей кормится на одних наших ошибках.
Кажется, было ещё что-то. Ладно, если вспомню, допишу.
Четвертое: таки вспомнил! Задачки та все по сути типовые, что на литкоде что в разработке в целом, но мы привыкли их решать вручную, да пишем какие-то библиотеки для удобства, но эти билиотеки то мы пишем вручную, "а что если хотябы часть из таких задач взять и решить на уровне языка?" - подумал я.. (это вдобавок к основной идее что описана ниже)
Пятое: Современные языки переусложнены, куча сущностей, абстракций, библиотек в которых еще больше сущностей и абстракций, и все они решают одни и те же задачи но по разному их формулируют и по разному называют.. Мы привыкли ругаться на Callback Hell, но почему-то терпимы к Class Type Hell или даже Any Name Hell - это же жесть! Вроде бы все делают для удобства, но чем больше делают тем неудобнее становится, языки сегодня стали громозкими неповоротливыми монстрами, даже самые простые из них этим грешат.
Идея
И вот я подумал: а что если сделать всё это скрытое открытым и явным?
Тогда я набросал прототип агента, который ходит по списку и выполняет операции с данными. Получилось интересно, но не дало мне удовлетворения.
Я тогда занимался своим проектом по кодогенерации: с графических макетов я генерировал каркас кода для экранов Android-приложения, генерировал интерфейс и бэк к нему (Controller/Presenter/ViewModel), в качестве интерфейса сначала XML, потом Compose. Проект переписывал несколько раз, делал прототип на Flutter, потом переписал всё на Kotlin Compose, потом ещё раз переписал. И в одной из итераций я пришёл к тому, что мне нужен простой скриптовый язык, язык, который я буду использовать для написания скриптов в интерфейсе генератора проекта из макетов, чтобы генерировать не только каркас приложения, но и кратко описывать логику к нему, этаким псевдокодом, из которого будет сформирован набор классов с функциями и переменными. Сейчас я вижу, как это можно сделать проще, но тогда у меня была такая идея, и я решил не тянуть существующие языки программирования из-за их громоздкости и неудобства работы с данными, а решил написать простейший свой под простые задачи описания архитектуры и моделей данных.
Я попробовал и неожиданно для себя за пару часов написал свой первый ЯП. Он получился функциональным. В нём я реализовал ещё одну свою идею: сначала пишем код, потом придумываем названия. Потому что я писал достаточно большие проекты, в которых нужно было много именовать, и иногда задача прерывалась на поиск подходящего имени и согласование его со всеми остальными именами. Это нормально, но я жаждал продуктивности и решил исключить такие прерывания на уровне языка: сначала пишем данные, затем если надо именуем, если не надо, не именуем.
Писал я его на Kotlin. Язык получился лаконичным, строк на 100 вместе с комментариями :) , и состоял из одних чистых функций. Я чуть-чуть застрял на математике, получил интересный опыт разбора мат-операций и их выполнения, ну ок, вроде всё сделал. Но упёрся в то, что одними чистыми функциями сыт не будешь. В реальном мире нужны состояния, и тут всю стройность языка как рукой сдуло. Можно было докрутить и использовать этот неидеальный вариант, но тогдашний перфекционист во мне решил, что всё не так, и это неудачное решение, и вообще ничего-то не получается, и я переключился на другие задачи.
Язык точно не помню, было что-то вроде:
Как видите, имён переменных вообще нет, есть только имена функций и параметр args. Так функции получаются чистейшими. А если надо создать именованную переменную - создаем функцию с одним значением внутри :) Еврика!)))
(Пока писал статью решил его таки реализовать, штуковина простая достаточно, и добавил в следующий релиз Simple + True, и знаешь как он будет называться? !true ))) )
Идём дальше.
Время от времени я возвращался к созданию своего языка программирования: писал в блокнотах, на листах A4 синтаксис, экспериментировал в уме то так, то эдак, реализуя синтаксис. Но до разработки дело не доходило.
И вот в этом году, даже в этом месяце или в конце прошлого, я однажды проснулся, и мне пришла идея, как докрутить до ума свой язык. Тогда я в течение дня, часов 12-14, написал реализацию языка (сначала на бумаге, затем построил прототип используя Алису + DeepSeek, забавная связка, я знаю).
Затем где-то неделю я докручивал язык с интерпретатором, сделал 2 версии, которые в итоге отбросил, и написал с нуля текущую реализацию(о которой писал в другой статье). Я делал на том, чем сам привык писать: Kotlin + Compose. И чем больше я добавлял функционала, тем сильнее разрастался проект, и AI начинал выдавать кучу ошибок. Поэтому я решил сменить подход: решил написать минимальную версию для демонстрации языка на самом простом инструментарии, который найду, и выбрал Python + Tkinter. Получилось коротко: вместо 10-ка тысяч строк кода меньше 1000. Это так же позволило сосредоточиться на ключевых аспектах языка и ещё лучше докрутить его.
И вот пару дней назад я закончил. Выложил всё в репозиторий на GitHub, написал доки, замутил демонстрационное видео, написал пару статей. На Reddit в одном из хабов меня забанили за то, что использовал AI при написании Simple. Я сказал направление, куда идти, матерком, в итоге мне забанили аккаунт, и я завёл новый, и пошёл в другое сообщество, где люди настроены более адекватно к использованию AI. И конечно я написал на Хабр, здесь сообщество приняло достаточно тепло, дома и стены помогают как говорится :)
Что сделал
Язык программирования True 0.9.6 + Simple 0.20.0. (скоро новая уже, сегодня-завтра, но пока оставлю текущую здесь)
Пример простой программы на True:
Именуем контейнеры a, b, c, копируем из a в b, перемещаем из b в c.
(ах да - в Simple программу на True исполняет исполнитель, т.е. агент, шаг за шагом, и именно агент определяет тип данных которые видит, в True вообще нет типов - все данные, все строка)
Описание, как видит строки программы агент Mr.Green
1. На себя не смотрит, смотрит на то, что под ним, и видит:
2. Пустой неименованный контейнер
3. Строка 1 в именованном контейнере a
4. Пустая строка в именованном контейнере b
5. Пустая строка в именованном контейнере c
6. Пустой неименованный контейнер
7. Действие копирования (=>) значения контейнера a в b (a: "1"; b: "1")
8. Действие перемещения (->) значения контейнера b в c (b: ""; c: "1")
Про True
- Программа это цикл. Если программу не остановить, она возобновит выполнение сначала.
- Цикл состоит из ряда строк.
- Агент идёт по строкам, определяет, как работать с данными (автоопределение типа данных).
- Данные для агента по умолчанию (Mr.Green) могут быть таких типов: неименованный контейнер, именованный контейнер, действие, действие с условием.
- Как работать с данными, решают агенты, циклы и функции расширения.
- Агент может перейти к любой строке цикла так: ^ N, или по имени контейнера ^ name
- Если действие обновило содержимое контейнера, то мы увидим, что оно обновилось сразу в коде.
- Консоли нет, нет print и т.п., так как весь код теперь отображает текущее состояние значений контейнеров в памяти
- У агентов могут быть разные правила к определению данных, каждый агент может работать с данными по своему.
- Остановить программу или использовать другие функции интерпретатора можно так: ::simple:pause, ::simple:new, ::simple:open, ::simple:exit.(здесь будет переименование, но в целом структура такая)
Финал
True сейчас это MVP, концепт.
Он не заменяет Python или Kotlin или еще чего..
Он показывает другую модель: программа это лента строк\линий, и она сама по себе может быть циклом, программу исполняет агент, исполнитель явный, данные обновляются в тексте программы на каждом шаге.
Если интересно, вот ссылка на GitHub: https://github.com/e39din/True
Я сделал это! Ееееее! ))))
Добро пожаловать к обсуждению если есть такое желание :)