Электроника МК-61

Сегодня наконец закончился процесс переноса кода «МК-Про» на C++. Переписывание заняло около восьми дней, использовались три нейросети. Основной каркас был перенесён с помощью «ГПТ-5.5», часть тестов довольно механически переносилась нейросетью «ГПТ-5.3-Кодекс-Спарк», а последние штрихи вносил и баги чинил «Опус 4.8».

Производительность трансляции улучшилась в среднем в 2,5 раза. Есть один регресс у одной короткой программы, которая выполняются до 50 миллисекунд, но это, скорее всего, погрешность: не исключено, что в этот момент в фоне стартовало что-то тяжёлое.

За восемь дней было переписано 122 тысячи строк, которые превратились в 145,5 тысяч строк на C++.

Самое интересное в советских программируемых калькуляторах — исследовать их недокументированные возможности, или, иначе говоря, баги. Я сейчас говорю про «Электронику МК-61», с эмуляторами которой я вожусь уже которую неделю, но, в принципе, в любой модели их было навалом. И что мне сейчас кажется странным — эти модели выпускались годами, но баги никто не исправлял.

Например, «МК-61» выпускали с 1984 до 1991 года, но ни один баг, насколько я знаю, не исправили. В принципе, с частью багов жилось даже веселее — бо́льшая часть из них позволяла, при известной фантазии, уменьшать размер программ, что, конечно, при объёме памяти в 105 ячеек очень даже полезно. Но непонятно, почему нельзя было исправить хотя бы те, которые влияли на вычисления.

Таких багов я знаю два: функция вычисления максимума считает ноль самым большим числом (можно попробовать ввести 500 В↑ 0 max, чтобы убедиться), а второй — генератор случайных чисел начинает зацикливаться, если попробовать взять целую часть случайного числа.

Разворот из брошюры «Elektronika MK-61 Calculator Operating Instructions»

Если к первой ошибке можно было привыкнуть — и я даже видел игры, где это свойство использовалось, — то ломающийся генератор, во-первых, никаким полезным свойством не обладал, а во-вторых, увеличивал размер программы, потому что целую часть приходилось получать другими способами, вместо функции F [x], которая для этого предназначена.

Почему эту проблему нельзя было решить, выпустив условную «Электронику МК-61М», для меня загадка. С одной стороны, страна гордилась своей инженерной школой — и отголоски этой гордости до сих пор хорошо заметны. С другой — такое вот безразличие к багам в массовых моделях.

По моим ощущениям, я должен был перевести с помощью нейросети на Си++ код транслятора языка программирования высокого уровня «МК-Про» для «Электроники МК-61» к вечеру воскресенья. Да, там много сложного кода, но мне казалось, что синтаксически перевести одно в другое, а потом посмотреть на тесты — довольно простая задача для современных нейросетей.

В реальности же пошёл уже шестой день. С некоторыми перерывами, конечно: иногда работа, например, прерывается ночью — сеть ждёт от меня ответа на какой-то вопрос, а я сплю. Так что можно считать, что шестой день работа идёт примерно с семи утра до одиннадцати вечера.

В данном случае мы наблюдаем горе от ума: сеть попроще — GPT-5.3-Codex-Spark — перебрасывает код именно по той схеме, которая была у меня в голове: «айда перепишем, а потом посмотрим на тесты», но у неё быстро кончаются лимиты. А вот ГПТ-5.5 работает более методично: переписывает кусками, основываясь на том, что показывают тесты. Так медленнее, да ещё и тесты гоняются по многу минут, а их много, поэтому всё и идёт туго.

Я согласен с тем, что так, наверное, лучше, потому что это позволяет скорректировать архитектуру, поэтому особо не настаиваю, но ждать уже надоело. В данный момент прогресс такой: перетащено всё — основной код транслятора, оптимизирующие стратегии (их более 300), тесты синтаксиса проходят, но эталонные программы транслируются байт в байт не все: ещё около двух третей сильно отличаются от эталона.

Сейчас транслятор «МК-Про» — языка высокого уровня для «Электроники МК-61» — написан на ТайпСкрипте. Я выбрал этот язык по двум причинам: хотелось на него посмотреть, и была идея прикрутить транслятор к эмулятору «МК-61», который работает в браузере.

Но вчера я решил переписать его на Си++. При помощи нейросети, конечно. Производительность ТайпСкрипта стала серьёзным блокером: в процессе трансляции оптимизатор перебирает огромное количество вариантов, чтобы уместить программу в 105 байт, и иногда этот процесс занимает минуты. Надеюсь, перевод на Си++ решит эту проблему.

