The Consequences of One's First Programming Language

BASIC has everything assembly does. At a high level, Assembly offers GOTO and GOSUB. Obviously, you can have pointers to anything, indirect jumps, etc. but, to be honest, unless you're writing your own malloc (and it a lot of assembly cases, you're not), you're dealing with static allocations of memory for data. A pointer can be no different from an offset into an array in BASIC (or set of arrays -- array of ints, array of strings).

You can recurse with BASIC, you just need to maintain your own stack for the data (the BASIC will handle the stack for the GOSUBs, if you continue to use them). You may well maintaining your own stack in assembly (ye old Forth-ish data stack v return stack). I've seen several different compilers written in BASIC. You can have "Structures" in BASIC. PNAME$, PADDR$, PZIP$, PBDATE. Turn those all into arrays, and you have arrays of structures. With a Pointer! (P!)

It's inelegant, but so is assembly. It's too primitive to not be. Outside of macros, there's no real abstractions. At best you can offset a memory reference to get something akin to a structure, and use constants for that offset. But, in the end, unlike todays legos, you're still stuck 2, 4, and 8 pin bricks to build everything. Plus all the fun register juggling.

Assembly lets you have better identifier names. Six letters! I remember a lady who wrote much of here companies core business software in BASIC. She was particularly proud of the fact that Z9 was the universal error/status variable used in the system. Similarly, I recall my father lamenting that he could only have variables such as A, and AA, but not AAA in BASIC (since at the time, MS-BASIC only distinguished on the first 2 characters).

BASIC is high level assembly, that just so happens to have some of the best string processing, and some pretty good I/O, in the business. (Garbage collected string processing in MS-BASIC, no small feat. Who knew you had a garbage collector in that 8K BASIC?)

I was not scarred by my BASIC experience. Nor my FORTRAN (it was FORTRAN back then) experience. (Very BASIC-ish, without the as many line numbers). I was grateful to have learned FORTRAN-77 and not -66. I would not want to go back to dealing with BASIC, particularly not 8-Bit level micro BASICs of yore, not if I didn't have to. That said, one of my favorite languages was a 4GL with in built SQL, screen forms, and reporting. It was limited in many ways that BASIC is, but, boy howdy, could I pound out usable, effective software that helped the company and its people with it, which is, in the end, what this is all about most of the time anyway.

About as far as I'd want to go back is QBASIC. It's lack of line numbers, and full screen editor send it over the top. Line numbers are what they are, but the biggest problem with them, particularly in MS-BASIC, is you can't renumber sections of lines. Like, you can't renumber lines 1000-2000 to 3000-4000. So, you can't easily re-organize and move code around.

But you make do.

Beats clicking binary into the front panel.

Java was not my first programming language, but it was the one I used at my first job, so it was the one in which I first read widely about the best ways to do things. I was immersed in the Java OOP culture. I lived through the days when it was normal to review the names of a couple dozen design patterns before a coding interview. Now I feel like a witness to history, and also like someone who was raised in a cult and then left and now tells people what it was like.

I haven't heard UNIVAC's facility in Blue Bell, PA, mentioned in a very long time.

Original BASIC had neither data structures nor scope. So programmers who started with BASIC lacked some key concepts. There was thus a problem at one time with programmers who started in BASIC.

I like Java as a host language to do things like:

Write numerical codes in FORTRAN style, allocating a few big arrays at the beginning and not pressuring the garbage collector. This is how I'd write an FFT, matrix inversion, or something like that.

Write programs with very few class definitions but a large number of static methods. (Like any non-OO languages, but static methods can go nicely with a few well chosen classes you make instances of)

Write static methods that take instances of "Object" as a parameter that are inspired by an algebra like that for a language like Python (of course a Collection is treated special, etc...)

Use static methods to build up structures like LISP's S-expressions.

These tactics can be used, for better or worse, to write Java DSLs that appear to describe "business rules" in plain English with the caveat that things like that are never as easy for muggles to maintain as you wish they were.

What’s the story behind your starting with Windows XP and then moving back to a Commodore 64?

For me, by the time Windows XP rolled around, my Commodore (128 not 64) was sadly long gone — given away at a garage sale by my parents while I was off at college.