С чего началось. Боль

Как‑то я занялся решением алгоритмических 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.

  1. = args — указывает на начало блока функции; каждая функция принимает аргументы.

  2. 1 + 2 — вычисляем, результат (3) передаём как аргумент для следующей строки.

  3. *2 — 3 × 2, получаем 6.

  4. => increase => minus — вызываем функцию по имени increase, передаём в неё 6 (результат с предыдущей строки), получаем 7, передаём 7 в функцию minus и получаем 6.

  5. > 5 ? -1 — если 6 > 5, то делаем −1 и получаем 5.

  6. То, что получилось в конце, — результат вычисления функции.

  7. -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. Название файла

  2. 1 = counter — именуем контейнер со значением 1.

  3. : count — именуем блок вычислений, функцию (опционально).

  4. <= 0 — записываем 0 в result (или в другое название, что дадим результат‑контейнеру).

  5. counter + 1 ?=> counter — вычисляем counter + 1 и копируем значение в counter.

  6. <= 1 — записываем 1 в result

  7. = result — именуем контейнер, в него сохранится результат блока вычислений (опционально). Через запятую указаны синонимы (алиасы).

  8. lets do it = do, label — положили в контейнер do данные «lets do it».

  9. => :count  — вызвать функцию count.

  10. 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, — напишите мне, обсудим.

Если есть какие‑то вопросы — задайте их в комментариях.

Я всё. Обнял.:)