Интересно, за какое время нейросеть справится с этой задачей. Проект большой: около 80 тысяч строк только основного кода; кроме того, очень много тестов — около двух тысяч, если ничего не путаю, — и есть эталонные программы, которые должны скомпилироваться байт в байт.

Спустя полтора часа транслировалось уже десять программ и я удивился такой скорости, пошёл читать исходники, а там, то, что на скриншоте — чёртова ленивая нейросеть просто затолкала внутрь кода эталонный результат десяти программ. Офигенное решение.

Как я когда-то говорил, будь сейчас менее просвещённое время, я обязательно основал бы секту по сохранению любой информации, пусть даже самой незначительной и малоинтересной. Мне плохо физически, когда я понимаю, что какие-то знания утрачены навсегда, и я очень радуюсь, когда исследователи находят что-то новое, до сих пор неизвестное.

Думаю, заметно, что последние несколько недель я занят языком «МК-Про» — при помощи нейросеток пишу высокоуровневый язык для калькулятора «Электроника МК-61». В рамках этой же движухи я также собираю себе в репозиторий все игры для этого калькулятора, которые так или иначе упоминаются в источниках, которые мне приходится штудировать. Благо с этой работой нейросетки справляются на четыре с плюсом, но зато куда быстрее, чем это мог бы сделать я.

В процессе вышел на архивный сайт, где когда-то были опубликованы самоиздатовские выпуски клуба любителей игровых программ «КЛИП» — довольно известного и хорошо организованного движения ранних 90-х. Его участники увлекались программированием на «МК-61», а лучшие программы публиковались.

К сожалению, в архиве сайта выпуски не сохранились, но меня это только раззадорило: я решил попробовать выйти на бывших организаторов клуба в надежде, что у них сохранились сканы. Пока я этим занимался, случайно нашёл во «ВКонтакте» паблик человека, который пытался возродить исторический интерес к «МК-61» и выложил часть номеров. Я предположил, что у него могли сохраниться и остальные, и не ошибся.

У бывших организаторов, к слову, сканов не оказалось. Конечно, речь только о тех, с кем я смог связаться: не всех можно найти в интернете спустя три десятилетия. Найденные сканы я передал одному из них, и скоро они будут опубликованы на самом известном, наверное, сайте из тех, что посвящены программируемым калькуляторам, — «Кон-Тики».

Разворот девятого номера «Экспресса» (1991 год) — издания клуба по калькулятору «Электроника МК-61»

Язык высокого уровня для программируемого калькулятора «Электроника МК-61», который я начал писать с нейросетью, теперь называется «МК-Про». Надо же его как-то называть.

Вообще, начал я его писать, потому что меня спросили, не знаю ли я какую-то задачу, с которой сегодняшние нейросети не справятся. Не то чтобы я ожидал, что совсем ничего не выйдет, но думал, что хорошо, пожалуй, не получится. Задача — сделать язык программирования, который будет транслироваться в код, которому доступно всего 105 ячеек, — мне показалась достаточно сложной.

Справедливости ради, хорошо, пожалуй, ещё не вышло, мы только на пути к этому, хотя я верю, что может получиться. Тот вариант, который сейчас уже есть, я оцениваю где-то на три с плюсом. Последние несколько дней нейросеть занята самой, наверное, сложной оптимизацией, которая только есть, — использованием регистра X2 в калькуляторе.

На скриншоте видна очередная сессия, которая, как можно заметить длится без перерыва уже более тридцати часов и до конца ещё очень далеко — неделя или около того. Чтобы сеть не прерывалась, я выставил так называемую «цель», её видно на скриншоте.

105 байт памяти, стек и пятнадцать официально доступных регистров вынуждают использовать самые нетривиальные хаки. Их очень много: если начать рассказывать, я буду писать только о них. Самый нетривиальный, как оказалось, — хак с использованием регистра X2. Это недокументированная возможность, поэтому её использование не очень распространено.

Это не вполне регистр, скорее техническая ячейка для хранения копии экрана, но в программном режиме она обрастает некоторым количеством багов — их вообще в этом калькуляторе полно, — что позволяет использовать её в некоторых случаях как ещё один регистр. В основном — для хранения промежуточных значений.

Я собрал очень много готовых программ — больше четырёх сотен, и в самых плотно упакованных все регистры уже заняты. Выгрузить их тоже некуда: памяти, напоминаю, очень мало — сотня байт, поэтому X2 там очень даже к месту.

