I was just thinking about how and where we learn to program. There must be quite a number of people now who work in software who were taught in Java. I was thinking that someone who first encountered programming in terms of classes, methods, and objects might have a bigger hurdle when it comes to programming in assembly language, compared to someone who first programmed on a calculator.

I'd be interested to hear your stories, both how you learned to program generally and how you found the initial stages of learning to program in assembly language.

For my own part, I think I'd come across both Fortran and Basic, in books, before having a TI-57 programmable calculator to play with. (Before the TI, I briefly had a Sinclair Cambridge Programmable, thanks to their 28 day money back guarantee.) I'm not certain of the timeline, from this distance. I know I wrote some Basic with paper and pen, and never got to run it, and got quite delirious with keeping my spaghetti code in my head.

I didn't come across structured programming until I was 20, I think, when I had a week long introduction to Pascal. I had by that point used BBC Basic, which has some facilities for structured programming, but doesn't enforce anything. (I was about to say I'd never been taught, up until that Pascal experience, but in fact I did a bit of COBOL at school, as well as some Basic, or possibly Fortran. But certainly there was no teaching of structure, or data structures, or methodology.)

I never have got to grips with OO programming.

I don't think I ever had difficulty with assembly language, but then I've never written anything substantial. I'd put that lack of difficulty down to having early experience on the calculator.

My introduction to computers was being beaten by a game called NIM - actually the one-line version, aka. "23 matches" ... You & the opponent take turns to remove 1, 2 or 3 matches from the pile and the one who takes the last one wins.

The computer beat me a couple of times, then I worked out the modulo 4 thing. Then the teacher showed me the BASIC listing and I said "that looks easy" ... Bother. Up to then I'd been into electronics... My family background was mostly mechanical engineering.

That was early 1978 (and I wast 16 by the end of that year) and a few months later the school I was at got one of the first Apple IIs in Scotland and the rest as they say was history. I got into BASIC programming, then when it wasn't enough, 6502 - mostly initially to better generate sound effects in the Apple II, then to speed up graphics. I went through the whole Integer BASIC, AppleSoft, DOS 3.2 -> 3.3, etc. phase on the Apples in that first summer... The "Red Book" - The Apple Reference Manual was essentially all I had to go on for the assembly part of it all.

After that, still at school there was some FORTRAN (just a different way of writing BASIC, isn't it?) then Edinburgh Imp (an Algol-like language) then I went to university where it was like going back in time - coding sheets for FORTRAN, Pascal, COBOL and PMA (Prime Macro Assembler) on a Prime mini, batch processing and TTY33's to make changes. I did manage to escape the drudge of that and found a nice little PDP11/40 running Unix and learned C on that - mostly by getting a summer job looking after it.

Structured programming was already there to a degree when I did BASIC in the Apple - mostly because my teacher was an Algol programmer and subsequently using Imp (as an after-school activity at a local college associated with Edinburgh University) so while (old) BASIC lacks the facilities for structured programming, I reckon that a good programmer can still create a structured program within the constraints. I've seen that while looking at old BASIC programs too - some, e.g. the original "Hunt the Wumpus" are very well structured indeed and I suspect it's because the programmers then also had an Algol background.

The worst spaghetti code I've seen has mostly come from self-taught programmers (not always, but that's been my experience)

After school I was a sort of full-time student for 8 years or so at uni and while the horrors of the Prime were still there, there came a much more elegant BCPL (part of a bigger project wher I wanted C, but we were constrained by the micros of the early 80's)

Fast forward a long time and I managed to get away without looking at OO style programming or C++ until I worked for a PC Games company. I survived that for a year and have not written a line of C++ since then.

Today I stick to C, 6502/65816 assembler, BCPL and BASIC - BASIC on the 8-bit micros and my own 32-bit BASIC - written in C but slowly re-writing it in BCPL.... I have zero interest in Python, Java, or anything else right now.

If you want to see the original Wumpus game alongside my own version, then it's here: https://unicorn.drogon.net/wumpus.rtb

-Gordon

_________________
--
Gordon Henderson.
See my Ruby 6502 and 65816 SBC projects here: https://projects.drogon.net/ruby/

It was 1978, I was 5 years old, and my older cousin told me about a "guy he knew" making a video game on a computer about a stork that delivers babies. LMAO.

Yes, typical BS talk from 5 year old kids.

However, it was enough to spark my life-long interest in computers. I immediately started asking my mom for a computer. Well, in 1978, parents didn't buy their kids computers. Especially poor people like us. Especially poor Southern people like us.

But that didn't stop me. I kept pestering her for a computer. Finally, in 1982 (9 years old) my grandmother saw a TI-99/4A at a Western Auto (remember those?) that was, IIRC, well less than $200. She bought it for me and I immediately started programming in BASIC. While the TI-99/4A was an odd-ball machine (which is why so many people like myself love it), it had an excellent stack of manuals and programming guides. TI was really a leader, IMHO, with home educational software. Well before Apple became widespread in the educational market.

We never could afford a disk drive or carts like XB for the TI. I remember one year, I think I was 10 or 11, my only Christmas present was a Speech Synthesizer because it was really expensive at the time. But it was awesome! My TI could talk!

Later, my mother made a promise that when I went to college, she would buy me a computer. So in 1985, I enrolled in chemistry, math and computers at a local community college. Yes, I was just 12 years old. It was a special program for "gifted" students where we could take some courses on the weekends. A way to promote education. I loved it because I got to play with TRS-80's there on campus.

My mother kept her promise and bought me a complete Commodore 64 setup!! I quickly got into BASIC and even assembly language on that machine and didn't look back until I got my Amiga 500 when I was 16.

The rest, as they say, is history.

_________________
Cat; the other white meat.

My first exposure to a computer was in 1982. I went to a small school system which only had two computers at the high school, an a Atari 400 and 800. In eighth grade my classes were at the high school as the junior high ran out of room and the computers were in my new math teachers room!

I first dabbled in Atari BASIC, I can remember writing a drawing program that remembered your movements and could redraw the screen just as you originally drew it but ran out of memory very quickly. We each had our very own 5 1/4" floppy disk which was kept in the class room. I wrote a 'virus' program on another students disk where it would autoboot into the virus program, make the screen look like the BASIC prompt screen and disable they keyboard and function keys. If you rebooted you got the same thing. It was a rather mean thing to do to someone ( I feel bad now about that part of it) but technically I think it was interesting.

I bought a used Timex Sinclair 1000 for $30 and programmed in BASIC on it and started learning about machine code. Then I was very lucky that my parents bought a C64 system, I still don't know how they afforded it, but it changed my life. I used BASIC at first and then machine code.

When I went to vocational school for electronics they had al old CPM computer and some old microcontorller trainers which had an Intel 8080 or 8086 (don't remember which), but I got to learn its machine code. We also had TI programmable calculators. My second year we got new 6502 trainers which were nicer but I knew the 6502 backwards and forwards so I did not learn anything. My teacher then gave me a PLC which had been donated and wanted me to make a traffic light controller out of it. That was a completly mind blowing experiance at the time as trying to figure out basic constucts like loops was difficult as I recall. (The autobody shop repainted the traffic light, the electrical wiring calss rewired it and I made it blink )

Over the last 30+ years I have learned many flavors of BASIC, different scripting languages, strange programming 'languages' for industrial controllers, ladder logic, C, C++, Forth, Java, Python, etc. It seems to me that the first language you learn is not as important as learning the concept of programming. Loops and conditionals might be expressed diffrently in diffent langauages but they are the same concept. If you learn the concepts you can move between languages much more readily.

My first program was also the NIM game. At the time I worked as a hardware customer service engineer for UNIVAC (later UNYSYS). I was stationed at a customer (insurance company) in my home town, who had an 1106 mainframe together with some older and smaller equipment. The program was a deck of punched cards containing a line of BASIC code each. Editing it required to replace some cards and then read it in again. The program ran interactively on a terminal however.

At the time I knew all the machine language instructions of the 1100 and 9000 series of UNIVAC computers and was able to code simple handloops for hardware debugging purposes. I later applied for a job as a test program writer with UNIVAC but failed to get the job.

With my new employer Amdahl remote maintenance became part of my life and I maintained some of the tools for it starting with a Heathkit H89 with 1200 Baud modem to dial in to customer sites. It also had a 300 Baud acoustic coupler to connect to the Amdahl internal problem documentation and e-mail system. You had to be quiet and patient...

But it wasn't until I purchased an AIM65 with both BASIC and Assembler ROM to get involved in serious assembler programming. I had an SC/MP before but that was again more like programming small handloops and I never liked the instruction set of it.

Up to today I have used many scripting and programming languages without ever becoming an expert for one of them. However, assembler rules if you want to drill into the heart of a CPU! It's not OO and it's not structured, so you simply have to be carefull with what you're doing.

_________________
6502 sources on GitHub: https://github.com/Klaus2m5

My first interactive computer experience was "Eliza" in about 1976 on the Lawrence Hall of Science's time sharing mainframe ... I was enchanted, because it didn't seem to be a large cut below the computers I loved from Star Trek TOS (except for the voice recognition part, of course). Then Lunar Lander on another time shared mainframe at the local junior college soon after. I was ten years old. In late 1978 I finally got a chance for interactive programming, this time on a 4K TRS-80 Model 1 with Level 1 BASIC, and I was thoroughly hooked. It was upgraded to 16K Level 2 BASIC soon after, and I was even more excited, staying after school while my friends and I wrote, typed in and tested games. The only bummer I can remember was the crummy cassette tape storage, which was slow and unreliable. "Invasion Force" and "Dancing Demon" were my first glimpses at the incredible power of machine language, but the TRS-80 didn't have any built-in support for assembly language development.

Fast forward to late 1981, and my parents graciously bought me my own Apple ][+ with 32K and cassette storage. Applesoft was definitely more nimble than Level 2 BASIC, and that was good enough for a while, typing in BASIC programs from magazines, composing my own experiments and buying mail-order cassette games. But the machine language bug finally bit me hard, and I was pleasantly surprised to discover that Woz had provided a nice built-in machine language monitor for me to play with. When I got my floppy disk drive two years later, I even found his mini-assembler inside the Integer BASIC binary image on the System Master disk, and there were no more barriers to becoming proficient in 6502 assembly language. Symbolic assemblers came later, and were just icing on the cake. I also got my own C=64 and 1541 around that time, but the slow disk and lack of built-in support for its unique features were a bit disappointing compared to the admittedly more primitive ][+.

At University lower division in the mid-80s, I took one semester each of Pascal, Fortran, C, and 360 Assembly language. C was my favorite of those four, and was hosted on the campus DEC VAX mainframe. The others mentioned were hosted on the CDC Cyber mainframe (simulated 360!). In upper division, I got a taste of 6809 assembly and 68000 assembly. I stayed away from most of the 8xxx stuff, because I just found the assembly languages of that family unpalatable.

Nowadays, programming is a hobby for me, and I gravitate toward C, BASIC and 6502 Assembly to conduct most of my experiments, but I am still interested in learning some FORTH and Python. Spare time is definitely the controlling factor, as Real Life ™ has always loomed heavily over my playtime.

_________________
Got a kilobyte lying fallow in your 65xx's memory map? Sprinkle some VTL02C on it and see how it grows on you!

Mike B. (about me) (learning how to github)

_________________
http://WilsonMinesCo.com/ lots of 6502 resources
The "second front page" is http://wilsonminesco.com/links.html .
What's an additional VIA among friends, anyhow?

@Mike,

I had a hunch that one of your first programming experiences was with a TRaSh-80. hehehe

_________________
Cat; the other white meat.

My first programming experience was in 1976 with a Commodore PR100 calculator, which I am astonished to find was manufactured in the UK!

I progressed to a TI-58c (which is moldering in the basement somewhere). My first real computer was a homebuilt Compukit UK-101 with the extra 4K of 2114 RAM chips. I programmed that in assembler and basic. An Apple II followed (actually an ITT-2020 clone in a silver case) with twin discs and UCSD Pascal. I worked two jobs to get that! When I went to college I discovered the delights of punched cards and batch processing on a CD -7600 until a Zilog Z-8000 based Unix v7 machine came to my rescue. Unix and C were heaven!

I started with LOGO on a black-box LINK 480Z with a green screen monitor. I made it draw a square, then polygons, then a circle that took all break-time to finish.

I tried to learn some BASIC on the Commodore 64 but soon after got a good book on assembly language and a Power Cartridge. Later on I got the Action Replay VI cartridge, which was better.

Nowadays I use Ruby on the server and CoffeeScript in the browser though I like C for programming AVRs. Ruby is a high-level scripting language but it can be readily interwoven with C for any high-performance requirements. I've written performant OpenGL apps in Ruby this way.

I started with QBASIC running under Windows 98's DOS, when I was about 10, I think. My first programs were nothing special, really. Mainly the equivalent of hello world with different strings.
QBASIC did have support for structured programming(SUB and FUNCTION), although I don't think it enforced it. When I figured out what that was, and that there were alternate ways to do the same thing(DEF FN and GOSUB), I looked at those and went "Why would you want to use those? SUB is so much easier." Later on, I learned that SUB and FUNCTION were fairly unique to QBASIC at the time. Some time later I found a copy of QuickBASIC on the internet (mainly because I wanted the more advanced graphics capabilities of the DirectQB library), and started fiddling with that. I never made anything too impressive then, although I did go back and make a Wireworld sim in it when I started uni a few years ago.

Before I started uni, I started playing Minecraft, which is written in Java. There are a couple of unofficial modding frameworks for it, and I wrote a couple of dodgy mods that were very quickly forgotten about.
I took a look at GW-BASIC(sometimes known as BASICA) when I got hold of a computer that had it on it. I wasn't particularly impressed.

I also took a look at Commodore BASIC, when I got hold of a couple of Commodore 64s(a breadbin and a C64C, both of which I still have). I was even less impressed with that, but that was mainly because I'd read that the C64 had some decent graphics and sound capabilities, and its BASIC didn't have any commands to work them. Neither of those work very well anymore, which is rather sad.

At uni, I was taught Python(which I didn't like), Java(in more detail), Scala, C++, and C.
I still use C/C++ and Java, where appropriate. Scala was interesting, but not enough to get me to come back to it, and Python's approach to variable typing rubs me the wrong way. Typeless variables and typed data is just gross to me.

I had trouble comprehending what objects actually were for quite a while, until sometime in the C++ unit(I think) where it clicked.
The class(the object definition) is actually a data structure(struct in C, TYPE in BASIC), bundled with the subroutines and functions to operate on that structure. The object itself is just an instance of the data structure; the routines don't get duplicated.

First family computer: an Amstrad PCW-8256. Alongside its primary office-type applications, it was possible to boot it into CP/M and run a BASIC interpreter, but we didn't have a manual for that stuff so I didn't do anything with it.

Then we got a BBC Micro second-hand, and that is a machine that was literally made for teaching programming. At some point we also got a ZX Spectrum+, but that always seemed like a toy to me, rather than an actual computer. It had to be plugged into our tiny colour TV that sat on an awkward high shelf, after it replaced a somewhat larger but much older black-and-white set that broke down. The BBC Micro actually came with a half-decent monitor.

Later still. we got an Acorn RiscPC - our first "modern" computer with a desktop GUI. Ironically, this was also the first of our computers that my mother had serious trouble learning to use. But as well as having a seriously upgraded version of BBC BASIC built in, we got one of the "nearly ANSI compliant" C compilers and a book. Needless to say, I learned a lot from that. I don't think I had any real trouble with pointers or recursion, which are the most commonly cited difficulties.

At school I had an Amstrad NC200, which again had BBC BASIC on it (this time one of R.T. Russell's versions, I believe). There was no traditional GUI, but the slickness of operation was very gratifying - as was the fact that it would last well over a week on a set of batteries. A bit later I was given a PowerBook 190 and a copy of CodeWarrior, which served as my introduction to AppleScript (a truly horrid language to actually get things done in) and C++ (likewise). I'm pretty sure C++ hadn't actually been standardised at that point. So by the time I took a C++ course at college, I knew all the material before it was given, and consequently I was among the few to actually pass the final exam (with a Distinction, no less). I continued to use CodeWarrior through my university days, basically until OSX rendered it obsolete.

CodeWarrior included an object-oriented overlay on the Macintosh Toolbox. Since I didn't have any of the "proper" Mac documentation - a recurring theme until relatively recently - that was what I had to use to write any properly Mac-like software. Between this and the Java-based university courses, I found object orientation to mostly be a headache that had to be navigated and worked around, rather than something that actually supported me as a programmer. That was, of course, because it was taken too far, producing what I like to call "wormhole code". OOP has its place, but you have to know which parts of it are actually useful in a given situation, and which are merely stylistic gloss that quickly turn into technical debt.

I have studiously *avoided* using C# - aka "Microsoft Java but we're not allowed to call it Java anymore and we had to change the syntax too so it can't be casually mistaken for Java". These days I also avoid using Java, since Oracle took over and ruined everything about it.

Most of my professional career has involved using C, not C++. Consequently, the advances beyond C++98 missed me for quite a while. Modern C++ with Boost is an extremely powerful language - but it's like a Barrett 50-cal or a KP/31, and requires extremely careful handling to actually use that power. On the occasions I do use it, it is simply to apply Boost's extensive library of templated data structures and algorithms, and otherwise just the very basics of OOP without much strictness.

Lua is an elegantly simple language that is surprisingly flexible. But not very fast. I was introduced to it by scripting mods for a game, for which it is very well suited.

Python is a very powerful and reasonably easy language, but painfully slow, which limits its usefulness for big projects.

PHP and Javascript are hell-spawned abominations that I refuse to write even a single line of code for. They make the surprisingly extensive realms of "undefined behaviour" in C look like Number Four Privet Drive next to Grimmauld Place.

There are many language features that I *wish* were available, but are not - even in C++ with Boost, or Python. Perhaps one day I'll be able to implement them. I am, after all, starting from the ground up with the 6502 family again…

For me, dates back to 1974, junior year in high school. A short 9 weeks course titled "introduction to computer programming". No computer we could see much less touch. One of the math teachers came up with the course idea and agenda. The school had an IBM 5410 (System/3 Model 10) which ran all of the school's DP needs (it was called Data Processing back then). We learned some basic Fortran coding, had to write it out first, then key it into a card punch machine (IBM 5496) that punched into the smaller 96-column cards. The teacher would stay late and run the programs from the class and then give us our print outs the next day. It wasn't all that exciting as we never saw the actual System/3 machine.

Two years out of high school (1977) and I landed a job with IBM... 2 years later (1979) I was in General Systems Division and my old high school was in my territory and I was now servicing and maintaining the same System/3 I had learned Fortran on... small world, who knew. Even the vice principle remembered me, albeit not walking into the office in a suit & tie with an IBM badge. I eventually packed the System/3 up, and re-installed it into a new location for data processing and about a year later, packed it up again and installed a nice new System/34. By then, the school also had a single Apple/II which was available on a very limited basis to some students, and was also in the same room as the System/3.

Well, around 1982 I picked up a Vic-20 and played around with Basic... really didn't care for it... also bought a 1541 disc drive... and the Machine Language Monitor cartridge. Taught myself 6502 assembly language, bought a C64 a bit later on and then picked up the Commodore Assembler package. I still have all of my original Commodore machines to this day. Having started a small computer club at the branch office in NJ, I interviewed for a job in Boca Raton providing level 2 technical support for the IBM PC and got a transfer early 1984. I later taught myself 8088/8086 assembly language and started writing some utilities for the PC. I wrote the first hard disk cloning utility one afternoon and it was used for a long time by Bank of America, Sears, various other large account customers, IBM branches world wide and early production preloads on IBM's PC line.

This turned into a nice career... being heavily involved in the hardware and software for all of IBM's PC products. I eventually focused on the software side (technical sales, direct customer facing globally) and was a charter member of Personal Systems Line of Business, which became IBM Software Group. I retired in 2015 after 38 years... and still build up my own machines from piece parts, run OSX mainly (have many Apple machines as well). And now I'm back to where I started.... writing assembly code on the 65C02 and designing and building my own hardware to run it on.

I've enjoyed getting back to when personal computing was, well... more personal, simpler and more enjoyable as well. My collection of machines is decent... probably 30 or more scattered around the house (office, closets, attic) and spans over 35 years.

_________________
Regards, KM
https://github.com/floobydust

I was 12 in 1981, and my oldest sister was working in a furniture store. The owner of the store was an older gentleman who was really into computers, and he had subscriptions to a whole lot of magazines, including Byte, Personal Computer World, Popular Computing, Electronics and Computing, Your Computer, and more I can't even remember. My sister had told him I was interested in that too, and every Friday she came home with a stack of magazines. I read each one. Cover to cover. Multiple times. Even the ads.

I can't remember which magazine it was, but one ran a series called "Building BASIC", which taught the language from 10 PRINT "HELLO" : GOTO 10, to, well.. probably FOR / NEXT, READ / DATA, SUBSTR$ and things like that.

High street stores like WH Smiths and Curry's had models on display, and every day after school I would walk to the city center (about 20 minutes away) and spend a few hours hogging whichever computer I could find and experimenting with whatever bit of BASIC I'd read about the night before.

The color ZX Spectrum, another Z80-based machine came out sometime in late 1982, as I recall. Either Christmas '82 or sometime in early '83 my parents bought me one (125 pounds... a lot of money for us at the time)... and you couldn't drag me away. I had very little / no pocket money, so I had very few games. I guess I had at most four games on cassette for that machine. I spent most of my time programming in BASIC... learning.

In the back of the ZX Spectrum user manual was a table of Z80 mnemonics and opcodes, along with weird column names like "After CB" and "After ED" (from memory). Things like "ld bc, n" and "call nn" and "push bc". What was this? What did it mean?

One day Electronics and Computing Monthly (as I recall, but honestly it could have been any of them) did a series on Z80 machine code. Machine code... that sounds interesting. It described how this "machine code" is what actually runs on the CPU, and it was 10x - 100x faster than BASIC. Ok... now you have my attention. Following the instructions, I POKEd my first Z80 program into RAM and called it via USR. "ld bc, 1234; ret" or something like that... PRINT USR(whatever) displayed 1234. I WAS A GOD AMONG MEN.

After some saving I bought the HiSoft DevPac assembler for the ZX Spectrum, and then spent some time learning Z80 in earnest.

Sometime in 1985 a friend of mine had a Commodore 64 and he introduced me to the 6502. He would write little proto games on it. The capabilities of the C64 was way beyond the ZX Spectrum in terms of graphics and sprites, so I wanted in. Unfortunately the C64 was out of my price range, but I sold my Spectrum and got a good deal on an Atari 800XL. I didn't even bother with BASIC, and immediately bought the Atari Editor Assembler cartridge (possibly the slowest assembler ever written), and started learning the ins and outs of the machine. This was a really fun time for me. The Atari had fantastic graphics hardware, and it was a treat to uncover its tricks.

By Christmas '86 the new generation of 68000-based machines were on the scene. The Atari ST had a 68000 CPU at 8MHz, 512MB RAM, 320x200 in 16 colors, full sized real keyboard and a windowed graphical user interface. It looked incredible. As soon as it arrived I bought a 68000 assembly book, along with the DevPac ST assembler and two different books on programming the thing at the hardware level. I wrote 68000 for the next four years.

I graduated university in 1990 and have spent my career in the 'C' and assembly worlds, building embedded systems, switches and routers for companies you've heard of, and ones you haven't, on platforms ranging from 68000 VME racks, 68360, PowerPC, MIPS32, and ARM64. I still get my kicks talking to to CPUs and hardware at lower levels, leaving the GUIs and Go programming to people better qualified for whom that's their jam.

I never tried to get into the x86 seriously. I was pretty late into PCs, having kept my Atari ST well into the early 90s and only buying a PC finally when hardware 3D graphics started being a thing, with the 3Dfx Voodoo cards. Then my PC was for gaming, not for learning. Prior to that I'd used PCs at work, even installing 386BSD on a space 80386 machine for a little UNIX fun. The x86 architecture was never an itch I had to scratch... I think because I always saw it as a complex system hidden by BIOS, and no two systems were alike, so there was no one thing to learn.

I've told my sister a couple of times that I have her to thank for my career and my life: The opportunity to move to the States, and live and work in Silicon Valley - a place I'd seen on TV as a teen and wondered how great it must be to live there (spoiler: the traffic is awful). She tells me I'm stupid and all she did was bring home some magazines... Sisters...

EDIT: As I read this over I realized how many mistakes I made last night. Not that it matters, but.. In the mid 80s there was a CB radio craze. I actually sold my ZX Spectrum to buy a CB radio. That lasted about a summer. A school friend had an Atari 800 and he demoed it one day and I was hooked. I sold my CB, bought an Atari 800XL system that Christmas '85, and got to work. My C64 buddy and I used to write proto games together. When I sold my Spectrum I kept hold of my personal tapes with my own programs. About seven years later my university was cleaning out its old computer stock and they were dumping a ZX Spectrum. I snatched it up (along with a microdrive and a Sinclair QL... that was a weird one), and a couple of my old tapes still worked.
I still have that ZX Spectrum, those tapes, my Atari 800XL and Atari ST. I haven't powered them on for 20 years whilst I've been in the US. Maybe I will one day...

My first programming experience was with the ZIP Mail Translator (ZMT) in 1970. I did have some exposure to naval ballistic computers in the 1960s, but one didn't program them in the sense of writing and assembling or compiling code.

The ZMT was a mail-sorting computer that was attached to an electromechanical letter sorting machine. The use of the ZMT greatly simplified the use of the letter sorting machine, as the operators (12 of them per machine) could more-or-less type in part of a ZIP (postal) code and the ZMT would tell the letter sorting machine how to handle the mail piece. Prior to the adoption of the ZMT, letter sorting machine operators had to enter ZIP code data by playing the keyboard like a piano, all the while mentally translating the ZIP code into certain key patterns—the machine had very little intelligence. It wasn't easy work and mistakes were frequent.

I started out as an installer and troubleshooter, but soon graduated to programming the ZMT, which was done via a Tele-Type model 33 ASR, using a what was essentially bare-metal machine language. Having no prior exposure to high level computer languages, I had no problem with the ZMT machine language—it was just a series of numbers combined with certain symbols. The procedure was to write the program, which would punch the paper tape. After finishing with the code, the tape would be run through the reader so a copy of the program could be printed and compared to what was written. It was also an opportunity to catch typos and transpositions. The tape was run through the tape reader to load the program into the ZMT, which had remanent magnetic (magnetic-core) memory, 1K of it—one kilobit, that is, not kilobyte. Careful programming was required to avoid using up too much memory and not leaving enough room for run-time data. Other than core, there were no storage facilities.

In 1976, my then-employer had developed an event recorder for use on locomotives to capture data while the train was in motion, e.g., speed, brake pipe pressure, etc. The prototype recorder was powered by a Zilog Z80, which was a very pricey device at the time (several hundred US dollars, as I recall). It wasn't too long before one of the designers had a look at the 6502. The 6502 was about 25 dollars, which meant the Z80 was out and the 6502 was in. Yours truly volunteered to learn the 6502 assembly language to develop test code for the recorder. The 6502 assembly language was more extensive than the ZMT machine language, but easier to understand—it was easier to visualize how to get the desired results.

Before any programming could be done, an assembler was needed. MOS Technology had a reference assembler that could run on some systems, but not on the IBM 370 mainframe that we had at the time. So one of our staff programmers studied the 6502 data sheet and wrote an assembler in FORTRAN, which worked well and was pretty fast.

Speaking of FORTRAN, up until 1978, I had no exposure to high level languages of any kind. My programming world was one of hexadecimal, mnemonics and all the other trappings of assembly language. However, I wanted to tweak the 6502 assembler and add macros to it. So I had to learn enough FORTRAN to do so. Later on (1981, I recall), the company got a DEC VAX running UNIX. Two years later, I purchased a Commodore 64. Meanwhile I had learned BASIC from working on a Basic IV mini, so the BASIC in the C-64 was definitely a step backward. It was back to assembly language.

I still work with business BASIC—a huge amount of software is written in that language, which is light-years more powerful than any micro BASIC. That said, I often find myself writing logic in BB that looks a lot like what one might see in assembly language. Old habits do indeed die hard.

_________________
x86?  We ain't got no x86.  We don't NEED no stinking x86!