С чего началось. Боль
Как‑то я занялся решением алгоритмических LeetCode‑задачек. Так как я больше привык к реальным, прикладным задачам, для меня это было достаточно дико поначалу. Затем втянулся: это как решать головоломки. Я люблю разгадывать судоку, например, и в шахматы играть — это из той же оперы, развлекуха.
Так вот, решая задачки, я переосмыслил программирование в принципе и задался вопросом — почему такие простые задачки нужно решать так сложно? Ведь некоторые вещи достаточно очевидно решаются на уровне понимания, но становятся сложными на уровне написания кода.
И это касается не только разработки. Так же обстоит дело и в математических вычислениях — наверное, потому что у них общие корни. Я периодически размышлял над этим, когда делал рабочие проекты и свои pet project‑ы. И пришел к выводу, что основная причина — это закрытость. Многое делается под капотом, и разработчику (читай — пользователю языка) нужно многое додумывать, многое держать в голове, о многом догадываться, многое проверять.
Отсюда растет сложность, отсюда множатся ошибки, отсюда разработчики частенько выгорают. Забавно, что наши боли породили целую индустрию решателей таких болей — и даже не одну: тестирование, продуктивность, мотивация, лечение от выгорания, курсы программирования… (И все потому, что мы простые вещи делаем сложными способами.)
Тогда я задался вопросом, а как бы я сделал? Как можно сделать по‑другому? Наглядно и удобно, очевидно и просто? И пришел к очевидному выводу: надо сделать модель того, что происходит под капотом, когда исполняется код. И тогда я смоделировал обход списка с выполнением действия — по сути, foreach. У меня получился странник, который идет по 1D‑карте. Если добавить вложенный for, то странник уже идет по 2D‑карте и так далее…
Но мой подход был реализован теми же закрытыми средствами, и поэтому наглядности не получилось: да, метафорично, но не видно ни карты, по которой идет путник, ни самого путника. Тогда я остановился на этом и перешел к написанию ЯП — правда, цель у меня была другая:)
true
Первый ЯП ‑!true. Я написал его, так как в моём проекте понадобился простой скриптовый язык, и мне не хотелось тянуть в проект популярных тяжеловесов. Тогда я набросал синтаксис (читай — дизайн) и реализацию простейшего интерпретатора на Kotlin за минут 20 — это был простейший функциональный язык с операциями +, −, *, /. Затем ещё часа 2 я прикручивал математику в целом — со скобками и другими операциями. Потом ещё день экспериментировал, чинил, докручивал, доводил до ума все детали.
Вот простая программа на!true: она, подобно калькулятору, высчитывает выражение на каждой строчке и передаёт результат как аргумент для вычисления на следующей строке:
# описываем функцию main = args 1 + 2 *2 => increase => minus > 5 ? -1 : main #описываем функции plus, minus +1 : plus, increase -1 : minus # вызовем main => main
Запустим => main — и она вернёт 5.
= args— указывает на начало блока функции; каждая функция принимает аргументы.1 + 2— вычисляем, результат (3) передаём как аргумент для следующей строки.*2— 3 × 2, получаем 6.=> increase => minus— вызываем функцию по имениincrease, передаём в неё 6 (результат с предыдущей строки), получаем 7, передаём 7 в функциюminusи получаем 6.> 5 ? -1— если 6 > 5, то делаем −1 и получаем 5.То, что получилось в конце, — результат вычисления функции.
-1 : plus, increase— короткая запись функции в одну строчку (plus, increase — синонимы, алиасы).
Синтаксис довольно простой: если есть вопросы — задайте их, и я расскажу подробнее.
Язык чисто функциональный (pure functional): нет никаких сайд‑эффектов. Нет переменных: если нужны переменные (скорее, константы), то создаём однострочную функцию, которая вернёт единственное значение, и используем её.
Здесь не реализована наглядность, но я постарался реализовать лёгкость, простоту.
True
Дальше мне пришла идея сделать императивный язык. Во‑первых, хотелось‑таки хранить и переиспользовать данные, во‑вторых, мне реально пришла идея интересного проекта. А когда приходит идея — надо брать и делать, иначе не отстанет. )
Простая программа на True циклично увеличивает счётчик до 12:
main.true: 1 = counter : count <= 0 counter + 1 ?=> counter <= 1 = result, anyAlias lets do it = do, label => :count counter < 12 ? =^ do
Запустим main.true в интерпретаторе и увидим, как меняется counter шаг за шагом. Реально меняется значение в коде (строчка 3, value = counter), ну и подсвечивается строка исполняемого шага.
Название файла
1 = counter— именуем контейнер со значением 1.: count— именуем блок вычислений, функцию (опционально).<= 0— записываем 0 вresult(или в другое название, что дадим результат‑контейнеру).counter + 1 ?=> counter— вычисляемcounter + 1и копируем значение вcounter.<= 1— записываем 1 вresult= result— именуем контейнер, в него сохранится результат блока вычислений (опционально). Через запятую указаны синонимы (алиасы).lets do it = do, label— положили в контейнерdoданные «lets do it».=> :count— вызвать функциюcount.counter < 12 ? =^ do— если счетчик больше 12, то прыгаем на контейнерdo(контейнер служит также и меткой), по сути — goto. Можно так же использовать тернарник видаcondition ? true : false.
Изначально был другой синтаксис, но в результате экспериментов и докручиваний я сделал True вот таким. )))
Здесь я уже поработал и над простотой, и над наглядностью: мы можем двигаться шаг за шагом, видеть, как обновляются данные (не нужны ни логи, ни дебаггер, чтобы увидеть то, что в памяти, — всё обновляется интерпретатором прямо в коде программы). Код программы получается одновременно и как источник данных, и как набор инструкций.
Нет типов (typeless). По умолчанию всё — строка данных. Если хотим записать значение в контейнер, делаем так: value => container. А если хотим вычислить математику перед передачей, то делаем так: a + b ?=> c.
Тут стоит упомянуть вкратце, что на уровне языка программу исполняют акторы, агенты, вычислители, наблюдатели (называем как душе угодно; я использую agent, потому что это удобно и понятно, про что речь). Тут стоит упомянуть, что со строками можно работать как с фигурами по осям X, Y, Z. Ещё стоит сказать, что разделение на процессы происходит на уровне языка: один файл — один процесс; результаты можно запрашивать из main‑потока, когда они нужны. Ну и шагать можно как вперёд, так и назад — удобно при отладке. И самоочевидное, но всё же: программа может писать саму себя и выходить за пределы своего окружения при желании. В общем, я поработал над разными аспектами языка и интерпретатора…
Есть видео, как работает интерпретатор (правда, там прошлая версия True, но концепция сохранилась, синтаксис только поменялся, как я описал выше): Катаемся на лифте, на языке True
Вот так поворот!
Работаю я, значит, над новой версией языка: интерпретатор докрутил, движок переписал, доработал синтаксис — и тут я переключаюсь на другую задачу! Я ещё с универа работаю над решением одной сложной математической задачи, большинство называют её невозможной. ) Вот мне пришла идея, как ещё можно её решить, — и я переключился на неё.
В ходе экспериментов и исследования я вывел ряд онтологий по числам и вычислениям в целом, для того чтобы решить задачу. Спойлер: так и не решил. ))) Но выведенные онтологии натолкнули меня на мысль про вычисления в программировании, и тогда я провёл параллели к True и к движку, на котором он исполняется.
Онтологии здесь не привожу, так как они крышесносные, нестандартные, а я и так здесь уже ввёл два новых ЯП. Так что как‑нибудь в другое время и в другом месте.;)
Та‑ак, вот! В итоге я пришёл к тому, что «под капотом» в моих языках программирования вертится чистая механика: по сути, там получается всегда машина Тьюринга или набор таких машин. (Вангую, что если копнём вглубь любой существующий ЯП — найдём там машину Тьюринга.) И чтобы было наглядно и просто, мне нужно показать ту самую машину, что «под капотом», — показать ту самую механику, которая всегда одинакова, на каком бы языке мы ни программировали!
Так я и «отказался» от развития языков True и!true и перешёл на построение такой машины, которая будет решать алгоритмические и практические задачи наглядно. Делаю прототип, напишу об этом в отдельной статье. (Название ещё не устоялось. Кстати, можете предложить в комментариях, кому интересно.)
И да, может быть, когда будет время, снова вернусь к своим ЯП, а пока что они на паузе, ибо я полностью погрузился в новый проект!
Что дальше?
Самому работать сразу над десятком проектов — не айс (а чувствуется, их у меня реально что‑то около десятка), так что я периодически переключаюсь между ними. И вот что я подумал: если кому интересно и есть желание присоединиться и поработать, например, по True, Simple и/или!true, — напишите мне, обсудим.
Если есть какие‑то вопросы — задайте их в комментариях.
Я всё. Обнял.:)