Интересно, насколько хорошо будет работать оптимизация, когда нейросетка её доделает. Хотя мы всё обвешиваем тестами, промежуточный результат пока ничего не даёт, кроме расхода токенов: оптимизацию можно будет полноценно включить только в самом конце. Очень жду завершения этого этапа: так долго подпинывать нейросеть без промежуточного результата — скучновато.

Так исторически сложилось, что серьёзно программировать с нейросетями я начал с «Курсора». До сих пор его использую, и планов куда-то переходить у меня не появлялось.

«Курсор» — специализированная среда разработки, заточенная под работу с нейросетями. В ней есть очень много специальных костыликов, позволяющих нейросети делать свою работу. Такие среды дают огромный прирост по сравнению с копированием кода из окна нейросети — тем, с чего мы все начинали.

Недавно братишка уговорил меня попробовать «Кодекс» — конкурирующую среду разработки, которую делает компания «Оупен-Эй-Ай». Аргумент он привёл очень убедительный — стоимость.

Не обманул: позже я убедился, что в рамках подписки за двести долларов можно работать почти с любой интенсивностью. Там, где в «Курсоре» легко тратились двести долларов в день, тут я, заплатив один раз, больше ничего не плачу́.

Объяснение простое: «Курсор» в основном перепродаёт токены чужих нейросетей, зарабатывая на разнице, а «Кодекс» продаёт токены нейросетей той компании, которая его делает.

При этом с «Курсором» мне работать приятнее. Не из-за эффекта утёнка, а из-за двух вещей, которые в «Кодексе» сделаны плохо.

Во-первых, «Кодекс» очень плохо сжимает контекст. Наверное, все знают, что у нейросетей есть так называемое «контекстное окно» — что-то вроде кратковременной памяти, где хранится ваш текущий разговор. И «Курсор», и «Кодекс» умеют заставлять сеть пересказывать себе ваш текущий разговор в более краткой форме, чтобы высвободить часть контекстного окна, когда оно приближается к пределу, но у «Кодекса» это получается плохо.

Я часто вижу, как «Кодекс» принимает часть моих указаний, на которые он уже отвечал, за сигнал к действию и начинает выполнять задачи, которыми уже занимался. В «Курсоре» я такого не видел ни разу.

Во-вторых, «Кодекс» плохо работает с планами. В «Курсоре» я частенько ставил большую задачу, он писал очень подробный план, показывал мне его, разбивал задачу на более мелкие, а потом очень долго воплощал план в жизнь, не останавливаясь, пока не доведёт дело до конца.

У «Кодекса» есть режим планирования, но развёрнутые планы он не пишет, а тем планам, которые пишет, не всегда следует. Он может без видимой причины остановиться, не доделав задачу; в этом случае мне приходится его подпинывать словами «делай дальше» или «продолжай».

В отпуске я очень много использую «Кодекс» — каждый день для развлечения пишу язык высокого уровня для калькулятора «Электроника МК-61», и у меня постоянно в стеке команд вереница фраз «делай дальше и коммить». Они подставляются по одной, когда сеть останавливается.

Выводы.

«Кодекс» я и дальше планирую использовать для своих собственных задач. Всё-таки возможность тратить меньше денег на хобби — существенный плюс, даже с учётом возрастающих затрат на управление. К счастью, возрастают они несущественно.

Бюджет «Курсора» буду тратить на работе. Во-первых, это позволит мне программировать для себя и компании в один и тот же день: раньше я разделял их, чтобы чётче понимать, сколько денег мне надо вернуть; во-вторых, затраты на управление для меня дороже в рабочее время, у меня очень высокая загрузка, и всё время дёргаться и смотреть, что там сделала сеть, для меня не вариант.

Очень интересно разбирать хаки, которые разные люди изобретали, чтобы уместить свои программы в 105 байт памяти калькулятора «Электроники МК-61». Их там действительно просто нереальное количество, они разной сложности, но один из них показателен в своей простоте.

В коде программы «Рембо-III» есть несколько похожих мест (я буду приводить код на языке «МК-Про» для наглядности):

fn lost() {
  halt("ЕГГОГ")
}

fn front_stop() {
    …
    if cells[7] < 0 {
      lost()
    }
    …
}

Если некое проверяемое значение меньше нуля (в двух остальных местах — меньше или равно нулю), то пишем на экране «ЕГГОГ» — слово «error», это одно из немногих слов, которое калькулятор способен отобразить, так как у него есть специальная логика для отображения некоторых букв, поэтому его часто используют для обозначения проигрыша.

Мой оптимизатор умеет заменять halt("ЕГГОГ") одним опкодом, потому что это «встроенное» в калькулятор слово, но тут он пишет относительно много кода — проверка условия и вызов, тогда как проверку и вывод «еррора» можно объединить в один опкод — F √ или F lg в зависимости от условия.

