The Jerusalem PostActivists rally at Erez Crossing against Gaza aid deliveries, accuse Israel of strengthening HamasInquirerWalang Pasok: Class suspensions on Friday, Nov. 20PunchEPL: My ex-agent blocked dream move to Arsenal – MudrykSky TG24Pagine, la rassegna stampa di Sky Tg24 del 20 novembreInquirer EntertainmentBINI members fangirl over BTS at Taiwan concertRTL BoulevardTwee gewonden na felle brand op zolder van rijtjeshuis in DelftCNN TürkGÜMÜŞ FİYATLARI NEDEN DÜŞÜYOR? 20 Kasım Gümüş Gram Fiyatı Ne? Gram Gümüş ve Ons Gümüşte Sert KayıpStraits Times SportLoh Kean Yew bows out of Hong Kong Open after q-final defeat by India’s Lakshya SenWirtualna PolskaZawyły syreny. Rodzice pytali, czy posyłać dzieci do szkółZDF heuteEntdecken Sie das ZDF-NachrichtenstudioSRF NewsKrankenkassenprämien – Veraltete Prämienregionen: Die Ungerechtigkeit bleibtObservador DesportoSó 13% dos PPR conseguiram superar a inflação em cinco anos
The Daily Newsstand · Free, Always
Friday, November 20, 2026

Как я написал 2 языка программирования и решил отказаться от разработки ЯП вовсе…

Translate

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

View the original on Хабр →

KioskNews shows a cleaned-up reading view extracted from the publisher’s page — the original always lives on their site, not ours.