Computer Lib/Dream Machines

Someone has finally uploaded a (possibly legal?) copy of to archive:

Read it from either end, there's two coherent books written back-on-back like an Ace Double, happily you don't have to turn your monitor upside down.

The first personal computer book (before the Altair came out!), though the PCC Newsletters predates it (and he mentions them). Fascinating time capsule, political tract about use of computers to control you (CYBERCRUD as he puts it).

Any nitwit can understand computers, and many do.
Unfortunately, due to ridiculous historical circumstances,
computers have been made a mystery to most of the world. And
this situation does not seem to be improving. You hear more
and more about computers, but to most people it's just one big
blur. The people who know about computers often seem unwilling
to explain things or answer your questions. Stereotyped
notions develop about computers operating in fixed ways--and
so confusion increases. The chasm between laymen and computer
people widens fast and dangerously.

This book is a measure of desperation, so serious and abysmal
is the public sense of confusion and ignorance. Anything with
buttons or lights can be palmed off on the layman as a
computer. There are so many different things, and their
differences are so important; yet to the lay public they are
lumped together as "computer stuff," indistinct and beyond
understanding or criticism. It's as if people couldn't tell
apart camera from exposure meter or tripod, or car from truck
or tollbooth. This book is therefore devoted to the premise
that

EVERYBODY SHOULD UNDERSTAND COMPUTERS.

Computers are simply a necessary and enjoyable part of life,
like food and books. Computers are not everything, they are
just an aspect of everything, and not to know this is computer
illiteracy, a silly and dangerous ignorance.

In many ways as relevant as ever. Just because you have a computer or "smart" phone, doesn't mean you know anything about its operation, purpose, and purposes you can put it to. Most people just use them as glorified TV sets and newspapers, mass media delivering people.

Unredacted 1st ed, includes some very… Ted Nelson is a white male born in the 1930s, his language about race and sex are, uh… not acceptable sometimes. Be aware.

Also, cover price $7 in 1974 is $37.61 in 2021, not $120, as Ted currently charges for a photocopy on his website. But at least he managed to publish this, unlike Xanadu which took 50 years to ship nothing.

I have a much longer draft of notes about it, that I'll probably finish up at some point. Now that I can just point you at the original, that gets easier.

BASIC at 57

We had a lingua franca, including the first 15 years of personal computing, that could be taught in a few hours and immediately used practically, and then it vanished almost utterly in the late '90s. Two generations are completely illiterate in the language of their ancestors.

Now, there's a couple of heirs to BASIC.

Python mostly took that role. For a while it looked like every computer would have a good version, but then between the Python 2/3 fiasco and hardening systems, you mostly get an old Python shipped on platform, and have to manually install from Python.org. IDLE (with my IdleStart shortcut ) is still a pretty great REPL, editor, and runner. import turtle as T; T.reset() and you can start doing turtle graphics in 10 seconds. The Raspberry Pi Beginner's Guide has a lot of Python as starting language (and Scratch, which is more a cruel joke than a language), which isn't great at graphics on a low-power computer but it is possible. The problem is it's considerably slower than a good BASIC, can't make use of multi-core, and relies on Tkinter for most graphics, which is even slower. Python's an evolutionary dead-end.

JavaScript is everywhere, and trivial to get started with… except you immediately run into a security wall, so you have to run a web server (easiest is, ironically, python3 -m http.server -b 0.0.0.0 8000 which serves all files in current directory). Edit file, reload browser page. And then doing anything in JS is a big hike up the mountain of JS, HTML, CSS. But it does run. Teaching everything you need to do interactive programs in it is hard bordering on a semester's coursework.