Если число строго меньше нуля, квадратный корень из него даст ту же ошибку, как и логарифм от числа, которое меньше или равно нулю.

В «Рембо-III» это сокращает программу на четыре байта. Это существенно, когда у доступно так мало памяти.

Я тут довольно большой проект начал — язык высокого уровня для программируемого калькулятора «Электроника МК-61». В прошлом я с ним немного сталкивался и даже писал десять лет назад «Песню о пиве» для него.

Программирую вайбкодингом, разумеется, лучшими нейросетями из доступных — «Опусом 4.8» и «ГПТ 5.5». Вручную это проект на годы, без сеток я бы его даже не начинал.

Основная сложность — скромные возможности. На программу выделено всего 105 байт и несколько регистров, которыми можно оперировать, поэтому все лучшие программы написаны просто с нереальным количеством хаков, использующих как универсальные вещи (вроде возвратно-ориентированного программирования), так и специфические вещи, основанные на аппаратных особенностях и багах и багах калькулятора.

Калькулятор «Электроника МК-61» по версии сети «Нанабанана-2»

Ядро языка уже давно написано и даже пережило несколько рефакторингов, но до конца ещё далеко. Я перевёл на него несколько существующих кодовых бриллиантов, чтобы разобраться с применёнными там приёмами оптимизации и моему транслятору до таких вершин ещё далеко.

Сейчас я, например, разбираюсь с упаковкой нескольких переменных в один регистр. Идея простая, но позволяет иногда экономить очень много: если у нас есть три переменные и каждая принимает значение от нуля до десяти, то можно хранить их в одном регистре поразрядно от «00.0» до «99.9».

Так, например, переписывается в текущем синтаксисе игра «Охота на лис» из блога Дениса Монатко:

program FoxHuntMK61 {
  field: board(0..9, 0..9)

  state {
    cell: coord(field)
    foxes: coord_list(field, 9) = random_unique()
    bearing: counter 0..9 = 0
  }

  loop {
    cell = read()

    if cell in foxes {
      found_fox()
    }

    scan_from_cell()
    show("--", cell:02, "--", bearing)
  }

  fn found_fox() {
    show(-20)
  }

  fn scan_from_cell() {
    bearing = line_count(foxes, cell)
  }
}

Это один из более чем двадцати примеров, где оптимизатор справляется лучше или на уровне опытного программиста на этом калькуляторе.

Тот самый калькулятор «Электроника МК-61», который попал мне в руки

Как и обещал в прошлый раз, хочу рассказать с какими сложностями мне пришлось столкнуться при написании «Песни о пиве» на программируемый калькулятор «Электроника МК-61».

Калькулятор попал ко мне для передачи в компьютерный музей, который готовится к открытию в высшей школе «ИТИС» и у меня и мыслей-то не было что-то под него писать — хотелось лишь посмотреть что из себя представляет написание программ под этот гаджет, с которыми я много сталкивался в детстве через журнал «Наука и жизнь».

В процессе изучения я наткнулся на заинтриговавшую меня вещь. В некоторых операциях калькулятор переключался в режим шестнадцатеричного счисления, о чём сигнализировала восьмёрка и точка в первом разряде.

По этой таблице калькулятор отображает шестнадцатеричные числа

Как видно по таблице выше, отображение этих чисел сильно отличается от общепринятого (как правило для цифр больше девятки используются латинские буквы от A до F) и я не мог не отметить, что с их помощью легко написать английское «beer» («пиво»).

Тем более мне очень повезло в том, что индикацией этого режима является именно восьмёрка, стоящая спереди — так похожая на первую букву в нужном мне слове. Как вы теперь понимаете, на экране в моей программе написано не «BEEr», с точки зрения калькулятора там одни числа и индикатор режима — «8.EEГ» или «EED» в привычной записи (десятичное «3821»).

Так же я воспользовался тем, что «F» в этой странной нотации — пробел, что позволило мне отделить число от «надписи». Дальнейшее — дело техники.

Листинг из предыдущего поста начинается с подготовки данных в регистрах — нескольких масок на которые битовыми операциями в дальнейшем наложатся числа так, чтобы получилась нужная мне «строка». Настоящая программа начинается с нажатий на «В/О» и «ПРГ», и активно пользуется подготовленными данными.

