Как я сделал язык 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 вместе с комментариями :) , и состоял из одних чистых функций. Я чуть-чуть застрял на математике, получил интересный опыт разбора мат-операций и их выполнения, ну ок, вроде всё сделал. Но упёрся в то, что одними чистыми функциями сыт не будешь. В реальном мире нужны состояния, и тут всю стройность языка как рукой сдуло. Можно было докрутить и использовать этот неидеальный вариант, но тогдашний перфекционист во мне решил, что всё не так, и это неудачное решение, и вообще ничего-то не получается, и я переключился на другие задачи.

Язык точно не помню, было что-то вроде:

# Пример 1 123 = args 1 + args + 2 * 3 = main # Пример 2 = args abc, func1 => func2 => func3 = main

Как видите, имён переменных вообще нет, есть только имена функций и параметр 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:

1| Mr.Green, #5fb85f | Data as | Aim: 0 2| 3| 1 = a 4| = b 5| = c 6| 7| a => b 8| b -> c

Именуем контейнеры 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

А вот мои первые ласточки, статьи т.е.: Habr | Reddit

Я сделал это! Ееееее! ))))

Добро пожаловать к обсуждению если есть такое желание :)