hckrnws
Oh my, this is so amazing. I can't wipe the grin off my face. I never thought I was would see Hammurabi (https://github.com/maurymarkowitz/101-BASIC-Computer-Games/b...) again!
With this I can pinpoint the exact first bug I created, and debugged. The year was 1991 +/- 1, the place was Canberra Australia. For unknown reasons that changed my life forever, my Dad got on board with this "computer" thing and bought an "Osborne" 486 PC. That year I went to the school fete and, for AUD 0.20, picked up a used copy of this book, leafed through the pages, settled on Hammurabi, and after some struggle and discussions with friends, managed to run Q-Basic and typed this program into it. And it sort of worked, but something was wrong, and after much experimentation I found that on line 11 (only today, with this post can, I finally state the true line number) I had written "LET P=P+1" instead of the correct "LET P=P+I". After a fair bit (days) of trial and error and 10-year-old reasoning, I figured that out, and so it began.
They built a Route 93 bypass around Manchester, NH and a new mall in 1980, not long after that I bought a copy of "101 BASIC Computer Games" from the Digital [1] Store there (really!) This was the minicomputer edition that David Ahl had published when he worked at DEC, not the microcomputer edition that he produced at Creative Computing magazine.
I was typing those programs into a TRS-80 Color Computer which had a very good implementation of Microsoft BASIC enhanced with commands to draw lines, circles and flood fills on a high resolution screen. The text mode only had 32 characters across, but you could get most programs to work on it.
That generation of games was intended to be run on a teleprinter so they did not use any graphics other than drawing scenes with ASCII characters and didn't use any commands to write text at specific places on the screen. Later in the 1980s you saw books with more complex BASIC games that implemented shooters and Pac-Man clones and such but all of those were specific to a particular computer whereas Ahl's games were portable even though you'd often have to modify the programs a little to get them to work.
By 1991 though I was done with BASIC. I had a ROM cartridge with an assembler by 1982 or so but I was still writing a lot of BASIC. Circa 1985 I was doing a lot with the OS-9 operating system which had a C compiler and BASIC09 which was particularly advanced, I remember writing a FORTH in 6809 assembly. Circa 1987 I had a 286 PC which had a wide range of programming languages including various BASICs, but Turbo Pascal was my favorite, though I switched to C in college (where I was in '91) because C was portable to the 32-bit workstations they had.
[1] https://en.wikipedia.org/wiki/Digital_Equipment_Corporation
I had a similar early learning experience. Grew up on BASIC, LOGO, a bit of 8086 assembly, Turbo Pascal, C.
Pretty sure these first few languages affected or shaped my childhood mental development somehow, for better or worse, and how I think about and express programs. Especially with BASIC, I was so young I was still learning how to think and talk in a human language, along with how to think with and talk to a computer.
A compatible Quick Basic system is available https://en.wikipedia.org/wiki/QB64
If you are craving a BASIC fix, I highly recommend getting a DOS emulator like DosBos-X and just installing a copy of Quickbasic 4.5 (which has a compiler among other niceties over the original Microsoft QBASIC). You can easily find it on the Internet Archive.
There are modern variants like QB64, but personally I find that BASIC really loses a lot of its appeal/flavor when you move from an interpretative language to a compiled one.
I made this a while ago and it ran beautifully in DosBox on my Mac:
I prefer GW-BASIC 1.0, as open sourced by Microsoft a few years ago, but with some changes to make it possible to build it easily yourself:
https://gitlab.com/tkchia/GW-BASIC
Also do a pip3 install pcbasic to get this great reimplementation of BASICA/GW-BASIC done in python for modern systems: http://robhagemans.github.io/pcbasic/
Thanks for the pointer to pcbasic! I experienced nostalgia from doing
play "cdefgab>c<bagfedc"
Or this which is lighter:
> Quickbasic 4.5 (which has a compiler among other niceties over the original Microsoft QBASIC)
QuickBasic was the original, with QBASIC being a cut down version of it bundled with DOS.
If anyone is interested, I just wrote a TinyBasic implementation:
I was afraid 'dbi' would clash with a binary on my machine (related to DBI), but it's fine.
BTW, on Basic, I had MISSION.BAS for MBASIC.COM under CP/M.
Is there any public Basic to run it? I tried bas, blassic, bwbasic, yours, and I had no luck.
Sorry, but I'm not sure which dialect of BASIC this is - wish I could be more helpful here. TinyBASIC is a very minimal implementation (no arrays, functions, nor loops) so it definitely won't be able to run this program.
Thank you for the dosbox-x suggestion. I am running Ubuntu on a newer laptop and did not have any luck getting Age of Empires to work in a virtual machine because of issues with DirectX on modern hardware. The game would render so slowly as to be unplayable.
I installed dosbox-x out of curiosity, then saw you could load Windows 9x on top of it. I chose the recommended Win98SE. It took a bit of tweaking to get the drivers loaded for 256 color display and the sound card, but I was just able to play the game. Because DosBox emulates the machine (I think this is it, anyway.), there are no issues with DirectX rendering. I was able to play through the Ascent of Egypt learning campaign for the first time since 2009 or so.
Maybe next I'll try to loading up a version of BASIC. I'd have to rewind back to 2000 or so for using Visual Basic in high school computer lab.
Thanks again, getting to play AoE without having to buy an XP-era laptop, was a real treat.
Nice! I think my favorite part of the original age of empires was the weird Latin sounding simlish of the voices (Pleribus!)
It'll be interesting if you can get the original VB to run. Fun fact there was actually a visual basic for dos which would let you build TUIs out of extended ASCII.
I saw that and was quite pleased with the idea of it all working nicely in say,80x50 text mode, that I proceeded to write a similar set of subroutines.
I ended up with a pretty nice subset.
Could draw a window with fields, pop a number of them up on top of that window, if desired.
Used that to write a small pile of DOS programs which computed various manufacturing related values used in sheet metal work.
There is no reason to lose anything, hence why many BASIC still do support both ways of working.
I bet many are unaware of many dynamism is still present in VB.NET, pity BASIC is no longer a darling language at Microsoft headquarters, and gets the bench on Sunday games.
I was craving a BasicA fix, so rather than run the ROM extractor on an IBM, I found the extraction program with them extracted. No 43-line mode like qbasic... :(.
Or FreeBASIC (it has QB compatibility mode). Works fine on Windows/Linux/DOS. No macOS port, unfortunately.
It's so entertaining to just pour through the source for each game and read the language used at the time, like in the game instructions or result responses.
There's something refreshing about seeing things described in different ways than they are now. I always wonder if some long forgotten words of phrasings will make their way back into public consciousness.
Psst… if you like this, you’ll love the 10LINEBASIC competition - the sources for these entries is truly a delightful resource to behold:
I'm greatly inspired by the kind of utopian visions of computing that seemed to be common from the BASIC era to the PC era to the pre-Facebook Internet era.
I'm somewhat disenchanted with commercial computing from the social media and smartphone era to the modern AI era, even though it is impressive and technically interesting.
If you want a taste of this nostalgia in the modern age, check out the 10LINEBASIC coding competition, which recently concluded with this years entries featuring some truly astonishing games in just 10 lines of BASIC:
One of my favorite machines of the BASIC era - the Oric-1/Atmos - won the competition multiple times in the last few years (though didn’t this year), and I really enjoy going through these games and observing just how rich a few lines of BASIC code could truly be.
In this years list of entries, there’s a Pac-Man clone consisting of a single corridor, which is surprisingly fun, a re-interpretation of the Space Invaders gameplay mechanics which, in hindsight just seems so obvious yet so delightfully simple, a full-blown real-time strategy game, and countless arcade-style minigames .. all implemented in just 10 lines of BASIC!
As a longtime follower of this competition, I really enjoy the nostalgia factor, and as its a multi-platform activity, its also really fun to learn the quirks and features of different systems BASIC implementations, as well. (Of course, I have a lot of these machines in my retro collection too, so this gives me a yearly scheduled reason to dust some of them off and give them a try)
If you haven’t heard of this, yet yearn to know more about BASIC, definitely check it out! The scene has been getting cooler and more diverse as the years go by, and it has to be said that the competition gets more and more effective as the years go by. The beauty and aesthetics of the 10 lines of code that give us a Pac-Man clone really imbues a sense of zen mastery .. and then there is the realization that, if this is what can be done in 10 lines only, imagine if the rest of the computers memory was then used as effectively.
Plus, there is just no way modern platforms can attain this level of programming efficiency and style. It’s really telling that BASIC, a much overlooked language, still contains so much fundamental power, unmatched in the modern era.
Here’s the link, one more time - BASIC fans, get yourselves ready for a real treat:
(Disclaimer: I was invited to judge this years entries, so yeah .. I’m a bit of a BASIC10LINER pimp. I had so much fun with this in the last few weeks!)
I don’t see gorillas.bas — that was my favorite. I actually found my appreciation for writing code modifying lines of code in that game to make bigger explosions.
nibbles was my favorite. Reading the code as a 13 year old I learned that they doubled y resolution by using lower and upper square ascii characters. It inspired me to find creative solutions for problems.
I had fun changing the barrier wall sizes in nibbles to make some levels easier. Having the source accessible and easy to change was quite useful.
I would love to know how DECs BASIC-PLUS worked.
The key thing about B+ is that it's a compiled BASIC, it compiled into P-Code, that was then executed. This is in contrast to MS-BASIC which interpreted the parsed token stream over and over.
But, there is no way that the entire thing was compiled each time you said "RUN", that would have been much to expensive. But, it was compiled. At the same time, it kept the entirety of the BASIC program in memory, as text. So, it had to store both the raw text form, and the compiled form. Seems quite expensive given the limits of machines back in the day.
So, I've always been interested in the design and engineering history of B+.
Similarly, I'd love to know where Gates and Allen got the idea to use a tokenized form to store the program, as its an elegant solution in a tight memory budget to store the program source and runtime.
They're clever guys, and maybe they made it up out of whole cloth, but it would be interesting to know what may have inspired them to do it that way. It wasn't BASIC-PLUS, as that's not how it worked.
Probably similarly to Dartmouth BASIC, which seems to have invoked the compiler when the user entered RUN.
I remember variants on this for several platforms by the authors:
Don Inman, Ramon Zamora, Bob Albrecht.
TRS-80: https://www.amazon.com/Advanced-TRS-80-Level-II-BASIC/dp/047...
TI-99/4a: https://www.amazon.com/Introduction-TI-BASIC-TI-99-4A/dp/081...
Visual basic for dos: https://www.amazon.com/Visual-MS-DOS-Prentice-Innovative-Tec...
VIC-20: https://www.amazon.com/Vic-BASIC-User-Friendly-Guide/dp/0835...
Here is the full TRS-80 text: https://archive.org/details/trs-80-level-ii-basic-a-self-tea...
Who were these guys? They were all over the map.
The self-teaching guide is impressive. The programmed instruction format is a great way to learn, and it works both in print and online. I wish there were entire curricula available this way.
Edit: It seems that Wiley has published a number of books in the self-teaching guide series:
https://www.amazon.com/Wiley-Self-Teaching-Guides-17-book-se...
Many happy memories of checking out books like this from my public library and trying to get the programs working on the C64. The BASIC dialect never matched exactly.
Similar for me in my early teens. I used an Australian machine called the Microbee, https://www.microbeetechnology.com.au/classic-plus-kit-compu...
A clever friend of mine wrote BASIC games that he sold back then. I think they had a bit of Z80 assembler built into it too.... Can't remember what names of them were though.
The 'hires' graphics mode (511*255, monochrome) were encoded into sprites. There were only 128 characters from memory. There were all sorts of tricks to try and get around that issue.
The best games used the sprites plonked into char positions.
The ‘bee was how a lot of us Australians of a certain age got into computers. The only real competition it had was the C64 as other things like the Apple II and IBM compatibles were just too expensive in comparison to that $399 intro price.
It was a bit weird to program for, as you said the basic was not quite the same as the popular platforms. It did mean you learned a lot about the machine itself, how memory was laid out, how to get those PCG graphics right.
It’s funny now to be able to see very similar cultures sprang up around less successful machines in other countries.
Me too, except with the CPC. After going through enough of them, I got to a point I could flick through the book in the library and figure out what was going to work ahead of time, what could be adapted and what went way beyond my abilities (usually anything that shoveled machine code into DATA blocks). It was neat imagining the incredible capabilities of computers other than my own and then trying to figure out a way to make mine do something like it too.
I also remember these books if anyone else was fond of them: https://en.wikipedia.org/wiki/Micro_Adventure
I have a few books from the Micro Adventures series and they can still be found on eBay for around $5 - $10 USD each, I think. Fun times, indeed!
I loved Amiga Basic. My first taste of programming without line numbers.
Amiga Basic still seems to me like the pinnacle of the basic language. Line numbers were optional, structured programming with loops and true functions, a graphics library... but still firmly BASIC. Not bits of code embedded in a UX editor, not some compiler-based C wannabee...
Having come from an 8-bit micro with ROM BASIC to the Amiga 1000 in 1985, I too was excited when I read about AmigaBASIC. It really seemed next gen. Unfortunately, once I started actually trying to do interesting things with it, I found it was surprisingly slow compared my 8-bit micro's ROM BASIC.
Of course even though the 8-bit was only running at ~1Mhz compared to the Amiga's ~7Mhz, the 8-bit's ROM BASIC was written in hand-coded assembler (and by some really good programmers, including BillG himself (in the case of the Radio Shack Color Computer I used)). I think AmigaBASIC must have been written in C and designed with portability in mind.
Dartmouth BASIC was designed as compiled on the fly language, no interpreter.
As for C wannabe, BASIC got famous before C had any meaningful meaning outside Bell Labs.
I think "C wannabe" is a complaint about some modern BASICs trying to be too much like C.
Dartmouth BASIC and timesharing were remarkable achievements: a simplified version of Fortran that could be learned in an afternoon but could be used for a wide variety of programs, including games; a fast, interactive compiler; and efficient resource usage and multiplexing that enabled a single machine to be shared by dozens (?) of interactive users. BASIC was also simple enough that it could be implemented compactly and efficiently on 8-bit microcomputers, while retaining its ease of learning for beginners and non-experts. And you could still write/run games with it.
And could be used as systems programming language on 8 and 16 bit home computers, long before C got famous outside UNIX, while being safer at it.
So there is nothing like wanting to be like C, when its mainstream adoption predates C.
Actually I am quite thankful to have learnt systems programming on 8 and 16 bit systems, with BASIC and Pascal variations, macro Assemblers, exactly long before C's mainstream adoption, because I am not tainted with the idea before C there was nothing else, as it eventually became a common myth.
I still see Forth far more advanced than Basic and C+Unix it's a bit meh. Being orthogonal with pipes it's cool, but Forth did that better since day 1 and without even a wordlist.
On Pascal, good for DOS, and maybe the Classic Mac, but even under Unix there were really good underused platforms, like TCL/Tk +SQLite. More crude than VB, for sure; but, seriously, most of the time a quick tool in that language would cover the 90% of the needs of any corporation.
I was in primary school when I heard about AmigaBasic. I was incredibly excited by it, I told my friend it would make it possible for us to build anything, for example we could build an ice hockey game. I hated ice hockey. I was just so excited that building anything at all with it seemed amazing.
But it turned out it was basically unusable on a TV because of the narrow cursor and difficult to read font. But AMOS was great, and we built a simple one-room adventure game prototype on it.
AmigaBASIC is still going, in some form.
There's Cursor[0], a compiler with an editor from 1994, unfortunately proprietary and not further developed. Maybe someone could get a hold of the author to try and get them to open the source code for preservation and potential further development.
There's also aqb[1], a reboot, MIT license.
And a very nice alternative in AmigaOS, Blitzbasic, got its source code opened and forked, with renewed development for AmigaOS as AmiBlitz3[2], as well as ports to other platforms.
0. https://aminet.net/package/dev/basic/Cursor
Thanks for the links!
Anyone recommend a good, ideally free QBASIC-like for modern Windows? Want native Windows, no DOSBox or similar.
My little brother (60+yr old) wants to get back into programming after many years of business analysis, project management, yada yada, but he was originally a programmer. I suggested Python, but I think he might be happier with BASIC. He's retired now, so doesn't need/want to do it for a job.
I have found that antirez’ LOAD81 can be a rejuvenating and invigorating environment to give to kids and the elderly, alike, to inspire them to rekindle their love of programming:
https://github.com/antirez/LOAD81
It has all the bells and whistles of a BASIC environment - easy, simple editing, fast switching between code and runtime, and just enough of an onboard SDK to do hires graphics and so on .. but with the Lua language, instead of BASIC.
Maybe your little brother will get a kick out of this .. keep an eye for some of the forks of it too, which provide other functionality such as joystick and sound support .. sooner or later, someone will bolt on networking and maybe even REDIS support, and we’ll have a whole new era of simple Lua-based client programming on our doorstep.
Freebasic or QB64 would be good places to look. There's also VB equivalents like gambas or xojo.
Coding Horror has set out to modernize many of these original BASIC games in modern programming languages. It has been going on for a few years now.
https://github.com/coding-horror/basic-computer-games
anyone can contribute and issue a pull request for the targeted language
Oh wow this is a trip down memory lane. My parents bought me a computer advertised in the classified ad as “includes over 100 games” and that really meant it came with a book over 100+ games in basic. I’d stay up copying the book to play the games in it. Fun times.
Comment was deleted :(
Would be better if the programs were JPGs that you had to type in
Knock yourself out: https://archive.org/details/101basiccomputer0000davi/mode/2u...
MS Office OCR works great for this, it did the Rogue.c jpegs in no time, but there are missing routines. I wonder if an AI could fill the gap.
A listing made on a dot matrix printer that contain PETSCII graphic characters might make it struggle. It'd be interesting to see if the LLM could infer the intended character.
I ment fixing the missing code blocks, of would suppose that an LLM could fix the mangled code without OCR training...
This exact book is how I learned to program, back in the late ‘70’s. Lots of good memories.
I picked up my copy of the microcomputer version at a neighborhood rummage sale in a park as a young kid. It's one of the earliest things from my childhood that I still have. Good times.
Walter Bright said here that he learned programming from this book.
This is the book on how to write practical games. If DEC had not shafted Ahl, I would have been on real DEC instead of an HP.
DEC could have ruled the world.
> DEC could have ruled the world
No way.
DEC's entire corporate structure was based on a particular business model that demanded their products sell for tens of thousands to hundreds of thousands per sale.
They tried many times to break out of this box, but failed every time. There was simply too much of the company invested in selling into a particular size of customer, and its weight meant that they could not survive, for instance, selling individual small computers to end users.
You can see this right to the end: even when they came out with Alpha it was targeted 100% to what was then the high-end of the new server-based market. Sure they made workstations, but only grudgingly, and with the hope that it would be part of a network containing at least one of their higher-end servers.
>DEC's entire corporate structure was based on a particular business model that demanded their products sell for tens of thousands to hundreds of thousands per sale.
Is this why the VT180 never got anywhere? (Didn't DEC only sell it to employees, or something like that?)
In retrospect it's mindboggling to think that DEC never marketed the upgrade kit to the massive existing VT100 installed base as an easy way to move into personal computers for less money. DEC had name recognition in corporate America in a way that Apple and Commodore did not, let alone the likes of North Star, Morrow, or Cromemco.
Nah, this was the book on how to write programs in the dominant end-user language of the day. Few of the games are all that memorable, really; the coolness lay in making the computer do things, in building something that was interactive. The book appeared in a brief shining moment when literally anyone could write meaningful programs without requiring vast amounts of training—-and then, like me and so many others, could grow and learn as the industry grew.
Related. Others?
Updating “101 Basic Computer Games” for 2021 - https://news.ycombinator.com/item?id=26273866 - Feb 2021 (65 comments)
From your own 2023 comment here: https://news.ycombinator.com/item?id=36945046
Play Basic Computer Games in the Browser - https://news.ycombinator.com/item?id=34377776 - Jan 2023 (1 comment)
Basic Computer Games (1978) - https://news.ycombinator.com/item?id=28572761 - Sept 2021 (12 comments)
Basic Computer Games (ported to C#, Java, JavaScript, Python, Ruby, VB.NET) - https://news.ycombinator.com/item?id=26188324 - Feb 2021 (3 comments)
BASIC Computer Games - https://news.ycombinator.com/item?id=19604142 - April 2019 (120 comments)
BASIC Computer Games (1978) - https://news.ycombinator.com/item?id=9026063 - Feb 2015 (31 comments)
Atari Archives: BASIC Computer Games - https://news.ycombinator.com/item?id=3200133 - Nov 2011 (23 comments)
BASIC Computer Games Book, published in 1978 - https://news.ycombinator.com/item?id=1866103 - Nov 2010 (36 comments)
There's also
More Basic Computer Games - https://news.ycombinator.com/item?id=41984335 - Oct 2024 (1 comment)
Basic Star Trek Games - https://news.ycombinator.com/item?id=42709559 - Jan 2025 (1 comment)
BASIC Star Trek Games - https://news.ycombinator.com/item?id=43070752 - Feb 2025 (2 comments)
Vintage Basic - Games - https://news.ycombinator.com/item?id=25502018 - Dec 2020 (1 comment)
I like the "Play BASIC Games in the Browser" link. All of these games should be collected into a browser-playable archive, along with the books and appropriate documentation.
Thanks for sharing! This brings back so many memories. When I was 8 years old, my mother enrolled me in a programming summer camp at our local university. This was my first exposure to BASIC and that is what got me hooked. After that, writing BASIC programs on APPLE 2/2E throughout junior high and highschool was the thing to do. Switched to Visual Basic shortly after that... It started it all for me!
I would love this for Forth :)
Yes, everyone had and has run these either on micros or bwbasic/blassic/bas, but porting these to Forth would be really cool.
The Retronauts podcast recently had an excellent episode about type-in computer games, and modern efforts to preserve them: https://retronauts.com/article/2367/retronauts-episode-677-t...
Among the most important computer books ever written, on the level of SICP and K&R.
Walter Bright said here that he learned programming from this book.
I found the backslash as separator of multiple statements on one line curious. I guess that's because I was used to BASIC on the Commodore C-64/128/Amiga and later the magical Amos Basic, so there were more differences in some of the other dialects.
I've been slowly documenting these differences with a series of Wiki articles. Generally though, there's three major "families":
* The original Dartmouth BASIC turned into a wide variety of mainframe versions. These are marked by the use of the CHANGE statement and supporting the MAT statements. * HP's dialect had array-based strings (like C) and string slicing... LET A$[1,6]="HELLO. * Timeshare's SUPER BASIC, which turned into BASIC-PLUS, which turned into MS BASIC, lacked those features and instead used MID/LEFT/RIGHT.
There's many other more minor changes from dialect to dialect, but those are the main differences.
Were line numbers in old BASIC games actually helpful, or just extra typing?
They were essential for branching with GOTO and GOSUB.
Example:
10 PRINT "HELLO ";
20 GOTO 10
You could then type:
15 PRINT "WORLD ";
10 PRINT "HELLO ";
15 PRINT "WORLD ";
20 GOTO 10They were required for most early BASIC interpreters. They acted as a label for goto statements and determined the listing/execution order. From memory, the TRS-80 (and similar) would immediately execute a statement without a line number, but would store a statement with a line number.
To elaborate on that: They were the handle on the code lines, for anything. You would often use the line number to either edit a given line number, or to remove it. 'Clever' people would even do mis-guided arithmetic on them, e.g.
GOTO MenuChoiceNum\*100 + 1000
GOSUB MenuChoiceNum\*100 + 1000Wow, it hurts to imagine maintaining and evolving that code :)
Fortran's had computed goto's since... at least '77 version. Fun times, those.
Fortran has never had a GOTO to a computed label number like this.
They were also how you edited your program in the absence of a coding editor. You'd type LIST to see your current program, type a new line with the same number to replace an existing line, or a new line with a new number to insert it numerically, etc.
Dartmouth BASIC was designed for teletype-style, hard-copy printing terminals, rather than video displays. Conveniently your whole session was printed out, so you could take your email and program listing home with you. Line-by line editing was practical for printing terminals, and line-by-line I/O scaled well across multiple terminals on a timesharing system.
Line editing also worked well on microcomputers with cursor movement (like the C64) - you could edit code in place just by overtyping and hitting "return" for the appropriate line.
On a slightly unrelated note, teletypes date back to the 19th century telegraph (and typewriter) era.
And still exist and are heavily used today, RTTY is built into most HF radios, and most militaries still use radio teletype, but encrypted and often at a different bandwidth.
AX.25 and qpsk didn't manage to replace it.
And it was an absolute pain if you had to insert a new statement, but didn't have enough space left between line numbers. You had to retype the offending lines with new line numbers.
Dartmouth BASIC had a renumber command. I believe that line renumbering commands and/or utilities were commonly available for microcomputer BASICs as well.
Some BASICs had a RENUM command. They were a bit of a pain as well. As you wrote your program you got to know which line numbers were associated with which statements. Doing a RENUM meant having to relearn the "meaning" of each line number. I'm pretty sure my VZ-200 didn't have the RENUM command.
Yes, most Microsoft ROM BASICs at least 8K in size had the renum command. It was still a pain because you had to figure out the start, end and skip values.
Sadly Atari BASIC did not.
I can't recall if the Apple ][ BASIC had it built in, or if Beagle Brothers utility software could do it, but it was possible somehow.
Common practice was to increment line numbers by 10 instead of 1. Would give a bit of wiggle room to add more lines in later without having to renumber everything else.
Well, since most 8-bit micros with ROM BASIC actually started up in BASIC, any BASIC you wrote without a line number executed immediately (and wasn't saved). So before you even got to goto and gosub labels, line numbers were useful for that.
Damn! I'm old. I remember the book.
The Dave Ahl books were one of my first introductions to programming. They're still awesome.
I wish modern computer companies to hire people to create material like this, the way DEC apparently did. Unfortunately computers aren't really programmed by end-users anymore. Arguably there's no need to between a million apps on one hand and AI on the other.
Are any of the games any good?
Golf.bas it's almost a Neo Turf Masters game in text mode.
Super Star Trek it's good too; and there are modern ports such as Super Star Trek from ESR in Python which expand the game a lot.
Also, BSD users have installed the old one, written in C, at /usr/games/trek.
man trekThe game of life is still being persuied relentlessly, the lunar module program was cooked by a NASA drop-out. Hamarabi is about to get cooked. Monopoly I do not think can be published.
Ha, `poet.bas` is the ancestor of all LLMs!
Where is gorilla.bas?
Looks like no Qbasic games? Nibbles, Gorilla - love to see them included.
Literally the first line of the README explains why:
> This folder contains the programs found in the March 1975 3rd printing of David Ahl's 101 BASIC Computer Games, published by Digital Equipment Corp.
No gorilla.bas?
BASIC, that is.
We've put an ASIC in there. Thanks!
I have a BASIC ASIC I think it's called a BASIC Stamp. 32 pin dead bug IC. Probably a PIC but I don't know for sure.
The title should be corrected.
Crafted by Rajat
Source Code