Scheme and LISP can be used this way, as seen in the Land of Lisp book, and Racket, but SBCL is a complex and terrible runtime for an ugly dialect of LISP (IMO, don't throw bombs at me), Racket has a broken REPL and their focus is on language experiments, not so much being useful. The other Schemes vary from hard engineering to even launch, to easy enough but poorly supported like my favorite Chez Scheme. I've been working on a "Beginner's Scheme" book for a while, and it's hard to compress what you need to know to get anything done, into small, fun parts.

It's actually easier to do Programming on Your Phone.

But there's still nice enough BASICs, in particular Chipmunk BASIC, and the old BASIC books & magazines work fine in it:

Just make a BASIC folder, download all those PDFs into it, and read them to see how quickly they go from "here's the BASIC commands" to "write a real program". And how you can make computing fun, not a chore.

I've been spending a little "non-productive" time hacking on my BASIC CRPG that'll run on the SpecNext when it arrives later this year… I do my work for now in Chipmunk; because NextBASIC has some strict limitations, I keep those limitations in my program, like single-letter array names. Graphics will have to be totally rewritten (but most of the UI is text-mode and portable), some data storage, too. Happily NextBASIC does have named functions (PROC, or SUB in Chipmunk), local variables, and loops (REPEAT:WHILE x:...:REPEAT UNTIL x, verbose but usable), so there's less GOTO and no GOSUB in my code.

I thought the line numbers and other limitations would kill me when I started doing it again, but in practice it hasn't bothered me much. I start each logical section at multiples of 10 or 100, add 1 per line, indent function and loop bodies, rarely have to renumber them. Since I don't GOTO/GOSUB much, finding them is less of a problem, only time I need specific line numbers is RESTORE xxx for DATA.

I'm starting to see BASIC as an interesting language again: Low-level enough to do something on simple machines, and reveal exactly how your algorithms work, high-level enough that you can get something done (much easier than ASM). You wouldn't want to build a large system in it, but focused problems, "tunnels through rock" as Chris Crawford wrote in De Re Atari, are well suited to it.

The original home computers having "turn on, maybe hit one key, you're in BASIC" interaction was amazing, unparalleled in any other system since, and we need to get back to as close to that as possible.

Nanorogue2 in BASIC

I've completed my BASIC 10-Liner contest entry, download on itch.io or find the latest version here:

Just shove the disk (.atr) in Atari800MacX or any other compatible Atari 800XL emulator, disable BASIC and hit reset, it should boot up into the launcher:

Where you can read docs or source:

And play the game!

So, the source for my first pass was manually-packed down, and I couldn't really fit everything I wanted in there, or switch to text-graphics mode. With some rethinking, and a better source editing tool, I could… So I wrote a filter program "Basic2List.py" that removes comments & blank lines, joins up everything after a numbered line with colons, lets me insert binary codes with \xFF escapes. It still looks a little dense, because I have to manually use abbreviated statement names or remove spaces, I'd like to make it smart enough about BASIC source to do that itself.

But it lets me turn source like:

5   POKE731,1       // noclick
    GR.1            // 20x20 wide chars, 40x4 regular
    SE.1,13,15      // palette 1 to gold
    W=20            // world size
    DIME$(27),M(W,W)    // E$() encounter table, M() map
    //RRRZZZD$$..........#######>
    E$="\xF2\xF2\xF2\xFA\xFA\xFA\xE4\x04\x04\xAE\xAE\xAE\xAE\xAE\xAE\xAE\xAE\xAE\xAE#######\x3E"
    H=10        // Hit Points
    L=1     // Level
    // G=0      // Gold, default value
    ?"NANOROGUE BY MDHUGHES"

into:

5 POKE731,1:GR.1:SE.1,13,15:W=20:DIME$(27),M(W,W):E$="RRRZZZD$$..........#######>":H=10:L=1:?"NANOROGUE BY MDHUGHES"

(except the RRR... are inverse & graphics chars)

See the Atari BASIC Quick Reference Guide to learn the abbreviations and some of Atari's peculiarities. And it's running in Turbo Basic XL which really helped the program size, so I was able to squeeze in stairs!

Last time I was using the compiler, and that worked but it distorted my sounds, and I couldn't make LAUNCHER.CTB run NANOROG2.CTB! So if I just left them all uncompiled (but tokenized) .BAS files it works fine.

The only down side is it's stuck in easy mode. I'd love to have a difficulty which increases the GP to Level Up, and makes monsters hit harder (but not reward more), but that didn't quite make the cut.

Generally I'm pretty pleased by this!

The ZX Spectrum (non-Next) port is turning out to be hard, it lacks a few things and doesn't have ELSE, either, so I don't know if it can be done.

10-Line BASIC Contest

Let's go back to the 1980s!

So I knocked down a tiny subset of my already tiny BASIC demo program, NANOROGUE, and plan to make 10-line versions for Atari 800 and ZX Spectrum. Getting it running on desktop in Chipmunk BASIC was trivial. Just a little ANSI for screen positioning.

Initially I just used standard Atari BASIC, and that worked fine, if very very tightly packed, and not fast… but the lack of an ELSE statement left me with an 11-line program, I wanted to end with 50 ... :GOTO 20:ELSE:GOTO 20:ENDIF but had to move it to a new line. Very frustrating. So I'm using an enhanced BASIC, which is allowed for the PUR-120 tier, for one command.

Being "compiled" (to bytecode, don't expect miracles) and making AUTORUN.SYS easier than my own utility is nice. TBXL is at least a 1985 tool; though at the time I was using the "official" BASIC XE cartridge instead, which had similar features, and mainly moving over to Action!, 6502 ASM, and C. But for retrocomputing it's fair game.

Making a TBXL executable & bootable disk is a little fussy.

  1. Make a blank floppy ATR (emulator disk format), format it, put Atari DOS 2.5 on it or whatever you like (from DOS 2.5, H to write DOS files). This is your program disk. Like TRON, everything you do will be encoded on it, and losing it will subject you to immediate deresolution.
  2. Turbo BASIC XL disk in D1, program disk in D2. Control menu, Disable BASIC, Cold Reset (Sh-F5). You should see a red load screen, then READY. Check you're in TBXL by typing DIR.
  3. Write your program. I recommend writing BASIC as LST files in a desktop editor, then Cmd-E "Edit an atr disk image", click "Atari/Mac Linefeed Translation", "Import Files From Mac". In BASIC, ENTER "D2:FOO.LST". RUN to test it. But if you like living the '80s lifestyle all the way (or using non-ASCII chars, which are annoying to work with), you can work entirely in TBXL.
  4. Save your program tokenized: SAVE "D2:FOO.BAS"
  5. BRUN "D1:COMPILER.COM", now swap D1 and D2 (Cmd-D, click the swap buttons; you want your program disk in D1!), hit 1, pick FOO.BAS, save as AUTORUN.CTB. Swap disks back (you want your program disk in D2!).
  6. Ctrl-D, J for Ja (yes) to go to DOS-XE. COPY D1:RUNTIME.COM D2:AUTORUN.SYS
  7. Now put your program disk in D1, reset, and it should come right up into your program, then prompt for Dos, Run, or Load when it ends. Nice!


So resuming work on NANOROG, I get:

The only down side is this tiny version has a very slow redraw, it renders the entire screen each move, instead of just fixing last/new positions. I'm pondering changing it to graphics 1 (wide text, 4 colors) and poking screen memory which is probably faster than printing. I made some acceptable bleeps and buzzes with SOUND commands; I'm a poor sound designer, but I get there with some trial and error.

Anyway, next week's task is the ZX Spectrum version. Speccy BASIC is pretty good, so I expect I can knock that out quick and without all these shenanigans.

Basic Games in Scheme

The first project I write in any new language is usually a guess-the-number game, a die roller, or an RPN calculator, then I start collecting those and other toys and utilities into a single "main menu" program, and use that to drive me to develop my libraries, play with different algorithms. Occasionally it's useful, mostly it's just a pile of stuff.

The Scheme version has a couple useful things. I was mostly thinking about old BASIC games, so it's "BasicSS" (SS being the Chez Scheme file extension, not anything more nautical or sinister).

I wrote a fairly malevolent wordsearch generator in the process of testing some file parsing, so here's one for 20 programming languages. I can tell you that B, C, C#, and D are not in my list. I'm doubtful that anyone can find all of them, or even half.

Hangman depends on /usr/share/dict/words, 235,886 lines on my system, which is very unfair:

 #______
 #     |
 #    ---
 # \ (o o) /
 #  \ --- /
 #   \ X /
 #    \X/
 #     X
 #     X
 #    / \
 #   /   \
 #
Word: TE---EN--
Guesses: E, T, A, O, I, N, B, R, S
YOU LOSE! You have been hung.
The word was TEMULENCY.

Seabattle ("you sunk my…") sucks, it just picks targets at random; teaching it some AI would help.

Hurkle, like all the early-'70s "find a monster on a grid" games, is awful, but the map display makes it a little easier to track your shots. "The Hurkle is a Happy Beast" by Theodore Sturgeon is one of his 10% good stories, but it provides only a little context.

Some of this I can release source for, some I probably shouldn't, so it's just a binary for now.

Computer Archaeology: Public Caves Discovered!

Exploring the archives of the People's Computer Company (a public timesharing computer center in the early '70s, yes before home computers), and many of the programs we're familiar with from David H. Ahl's Creative Computing come from here. 15 different variations on guess the number and guess a coordinate, sure, but also some really important things, many of them long forgotten.

Then I find this artifact:

pcaves

What the. This is basically a MUD†, from 1973!

Source code (uses a very long TREES library on previous pages).

Everyone knows WUMPUS, which is based on CAVES, but this is the rock star of these! How does everyone not have a copy of PCAVES? This is like finding a working Airwolf helicopter in a cave with ochre handprints on the walls. HOW THE FUCK did cavemen do that? Why don't we all have an Airwolf, if it existed 47 years ago?!

So anyway some barely-modernized version of this will be added to the MysticDungeon soon, you'll all be able to graffiti up a cave!

† more like a MUSH ("Multi-User Shared Hallucination") with one user at a time, specifically.

  • Note: You can play a version from the Narrascope conference 2019: PublicCavesNarrascope
  • Renga in Blue typed it in for the above event, and briefly reviews it as an adventure game. Which it's not, this is a social environment, literally a MUSH.

Programming on Your Phone

Pythonista lets you use your pocket UNIX workstation as a workstation. I use Pythonista, if not every day, very heavily on the days I use it. As always it's crippling of Apple that there's no upgrade pricing, so I can't give him more money every year that I keep using it. The new keyboard module is an interesting script launcher, but I already wrap a bunch of utilities in a main menu program.

There should really be more of these mobile programming environments. In the early days, Apple severely restricted you from shipping one; you could kind of cheat with JavaScript, and a few games snuck in some bytecode interpreters, but scripting was right out. They loosened up eventually, but are still dicks about you saving code anywhere it could be shared, so for example I have to keep my Pythonista stuff in iCloud, not DropBox where it'd make more sense.

  • Panic's Coda and Coda for iOS (née "Code Editor" WTF) is the only other one that's really functional; I've built real web sites out of it, but I mostly use it for ssh. Sweet baby Cthulhu, I hate Panic's crooked-text "designer" sites, I hit Reader view on those instantly. Designers shouldn't be allowed access to CSS or JS.
  • Hotpaw BASIC still works (as does his Chipmunk BASIC on the Mac), but hasn't been updated in 2 years. Not that I want to program in BASIC, but it's better than no programming at all.
  • The iPad used to have a very nice "BASIC!" (with a structured BASIC and a bunch of system functionality), and a very limited "iSkeme" (scheme interpreter, R5RS-ish? with nothing but text I/O), but they were killed in the 64-bit-pocalypse. Update 2020-09: miSoft Basic! has been updated. Searching for this is utterly impossible!
  • Workflow (née Apple Shortcuts) is great for putting a few tasks in a row but you'd go insane trying to write anything complex from drag-and-drop clicky boxes.
  • Apple's Swift Playgrounds on iPad is a tutorial, not really usable for applications AIUI.
  • There's a bunch of "kids learn to code!" apps that are mostly ripoffs charging $60/year to play robot tanks. Do not buy anything like this.

I dunno if the 'droids have anything comparable, I'm sure they can root their phone and try to use vi in a busybox shell, but that's not a reasonable work environment for a thumb-sized on-screen keyboard.

Programming the Atari 8-bit

My programming started in 1979 with the TRS-80 Model I, but in late 1981? early 1982?, I got my Atari 800, and later a 1200XL, then Atari ST. Those are what I consider "my computers".

Last few weeks for hobby time, I've taken up playing with an Atari 8-bit emulator, and may soon buy an old machine (130XE? I guess?) and a modern SD-card reader, and HDMI adapter unless I want to set up my old CRT… Yes, this is "pointless", but it's the most emotionally rewarding programming I've done in some time.

Had to do a lot of setup to get to this point, though. Follows are my excessive notes, which will hopefully be useful to others.

The keyboard mapping in AtariMacX is weird, I finally figured out:

Mac Key Atari Key
` Break
F2 Option
F3 Select
F4 Start
F5 Reset
Sh-F5 Cold Boot
Opt-F5 Insert Char (be REAL DAMN CAREFUL not to miss the Opt key!)
Sh-Opt-F5 Insert Line (same, DANGER WILL ROBINSON DANGER)
Home / Opt-F7 Clear
End Atari/Inverse
PgDn / Opt-F10 Help (XL/XE)
Opt-F1 F1 (1200XL)
Opt-F2 F2 (1200XL)
Opt-F3 F3 (1200XL)
Opt-F4 F4 (1200XL)
Capslock Cycle caps, may take several tries of caps A backspace repeat until you get lowercase, not graphics or uppercase.
Sh-Capslock Uppercase, almost always works

Typing on a real Atari keyboard is probably the #1 reason to get real hardware instead of emulation.

Immediately it comes rushing back, how much I didn't like the default environment of blue screen, clicky keyboard, inset margins. Easy to fix with a few pokes, but I don't want to do that every time I reboot, so I need a startup program.

  • First, configure Atari800MacX with the subdirectories next to it. It comes with all these folders in user space, but it's actually mapped to somewhere in /var, which is awful.
  • Make a boot disk. Media -> Disk Image Conversions -> XFD to ATR, pick the DOS25.XFD image in OSRoms, and call that boot.atr, store it in Disks, Load it in D1 Cmd-1 and pick boot.atr.
  • Reboot into DOS, by Control -> Disable BASIC. Bask in the glory of Atari DOS 2.5.
  • Make a data disk, Media -> New Floppy Image, I went with Medium Density (130K) since almost everything can read that, assign to Drive 2, and call that disk2.atr or whatever.
    • From Atari DOS, Format: I <return> D2: <return> Y <return>
    • Preferences -> Boot Media -> Set to Current Media, Save Configuration
  • My Atari BASIC project on Gitlab
    • Based on what I remember of my old main menu, I had a ton more stuff but I'm slowly adding routines as I need them. This can also be a shell for new programs, delete 11-9998 and use the subroutines. I wrote Draw to test joystick & function key scanning, not to be a good paint program, typed in a Music demo to make sure I had sound working.
      • Digression: This is not an efficient structure, because high line numbers take longer to find; an optimizing Poindexter would put the subroutines tightly packed at 1-999 and the program at 1000+, but it's massively easier to read & work with this way. I won't be in BASIC that much anyway, it's just for utility work.
    • Download AUTO.LST, convert Unix newlines (char 10) to the ATASCII newline (char 155 õ), and drop it in the HardDrive1 folder.
    • % LANG=C tr '\233' '\n' <AUTO.LST.TXT >AUTO.LST
    • Or you can just Media -> Edit an .ATR disk image, import file, and that has a newline conversion.
    • From BASIC, E."H1:AUTO.LST" <return> RUN <return>, pick Y. (Script AUTORUN.SYS), and enter:
      • ?"MAINMENU"
      • E."H1:AUTO.LST"
      • RUN
      • .
    • Change H1 to D1 if you saved it in your boot.atr.
    • Now it'll do that on every bootup from that floppy. Reboot to be sure it works.
    • If you make changes to your main menu, remember to LIST "H1:AUTO.LST". I use LIST/ENTER (text LST format) instead of SAVE/LOAD (tokenized BAS format) so I can read it from the Mac; BAS is slightly smaller and much faster to load/save, but it doesn't matter with emulation or an SD-card.

    • Atari-autorunsys

  • BASIC set up and tested, and it's a convenient place for little utilities, but now for real programming.

  • Atari Macro Assembler and Program Text Editor

    • Download this, read the fine manuals; more for MEDIT than the assembler unless you're really hardcore. I will probably do little or no assembly, even tho back in the '80s I could hand-assemble short programs directly into ATASCII codes to run from BASIC; bug-eating freak that I was.
    • Read the MEDIT manual. It's quite a respectable full-screen editor with command mode for search/replace, block editing, etc.
    • Open the Atari Macro Assembler and Program Text Editor.atx (ATX is write-protected or encrypted or something; you can't use them directly, and have to disable the SIO speedup hack in emulator) disk in drive 2 of your Atari (Cmd-2), Control -> Disable BASIC (which will reboot to DOS). So you want the program files off that:
      • DOS: C <return> D2:MEDIT,D1:MEDIT <return>
      • DOS: C <return> D2:MEDITCM.BAS,D1:MEDITCM.BAS <return>
      • DOS: C <return> D2:AMAC,D1:AMAC <return> (skip if you'll never write ASM)
      • DOS: C <return> D2:SYSTEXT,D1:SYSTEXT <return> (I think only needed for AMAC?)
      • Eject: Ctrl-Cmd-2
      • Reload your data disk, Cmd-1, disk2.atr.
    • Control -> Enable BASIC, LOAD "D1:MEDITCM.BAS" <return> RUN <return> and configure MEDIT however you like.
      • Language: PAS
      • Tabstops: Set at 5 and +4 after the existing ones, because 8-wide tabs are crazy in a 40-column screen. Yes, I'm a tabs not spaces guy, OBVIOUSLY.
      • Margins: 1,40
      • Colors: 12,4,14 (sadly can't be 0 or 2 background luminance, because the cursor is black)
      • Flags: Tabs: Expand, Shift-Lock: No (starts in lowercase).
      • Save & Return to DOS.
      • You can just copy the MEDITPAS.ECF to MEDITTXT.ECF, etc., you don't need to run the tool for each language, but it doesn't have a default mode. Note you also have to copy these to each disk you're editing on, or it switches back to the stupid defaults:
      • DOS: C <return> D1:*.ECF,D2: <return>
      • DOS: L <return> MEDIT <return>, filename D2:HELLO.PAS, and enter:
        program hello;
        var c: char;
        begin
          writeln('Hello, Atari!');
          read(c);
        end.
        
      • <option> exit <start> to save & exit. Note return doesn't execute commands in MEDIT, start does. Kids Today™ have some meme about how hard it is to exit vi? Ha ha, they have no idea. RTFM.

  • Finally ready to program in Action! or Pascal, which is what I mainly did back in the day.

    • Deep Blue C: Tragically underpowered version of Small-C. I loved it as an intro to C, but didn't use C for real until the Atari ST. It did produce standalone binaries and the compiler was easy to use, IIRC.
      UNSUPPORTED FEATURES
        Features in C not supported in DEEP BLUE C are:
        1) structures, unions
        2) multidimension arrays
        3) Floating point numbers
        4) Functions returning anything but int
        5) Unary operators: sizeof
        6) Binary operators: typecasting
      DIFFERENCES FROM STANDARD C
        THE DEEP BLUE C language has the  following nonstandard features:
        1. The last clause of a "switch" statement, either "case" or "default", must
      be terminated with a "break", a "continue" or a "return" statement.
        2. The ancient =<op> construct has been removed. Use <op>= instead.
        3. Characters are unsigned. Chars range in value from 0 to 255.
        4. Strings can not be continued on the next logical line.
        5. C source code lines can be a maximum of 79 characters long.
        6. Functions can have a maximum of 126 arguments.
      SPECIAL SYNTAX
        C uses several ASCII characters not available on the ATARI computer's
      keyboard. In particular the braces have been replaced by to two-letter
      combinations $( and $), and the tilde has been replaced by $-.  The $ character
      is not used in C, so your editor's find and replace command can be used to
      convert standard c programs into a format acceptable to DEEP BLUE C.
      
    • Action!: Custom language on cart for Atari, fantastic built-in editor (later the basis for the Paperclip word processor!), had a disk runtime system so you could distribute programs (also on AtariMania). But it came out a little later than my Pascal adventures, and it's a weird super-low-level language, and I think I'm in no mood to relearn it right now. Super goddamned fast, tho. May get into this if I'm frustrated later.

    • APX Pascal: Excessively complex process with a disk swap for every compile, compiles & links into PCode, no explanation of how to boot it. This is a very user-hostile compiler.
    • Kyan Pascal: Maze of command line tools. Doesn't work, at least for me, on emulation. It cycles through the tools, but never actually builds anything, eventually crashes and corrupts video. Makes a big deal of being usable from RAMDisk, but that doesn't matter on modern hardware.
    • Draper Pascal: Which I used in the '80s. Hilariously bad editor (but I can use MEDIT, so fuck that), compiler just fucking works, but only produces PCode (.PCD), so has to start from bootdisk or run Draper's menu then your program, ick. But this was no trouble to get running, so it wins.
      • Insert drpascal.atr in drive 1, reboot, boots into a menu.
      • 3 Compile program: D2:HELLO.PAS
      • 1 Run program: D2:HELLO
      • Total success! \o/ Hit any key to exit the program.
      • Drive 1, boot.atr, Drive 2, drpascal.atr, reboot
      • DOS: C <return> D2:AUTORUN.SYS,D1:PASCAL.COM <return>
      • DOS: C <return> D2:INIT.PCD,D1:INIT.PCD <return>
      • Cmd-2, disk2.atr
      • So now I can: DOS: L <return> PASCAL.COM <return>
      • And run Pascal programs. I could make a more focused runtime menu for it, maybe dir & list all the PCD files, the INIT.PAS source is included. If I ask it to compile, it prompts to insert drpascal.atr, and then I can switch back, which is reasonable.
      • Standard library is small but effective, seems like it has all the BASIC equivalent commands, and enough POKE/PEEK/ADDR stuff to let me do everything, including Player-Missile Graphics.
      • I can presumably now move all my source and disk2.atr contents to H1, so they can be managed & edited on the Mac, but I just wanted to get things running first.
      • Probably make another gitlab project (and actually sync it from git) when I get somewhere with that.

This took quite a lot of my hobby time doing something harder than actual work, to be honest. But I'm in a good place with it now.

Fall of Visual Basic, Rise of QuickBasic?

There was simply no other tool that a developer could use to sketch out a complete user interface and get coding as quickly as VB.

Except Smalltalk on the Xerox Star (1981), ResEdit on Classic Mac (1984), RCS and ORCS on Atari ST (1985), Hypercard (1986), Interface Builder on NeXTstep (1988), and others; Visual Basic came out in 1991, Delphi came out in 1995. Maybe there was no other tool on brain-damaged DOS/Windows systems before VB, I can buy that, but real computers were doing RAD a long time ago.

Alan Cooper, the "father" of Visual Basic, has done some really interesting work with interaction design and user experience, but he didn't invent RAD. VB started life as his project "Tripod", a shell creation tool, basically a user-customizable program launcher or "wizard". Then Microsoft bought it and turned it into "Visual Basic", as a kind of ugly Hypercard (is BASIC a worse language than HyperTalk? Eh.)

VB became famous for a legendary feature called edit-and-continue, which allowed developers to run their programs, find problems, fix them, and then keep going with the new code. This was a sharp difference from almost every other programming environment known to humanity, which force developers to recompile their work and start over after every change.

This is, of course, utterly wrong. Every language with a REPL can do this: You write some code in the REPL, run it, it crashes or produces wrong results, you change the one offending function and resume. All global objects are still present, no recompile necessary.


#;2> (define (hello name) (error 'hello "Unimplemented")) #;3> (define (greetings) (for-each hello '(Cthulhu YogSothoth ShubNiggurath))) #;4> (greetings) Error: (hello) Unimplemented #;4> (define (hello name) (printf "Ia ia, ~A fhtagn!\n" name)) #;5> (greetings) Ia ia, Cthulhu fhtagn! Ia ia, YogSothoth fhtagn! Ia ia, ShubNiggurath fhtagn!

The one difference is that to save state, you have to copy-paste out of .csi_history or whatever. IDLE lets you save off your session history directly, but you still have to edit it into a working script. VB did have the virtue of staying in the live editor, but you're still just coding behind buttons, you have no access to a history or REPL.

(This is why I dislike DrRacket so much: If you edit code, it does destroy your global REPL state! Why even have a fake-REPL there, man?! Command-line Racket doesn't have this problem, but it's still not a great Scheme.)

Just as VB acquired the same power as C#, C# picked up the same conveniences as Visual Basic. For example, .NET’s type safety and memory management features meant that C# developers never needed to worry about memory leaks, just like VB developers.
In other words, C# now had the guardrails to protect hobbyists, students, and new programmers without surrendering its power. All of a sudden, VB was no longer something special. It was just another tool in a capable programmer’s toolkit.

Every part of that is… well, not correct.

  1. My understanding is VB.NET was a mess interacting with .NET resources, so if you used it you were still stuck in the VB gulag or had to learn so much C# or C you might as well move up.
  2. C# is a hard language to start up in, you would never give it to a newbie and say "good luck!"; although that's what Unity does, and most Unity code is nightmarish as a result.
  3. C# is certainly not "never need to worry about memory leaks"; it's a Java ripoff with more native libraries, many of which have dangerous C++ based memory management, and in any case you can over-retain things and fill up memory very quickly.
  4. No capable programmer is going to say "this project is best in… Visual Basic dot Net!" Except on broadcast TV-for-morons.

The one good thing from all this:

An innovative project called QB64 has created a modern QuickBASIC replica. It runs on Windows, MacOS, and Linux, with no emulator required.

OK, this is interesting. Terrible domain name www.portal.qb64.org though, what is happening there? Just qb64.org redirects to that mess.

Once you run the setup_osx.command, it has a qb64 binary, which opens a DOS-like window with the old DOS qbasic.exe UI. Huh. This isn't bad, though the font is small and the only way to change it is with a custom font. It ships with a cyberbit.ttf font which is pretty but very W I D E.

Writing something and hitting Run|Start dumps an untitled binary in the main directory. Saving (to the programs folder in this package) and then hitting the Run|Output EXE to Source Folder toggle does something more reasonable: hello.bas, hello, hello_start.command. A trivial program is 1186K, which is excessive, but it does work, opens a terminal and shows some text.

There's a ton of sample code in program/samples, including a lot of 3D stuff.

This is a pretty credible BASIC environment.

Pro:

  • Structured BASIC, if you want it.
  • You can just recompile on every platform.

Con:

  • No interactive REPL (that was one of the few things classic line-oriented BASIC, or hybrids like ST BASIC, had going for them).
  • Slow compile.
  • Ugly editor, though probably playing with fonts and colors would improve this.

You'll always be better off just giving a newbie Python, but some people may have old code or nostalgia.

  • Chipmunk BASIC is certainly nicer as an interactive environment, but probably hundreds of times slower.

Tower of Babble

Programmers almost compulsively make new languages; within just a few years of there being computers, multiple competing languages appeared:

It proliferated from there into millions; probably half of all programmers with 10+ years of experience have written one or more.

I've written several, as scripting systems or toys. I really liked my Minimal script in Hephaestus 1.0, which was like BASIC+LISP, but implemented as it was in Java the performance was shitty and I had better options to replace it. My XML game schemas in GameScroll and Aiee! were half programmer humor, but very usable if you had a good XML editor. Multiple apps have shipped with my tiny lisp interpreter Aspic, despite the fruit company's ban on such things at the time. A Brainfuck/FORTH-like Stream, working-but-incomplete tbasic, and a couple PILOT variants (I think PILOT is hilariously on the border of "almost useful").

Almost every new language is invented as marketing bullshit based on a few Ur-languages:

  • C++: Swift
  • Java: Javascript (sorta), C#, Go
  • Awk: Perl, Python, PHP, Julia
  • C: Rust
  • Smalltalk: Objective-C
  • Prolog: Erlang, Elixir
  • ALGOL: C, Pascal, PL/1, Simula, Smalltalk, Java
  • LISP: Scheme, ML, Haskell, Clojure, Racket
  • BASIC: None, other than more dialects of BASIC.
  • FORTRAN: None in decades, but is the direct ancestor of ALGOL & BASIC.
  • COBOL: None in decades.

A few of these improve on their ancestors in some useful way, often performance is better, but most do nothing new; it's plausible that ALGOL 68 is a better language than any of its descendants, it just has mediocre compiler support these days.

Certainly I've made it clear I think Swift is a major regression, less capable, stable, fast, or even readable than C++, a feat I would've called impossible except as a practical joke a decade ago. When Marzipan comes out, I'll be able to rebuild all my 15 years of Objective-C code and it'll work on 2 platforms. The Swift 1.0 app I wrote and painfully ported to 2.0 is dead as a doornail, and current Swift apps will be uncompilable in 1-2 years; and be lost when Apple abandons Swift.

When I want to move my Scheme code to a new version or any other Scheme, it's pretty simple, I made only a handful of changes other than library importing from MIT Scheme to Chez to Chicken 4 to Chicken 5. When I tested it in Racket (which I won't be using) I had to make a handful of aliases. Probably even CLISP (which is the Swift of LISPs, except it fossilized in 1994) would be 20 or 30 aliases; their broken do iterator would be hard but the rest is just naming.

Javascript is a pernicious Herpes-virus-like infection of browsers and desktops, and nothing can ever kill it, so where it fits the problem, there's no reason not to use it. But there's a lot it doesn't do well.

I was leery of using FreePascal because it has a single implementation (technically Delphi still exists, but it's $X,000 per seat on Windows) and minimal libraries, and in fact when it broke on OS X Mojave, I was disappointed but I-told-you-so.

I'm not saying we should quit making new Brainfuck and LOLCODE things, I don't think it's possible for programmers to stop without radical brain surgery. But when you're evaluating a language for a real-world problem, try moving backwards until you find the oldest and most stable thing that works and will continue to work, not piling more crap into a rickety new framework.

The Biblical reference in the title amuses me, because we know now that it requires no malevolent genocidal war deity scared of us invading Heaven to magically confuse our languages and make us work at cross purposes; anyone who can write and think splinters their thought into a unique language and then argues about it.