(2023-04-24) (L)VTL as the starting point for LPC-oriented applications
-----------------------------------------------------------------------
Today, I released a new version of LVTL, called LVTL-O. It's still portable
and under 300 SLOC of C89, but optimized for both execution speed and memory 
consumption, as well as fixing some critical bugs. So, whoever uses LVTL-A 
(although I doubt many people have downloaded it over the course of two 
days), should switch to LVTL-O as a drop-in replacement. The main page at 
hoi.st no longer offers LVTL-A for download either, only the new LVTL-O 
version. The new sharball also has some more VTL-2 examples that I found to 
be working fine after all the bugfixes, including my all-time favorite game, 
Bulls and Cows. Although, of course, this B&C variant is easier to play 
because zeros are not allowed anywhere in the number.

By the way, why did I find Bulls and Cows so amusing and why does this
particular game bear a special meaning when it's run on VTL? Well, because 
it's the first game I encountered that doesn't need any real-time interface. 
It's a challenge-response type game. You send a four-digit challenge and 
receive a two-digit response. In fact, some time ago, I coded up a JS 
function version of this game where you pass your digits as a hexadecimal 
BCD number (e.g. if your guess is 1234, you pass 0x1234) and receive the 
response in the format BxCy, e.g. B3C1 for 3 bulls and 1 cow. And the entire 
game "interface" was just a function call (and another call to reinitalize 
it). You can wrap it into anything: graphics, text, voice, radioteletype, 
Morse code... Imagine playing Bulls and Cows over Morse. That's something 
you can't do with Tetris.

So, why is it significant that we can run B&C in VTL? Because VTL itself is
fully line-oriented, and all program editing flow is designed in a 
challenge-response fashion. In fact, it was designed with teletypes in mind, 
because not every computer hobbyist in the late 1970s could afford CRT 
displays, not to mention full-featured terminals. Home PCs with TV adapters 
that allowed to use home TV sets as displays would only appear a bit later, 
in the early 1980s. And, as even Tiny BASIC was so verbose it's a bit unfair 
to call it "Tiny", VTL allowed its users to save keystrokes, paper tape and 
teletype ink.

Speaking of paper tape... I don't actually know if the original design of VTL
was to also be fully compatible with the 5-bit ITA-2 code, also known as 
Baudot-Murray code, in its US variant, but it's quite close to that. The 
only exception is that ITA-2 doesn't have a character for a percent sign (%) 
and * (asterisk), so, as far as I understand, the bell character (S in FIGS 
mode, for US variant) is used instead of the latter, and we can extend the 
encoding by adding % as FIGS+CR or something. So, ideally, a "5-bit" version 
of VTL only uses these characters:

Bits  Letters Figures 
----- ------- -------
00000 null 
00100 space 
10111 Q       1
10011 W       2
00001 E       3
01010 R       4
10000 T       5
10101 Y       6
00111 U       7
00110 I       8
11000 O       9
10110 P       0
00011 A       -
00101 S       *
01001 D       $
01101 F       !
11010 G       &
10100 H       #
01011 J       '
01111 K       (
10010 L       )
10001 Z       "
11101 X       /
01110 C       :
11110 V       ;
11001 B       ?
01100 N       ,
11100 M       .
01000 CR      %
00010 LF
11011 Shift to figures  
11111 Shift to letters

And, indeed, the original VTL-2 for Altairs only used these characters + the
percent sign, while LVTL extends the range of variables to most lowercase 
letters (except xyz) and some special characters like @[\]^_`, as well as 
introduces three new bitwise operators - &, | and ^, two of which are not 
present in the ITA-2 set. Well, as the precedent of using * as both a system 
variable name and an operator was set by the original VTL-2, and & is also 
used both as a sysvar and as an "and" operator in LVTL already, nothing 
prevents us from aliasing | with ! for "or" and ^ with # for "xor". And this 
is what I also have done in LVTL-O as one of the improvements. As long as we 
only use all-capital letters and strings, we can write LVTL programs that 
still can be ITA-2-encoded and punched onto a 5-hole tape (provided we also 
have encoded % as something like FIGS + CR).

Now, where do we go from here? I'm planning to create a somewhat restricted
subset of LVTL: with only 26 uppercase letters and only ITA-2 characters + 
percent sign (so ! and # operators will be the only versions of | and ^), 
also without interactive input evaluation, and the ? sysvar in this version 
will only accept integers, like in VTL02sg. This restricted version also 
will have a reference implementation in C89 (based on the cut-down LVTL-O 
code, of course), but then I'll try porting it to some other runtimes. Which 
ones, is a story for another time.

--- Luxferre ---