jim_lawless

Agreed. I only recently found out about a book that Barden wrote (also a Sams book) that was published in 1977 called "How to Program Microcomputers". It explains the common workings of microprocessors and then goes over the makeup and instruction sets of the Z-80, 6502, and 6800. I wish I'd had that as a primer on assembly language and programming for microprocessors.

Z-80 was the processor for my introduction to programming in assembly language on a TRS-80 model I in early 1983. Bill Barden's assembly language books and Hardin Brothers' "The Next Step" column in 80 Micro magazine paved the way.

I wrote a quick post a while back about my Z-80 experiences here:

https://jimlawless.net/blog/posts/z-80/

I've stood up a message board to try to recapture the fun of running an 80's/90's BBS. You can look around at :

https://jims-bbs.com/bbs/

If you want to join in and post, you'll need a code for the registration process. The code ...

yc2026

...should work for a while.

I remember seeing the TRS-80's in The Life Aquatic with Steve Zissou but I didn't know that they were Model IV's.

According to this list, there was a TRS-80 Model III in the Star Wars TV series Andor:

Andor - Season 1, Episode 1, "Kassa" (2022)

It looks like MiniScript uses the keyword "end" followed by another keyword to denote the end of a specific type of block.

From the Quick Reference guide here:

https://miniscript.org/files/MiniScript-QuickRef.pdf

"Indentation doesn't matter (except for readability)."

You might want to check out the book "FoxTales : Behind the Scenes at Fox Software"

https://www.amazon.com/dp/B005KUH4GI

Related HN post "Ageless Linux- Software for humans of indeterminate age" :

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

My main page is

https://jimlawless.net/

It mainly serves as a page to hold contact info and some links to various specific parts of my sites ( blogs, podcast, ...etc. )

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.

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... )

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!"')

Nope. Not me.

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

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.

I like to write a lot of little programming interpreters and compilers that don't have a whole lot of purpose other than to experiment with a concept. One of these was a little language I called Triad ... an esoteric programming language that used three-letter identifiers because I could quickly treat them like a base-26 int and index an array of 17576 entries, avoiding having to use a hash table implementation.

You can see the C source code for a simple command interpreter that permits three-letter subroutine identifiers here.

https://github.com/jimlawless/triad

I have some other versions that had placeholders for built-in operations that would have made the language Turing-complete but I soon lost interest.

I also implemented a little BASIC interpreter that was only complete enough to write a BASIC program to display the lyrics for the 12 Days of Christmas song:

https://github.com/jimlawless/lazybasic

80 Micro was a wonderful magazine. Hardin Brothers' column "The Next Step" ... a Z-80 assembly language tutorial series ... was my favorite portion of the magazine.

At the time of the release of Turbo Pascal 3.x, the IDE's on the CP/M version and MS-DOS version were almost identical. I suspect that the author was using TP 4.x or later on MS-DOS.

Turbo Pascal on CP/M was a sweet spot among the development tools of the day. As the author describes, the IDE was very pleasant to use, compile-times were speedy, the generated code was compact, and the language implementation permitted a nice mix of high-level constructs with low-level access.

A set of Python PIL scripts for generating background / wallpaper montages. One of the output montages is here :

https://jimlawless.net/magsbooks.jpg

A Perl script that formats a bbcode-like markup to HTML for some of my web pages.

A mostly-Powershell script that stops all Windows features and apps that I don't want running. Some features/apps start up again after Windows updates, so this shuts them back down.

Some SMTP/POP3 scripts that I use in various languages to automate email management.

An ffmpeg script that converts an MP3 coupled with a static image to an MP4 so that I can upload podcasts to YouTube. I did provide this on a Twitter/X post once, so maybe it's not something I've kept to myself very well.

Some ffmpeg scripts to convert M4A audio file to MP3.

I have a web page that just displays the current time every second that I use when timing things. It's all very simple client-side JS.

...and others.

I'd read a story a while back about a phone company employee who serviced payphones. He would periodically shut off power to payphones on his route, causing them to trap whatever coins the callers would insert. He'd return at a later time, turning the power back on. The coin return would then empty and he'd get the coins.

"x64 Assembly Language Step-by-Step: Programming with Linux" (4th edition) by Jeff Duntemann is a pretty good book.

DEBUG was also able to read/write disk blocks and it could load / save files from memory based on register settings. I had written a batch file and a file of DEBUG commands ( redirected into DEBUG ) that would load the blocks from 1.44M diskettes at about 64K at a time, save each just-under-64k segment with a separate filename, and then zip up the whole collection. I also had written the counterpart scripts to decompress and block-write the data back out to a 1.44M floppy. This allowed us to archive the .zip collections as disk images for some critical boot disks and such.

I had also written a utility in C published in Windows/DOS Developer's Journal (April 1995) before some email clients could UUDECODE or Base64-decode attachments. This utility wrote a short loader as a text file followed by the G command to execute it. Following the G command were lines of UUENCODED data. The assembly language loader code would begin reading lines from the standard input device and would UUDECODE them as it added them into DEBUG's current working buffer starting at 100h. At the tail end of the script, the N command was used to name the output file, the CX register was updated via RCX to set the output length, and the W command was used to save the file. This allowed me to send some encoded binary files embedded in the body of the email to folks that didn't have sophisticated email clients. They could just pipe this portion of the email into DEBUG and it would ultimately write the decoded binary file.

We had a pretty active CP/M community in the 80's when the C128 was released. Most of the time I spent in CP/M mode was either running Turbo Pascal or MEX ( the Modem EXecutive ... a telecommunications program. ) We had some CP/M bulletin board systems in the area with downloadable software and source code. This was where I first used archivers such as Gary Novosielski's LU / Library Utilty ... which was kind of like tar. It stored archives in files ending in the extension ".LBR". Versions of ARC were also used at the time. There were stand-alone versions of LZW and Huffman compressors ( Crunch and Squeeze, respectively ) which were often used in conjunction with LU in the same manner that gzip is often used with tar archives.

The posted article mentions how slow C128 CP/M when compared to comparable machines, but I really didn't notice. It ran quickly enough for my needs.

I was particularly fond of his ATLAST Forth-like programming language.

https://www.fourmilab.ch/atlast/

Rest in peace.

On the server side, I remember it being challenging trying to figure out how to run CGI's ... usually in Perl ... on a given site. Some sites had Perl 4, some had Perl 5. Your code might have needed either the .pl or .cgi file extension. Sometimes the CGI script just needed to be in the /cgi-bin/ directory with execute permissions set and the appropriate hashbang in the top comment.

While there were more elaborate Perl CGI libraries, I preferred to use cgi-lib.pl.

mIRC, a windows .HLP authoring tool, an animated GIF HTML button generator, a graphics DLL for Windows. I think I might've licensed a QWK Mail reader for BBS use as well.

I also sold a few shareware apps in the late 90's and early 2000's. Mostly command-line email and/or command-line something-or-other utilities.