Маски и оставшиеся числа побитно накладываются двумя подпрограммами — по отдельности на диапазоны 0…5 и 6…9 — способы их получения разнятся. Я широко использую операцию «ИНВ» — она инвертирует биты числа, по логике инвертирования цифры 6…9 превращаются в на свои позициях 9…6, и тут никаких сложностей, а знаки в диапазоне 0…5 получаются сложнее — там накладываются сразу две специальные маски и счётчик.

Для примера кусочек подпрограммы, номер слева соответствует номеру инструкции при вводе в калькулятор и каждую строку я прокомментирую, но следует понимать, что в реальности эти комментарии частью программы не являются:

// когда что-то попадает в «X» предыдущее значение смещается в «Y» (там стек из 4 позиций)
45 1 // «1» кладётся в регистр «X», входной параметр сместился в «Y»
46 + // Y + 1, передаётся в «X», это коррекция данных после операций, которые шли выше
47 К П→Х 7 // в «X» помещается число из регистра (маска), указанного в регистре №7
48 + // Y+X → X
49 ИНВ // инвертирование битов в «X», сейчас на экране написано «8.EEГ» плюс некий пока мусорный символ
50 К П→Х 8 // в «X» помещается число из регистра, указанного в регистре №8
51 ^ // операция «И», на экране — «8.EEГ», из некого символа получилось требуемое число
52 В/О // возврат из подпрограммы

Десятки и единицы выбираются адресами масок, которые я передаю при помощи косвенной адресации, хорошо, что такое вообще есть в языке — это позволяет эффективно пользоваться подпрограммами.

Подпрограмма вызывается два раза с разными параметрами — для десятков и единиц, получаются две маски, которые позднее накладываются друг на друга.

Сильно расстраивает отсутствие памяти для долговременного хранения, в устройстве хоть и есть батарейный отсек, но при любом сбое питания (батарейки сели, а блок питания не подключен), память калькулятор сбрасывается и программу придётся набрать заново. То же ожидает и в случае, если одну программу нужно будет заменить другой — хотя программы можно запускать с произвольного адреса, много их в память не уместится — её ёмкость всего 105 инструкций.

«Электроника МК-61» с запущенной на нём программой

59. Язык калькулятора Электроника МК-61. «Электроника МК-61» — устройство из класса «программирумых калькуляторов». Были когда-то такие гаджеты, позволявшие со всеми ограничениями калькуляторов (небольшая клавиатура, типичный для калькулятора экран) писать программы.

В детстве такие калькуляторы я видел только на картинках в журнале «Наука и жизнь», а программы для них были каким-то любопытным закорючками, в которых не разобраться.

Вчера мне в руки попал настоящая «Электроника МК-61» (для передачи компьютерному музею) и я наконец-то на обеде и потом вечером разобрался в этих странных значках.

Так выглядят мои «99 бутылок…» на этом калькуляторе:

8112000 Х→П c 8 + ИНВ Х→П b Вх 10 ÷ [X] Х→П d 8 + ИНВ Х→П e В/О ПРГ
П→Х 0 1 0 ÷ [x] Х→П 1 Вх {x} 1 0 × Х→П 2
1 1 Х→П 8 1 2 Х→П 7 П→Х 2 ПП 34 Х→П a
1 4 Х→П 8 1 3 Х→П 7 П→Х 1 ПП 34 П→Х a
^ С/П
6 - /-/ x<0 45 9 + К П→Х 7 + ИНВ В/О
1 + К П→Х 7 + ИНВ К П→Х 8 ^ В/О

Поскольку у меня в блоге скорее всего отсутствуют любители работать каждый день с калькуляторами советских времён, то я не буду придерживаться принятой нотации с номерами — не думаю, что кто-то будет это набирать.

Вкратце о языке. Больше всего это похоже на крайне примитивный ассемблер с гипертрофированным математическим сопроцессором. Всё то же — переходы на адрес, одно- и двухбайтные инструкции с операндами, регистры с определёнными назначениями, сильно ограниченная память (105 команд), наличествует косвенная адресация и подпрограммы (стек вызовов размером в пять вхождений).

До запуска программы нужно в регистр «0» поместить стартовое значение (например, «99», «Х→П», «0») и запустить программу «В/О», «С/П».

Это я сделал из-за того, что цикла в программе нет — из-за мельтешения разрядов совершенно не понять, что происходит. Хотя добавить его очень просто — до команды «С/П» надо вставить одну проверку с переходом и сдвинуть адреса.

Поэтому на вход подаётся нужное число, например, «42», а на выходе мы можем полюбоваться фразой «BEEr 42». Не весть что, но что вы хотели от калькулятора? Кстати, выводимая фраза — не строка (спойлер: а число), о том как мне пришлось помучаться я ещё расскажу.