I saw a post about the SKOAR language here on HN in late 2015:

https://news.ycombinator.com/item?id=10180423

In the comments, I saw reference to MML ( Music Macro Language ... not exactly what I think the MML is on the list. ) Here's the one referenced in the HN post.

https://en.wikipedia.org/wiki/Music_Macro_Language

At the time, I built a small interpreter that included MML as an embedded language, but I don't think I have the (Windows) binaries handy.

I interviewed Rob Sherman the gent behind Southernamis and other Atari BBS's on my podcast a few months ago. He's running emulated Atari 8-bit systems in AWS for these BBS's. Rob also has written some articles on telnet-access retro BBS's in the newly revived Compute's Gazette magazine.

Visiting BBS's that run on actual or emulated hardware can be a nice trip down memory lane for those who were part of the 8-bit BBS community in times past.

I asked ChatGPT to write a Windows GUI C program that looks for a running instance of the onedrive EXE at regular intervals and terminates it while keeping a running log of the attempts in a scrolling window. It took a few iterations to get what I wanted and it was simple to compile with GCC.

You can use a Powershell to see if onedrive.exe is running and kill it with the -force option to do something similar ( ps * onedrive * | kill -force ) with no spaces between the asterisks and the word onedrive, but that turned out to be a little heavier to have running continuously than I wanted.

If you use a process like this, you absolutely need to run it at intervals because the onedrive exe seems to execute at regular intervals.

Hopefully everyone uses an Enterprise SKU of Windows so you can just control it with Group Policy.

On Enterprise, you can use its built-in App Locker features to block the execution of any Windows component. I've used it to block Windows Update completely at home after it filled my drive to the last byte and I was sick of my gaming box disobeying.

This will wreck havoc on your battery life, consider instead replacing onedrive.exe with a dummy executable and then using NTFS ACLs to deny "TrustedInstaller" permission to modify it

Why not just uninstall it via powershell scripts like those available from privacy.sexy?

I gutted OneDrive so hard it will likely never come back.

I have a handful of sites that I visit frequently. I wrote a script called "to" that has an embedded list of these sites' URL's along with some metadata that includes the preferred browser client and a short mnemonic name for the site. When I issue a command like:

to hn

The script will open the site https://news.ycombinator.com with Chrome. I also have a help screen that lists the URL's and their mnemonics. Again, note that this is a very short list.

I like working at a command-line so it's often faster for me to run something like this instead of typing the first few characters of a site name into a browser and waiting for the URL autocomplete to finish the URL for me.

You could do similar things on a C64 and other computers. You might try this out on a C64 emulator such as VICE.

10 REM NOTHING TO SEE HERE

20 PRINT "HELLO!"

POKE 2049,1

Run it. You'll see HELLO! LIST it and you'll continuously see line 10. If you try to LIST 20 the machine pretty much locks up.

Screen image is here:

https://jimlawless.net/images/remtrick.gif

(note that in the above image, you'll see two RUN lines ... it appears that I captured the screen as it was in mid-scroll... )

At least on the C64, you could also put a line containing REM shift-L in the program, and the LIST command would crash out when encountering it.

The problem being that the LIST routine should handle a comment like a string (which is how it is parsed and stored: a comment is essentially an unquoted string extending to the end of the line), but doesn't bail out of keyword expansion, whenever it encounters a REM token.

[Edit]

Coincidentally, a shifted "L" is PETSCII code 0xCC. Which is just one after the highest available token in Commodore BASIC 2.0 / V.2. (The last one being 0xCB, `GO`.) Therefor, a lookup into the keyword list will yield the terminating zero-byte, which probably causes the problem. (E.g., by defeating what was intended to be an unconditional branch instruction.)

(In BASIC 4.0 for the 40xx/80xx PETs, this is actually a valid token, namely `CONCAT`, which is expanded by LIST without further issues. Meaning, this kind of LIST protection can be broken by simply loading the program on one of the later PETs.)

That's why I said "at least on the C64". This particular bug probably also happens on the VIC-20, but I don't know if PET BASIC 2.0 is the same or not. I'd also imagine the "protection" would break if loaded on BASIC 7 or 10 (although 10 was never finished, but it was based on BASIC 7 AFAIK, so there's that).

It also happens on the PET, before BASIC 4.0.

I had a cursory look at it: there's no check for REM, of any kind, but there's, of course, a check for quoted strings. For any tokens, an offset count is calculated by subtracting 0x7F from the token and then a loop starts searching for set sign-bits in the keyword list, decrementing the counter each time, it finds one. If the counter is zero, we must be right at the keyword, we're looking for. – But in those cases, where we are not…

For values larger than 0xCC (shift-L), the routine actually wraps around. E.g, shift-M is listed as FOR (0x81), shift-N as NEXT (0x82), and so on. This is, because the keyword list is exactly 256 bytes long (including GO and the terminating zero-byte, like on the C64) and is inspected by an indexed load instruction. So the index register just wraps around.

(BASIC 4.0, on the other hand, has to deal with a longer keyword list anyway, so it uses a more complex method to read the list, involving a pointer. Thus it happily spills over into the list of error messages, which follows immediately after this and happens to be encoded in the same way. Therefor, it will expand any excess-tokens into error messages. I guess, this will be the same with BASIC 7, and so on, if they are anything like this.)

Small update: I did a write-up on LIST and its mishaps (covering the PET to the C64 – so, no BASIC 7, etc.)

https://www.masswerk.at/nowgobang/2025/the-remarkable-misadv...

There was a pretty detailed article in the May 1985 Radio Electronics that mentioned interfacing it to a VIC-20:

https://archive.org/details/radio_electronics_1985-05/page/n...

Transactor Magazine volume 7, issue 4 (1987 ) had an article on interfacing it to a C64:

https://archive.org/details/transactor-magazines-v7-i04/mode...

A TCL interpreter is packaged with Python in the tkinter library:

import tkinter

tcl=tkinter.Tcl()

tcl.eval('puts "Hello, world!"')

I'm aware, but that kind of defeats the point (at least to me). If I want to build out some cute DSL for a project, it would just be with the small tcl interpreter.

This reminds me of home computing in the late 70's when we used to keep our "database" info in DATA statements embedded in a given BASIC program.

https://jimlawless.net/images/basic_data.png

Glad I'm not the only lunatic who would do something like this. At least until I got my paws on dBASE.

I worked with somebody with your name in the early 90s on a Sequent/Dynix system, that wasn't you by chance was it?

Nope. Not me.

In the early 1990's, I purchased a "Telepath" modem from a company then known as Gateway 2000 along with a computer and other gear. Qmodem for DOS was included with the Telepath.

I had used a number of different terminal programs on a handful of machines of the era, but I never found one as robust and as easy to use as Qmodem. I used Qmodem for several years. I quit using it when the local BBS scene wilted away.

Thank you for your father's contributions to communications tech and BBSing. My condolences to you and your family.

Forth has a default syntax, but Forth code can execute during the compilation process allowing it to accept/compile custom syntaxes.