The combination of BASIC with the basic ability to have inline assembly was very convenient - just use a BASIC for loop for two-pass assembly, use CHAIN to split source into multiple files, etc.

Same here. I cut my programming teeth on BBC Basic and later 6502 assembly, initially on an Electron, then the Model Bs at school, and we later had a Master 128 at home.

The integrated multi-pass assembler was a godsend for someone who got to the point of wanting to play around at a lower level, but before getting to that stage the language had other things that set it far apart from other micros of the era:

• Better structured programming constructs: proper procedures and functions where some other 8-bit BASIC implementations had nothing beyond GOTO/GOSUB. With a little hoop jump you could completely do away with line numbers.

• Long variable names, where some implementations only allowed two, or even just one, character. This allowed code to be a little more self-documenting. IIRC it only considered the first 40 characters⁰ despite not erroring when there were more though, so if you used anything longer one variable could silently clobber another.

----

[0] but who was using such long names in the limited memory¹ of an 8-bit home micro?!

[1] I did actually write something a bit akin to modern JS minimisers, to make things fit in the smaller model A² machines: it removed REM statements and did a fairly naive scan-then-search-and-replace to replace long names with shorter ones

[2] these had only 16KB rather than 32, which after taking out screen memory and other standard allocations were taken out didn't leave a lot of room for your code to live in

There's no obvious length check. I guess the actual limit will be 255 or 254 characters, maybe minus a bit if the info block has any extra data.

EDIT: previous discussion: https://news.ycombinator.com/item?id=19246063

Line length was limited by a byte-length counter and IIRC included the line number and maybe EOL, so would be something like 253 or 252. Do the maximum usable variable name length will be a couple of bytes less than that as you'll need a couple of characters to do something with is (LongLongLong...Long=1 and so forth).

EDIT: oh, interesting. The only references I can find to a variable name limit of 40 characters are referring to the PC BASIC implementations by MS: GWBasic, QuickBasic, and QBasic. I did do work in those too.

Those BBC TV shows had the unusual feature of broadcasting software over the end credits. Just had to tape the screeching and play it back into the computer.

I actually tried downloading programes from the Dutch radio station back in those days - and it worked.

That was your queue to literally physically stick the box over that square on the screen and then a few minutes later during the end credits that square would turn into what would look like to the human eye just plain old static but to the sensor in the box stuck over it, it was reading it as a datastream that the software would interpret and save.

To be honestly it wasn't terribly reliable, I think we got it to work maybe once or twice in the few times they did it but was an interesting experiment by the BBC back in the 80s!

Can you explain this? Do you mean that BASIC programs were encoded as sound in some way, and then could be uploaded into the computer and run?

The tape would contain bleeps and blurps which would be decoded into bytes by the computer. EG this is the sound produced by an Amstrad cpc464 loading a game: https://www.youtube.com/watch?v=OvChkOHgDIo

This meant that to copy software you didn't even need a computer, just a double cassette deck.

And that by recording the credits of this BBC show to tape and playing that back into the computer you'd load some program. That's actually a brilliant idea, I wonder what kind of software they broadcasted.

Sounds (pun not intended but noticed) like steganography.

https://en.m.wikipedia.org/wiki/Steganography

Software has even been distributed on vinyl records and flexi singles!

You could connect a domestic cassette recorder up to a BBC Micro and use to save and load software onto normal cassettes!

There were favoured devices that would give better results and better cassettes for data storage and so on.

Its all ancient history and folklore now :-)

I must admit, I feel somewhat similarly to you. I want to prod at the hardware and write some assembly code. Whereas if I wanted to work with SDL there are better ways for me to do that.

With that being said, BBC Basic was a great entry point into programming for a lot of people and it's perhaps the case that it could still be so, so I do appreciate the fact this project exists.

         10 PRINT "This computer is overheated."
         20 PRINT "WARNING: Computer about to EXPLODE!..."
         30 GO TO 10
         RUN

Line numbers are arbitrary, you can just use GOTO to jump to some out-of-line code then GOTO back at the end. It gets a bit spaghetti'ish if you do it lot, though.

The school I went to only had a cpuple of computers, so I wrote code longhand on A4 lined paper. When I needed to insert lines, I wrote them on a slip of paper that I placed at the appropriate place on the page and stapled on the right-hand edge.

We've certainly come a long way.

Another thing that one got: a printed circuit diagram of the machine.

As for today: One can get get an entire annotated disassembly for Elite, including the version that used the Second Processor: https://www.bbcelite.com

Sometimes replaced with a smoke screen at this age: https://www.youtube.com/watch?v=TU55-7dWMi0

I had a ponder on the attractions of the 8-bit era a few days ago ...

https://thechipletter.substack.com/p/the-virtues-of-the-8-bi...

Closest I've found to a modern version is the Colour Maximite

https://geoffg.net/maximite.html

- Instant-on - You hit F12 and in less than a second you've got an IDE with a REPL

- Integrated assembler - While I don't think you can inline it, WASM is really easily used: https://developer.mozilla.org/en-US/docs/WebAssembly/Loading...

- Great documentation: https://developer.mozilla.org/en-US/

- Way too much access to hardware: I wish browsers had less access to hardware due to privacy and security, and I don't know how low level the APIs get, but it's something you can play around with as a random person with a web browser, so that's neat.

Yes, as easily as this:

some BASIC statements here

[ some assembly statements here ]

some BASIC statements here

IOW, you just had to enclose your assembly language statements in square brackets. That's it.

Of course, you would need to know what memory addresses to operate on, in a real-life program, as opposed to a demo, so that you could share data in some way between the BASIC code and the assembly code, otherwise the program might not be able to do anything useful.

I don’t know about the multi-pass assembler feature that others have mentioned in this thread.

Using 1 would suppress errors, which would mean you wouldn't know if your code was bad.

You could use 0 and 3 or, if you don't want a listing, 0 and 2.

Search this page for 'first pass', for a more complete explanation: https://central.kaserver5.org/Kasoft/Typeset/BBC/Ch43.html

But I'll check that page out anyway.

Thanks again.