I worked as a hotel night auditor during college. It was great for me: I did actual work from around 11PM to midnight, then loafed around until around 6AM when it was time to set up the breakfast table.
A big chunk of my job was doing tedious manual edits in the guest management software that tracked who was in what room, what phone and pay-per-view charges they'd racked up, etc. It occurred to me to peek at its database file and see if I could pull any useful data out with automation. The DB turned out to be a flat file of fixed-length records. The DOS PC had a copy of QBasic on it and I used a bunch of trial and error to map those records to types, and then I could loop across the records to get interesting data out of them.
Long story short, I ended up with a system we'd run nightly to correct misspellings, build reports of which companies did the most business with us and how recently, identify regular guests who hadn't been around in a while, and a thousand other little things that made my job much more pleasant and my boss extremely happy.
It would be much easier to recreate that program today in a nicer language. I didn't have a nicer language available, though, and while it wasn't pretty, QBasic got the job done.
The AWK Programming Language was published in 1988, and indicates:
"Aside from these
limitations, however, awk should be useful in any environment; in particular, it
runs on MS-DOS. Further information is available from Addison-Wesley."
It likely was not easy to find, and I hadn't heard of it until 1990.
There's zero chance I personally would have been capable of building that same software in Awk, even if I knew of it, and even if I knew how to get it onto that non-networked computer that didn't have any removable media in common with what I had at home.
BASIC is a uniquely useful language on machines with extremely limited RAM. It was designed to take up as little program space as possible even when compared with machine language. On home computers, each BASIC keyword is tokenized into a single byte.
I have a computer with only 3kb of RAM but has a comparatively large amount of ROM to support a complete BASIC. With BASIC you can create useful programs that would otherwise be impossible to fit into RAM. This has given me a newfound respect for the language.
Which was an attempt to make a standard dialect that different computers could interpret, and/or convert into their own machine's BASIC.
A late-night radio program (NOS Hobbyscoop) would often end its transmission with some minutes of tape-loading sounds. Users would record this on tape, run it through some conversion program, and RUN. So the same program as transmitted over the air, could then be run by C64, ZX Spectrum, MSX, Amstrad CPC users etc.
Iirc it wasn't that popular compared to other ways of obtaining software. But computer users @ the time were eager to do & try anything they could get their hands on. Today's internet info-overload didn't exist then.
And of course radio had a wide audience. Interesting programs could thus be distributed among many users quickly.
It's hard to overstate how important BASIC was to the adoption of personal computing - it provided a straightforward way to program an entire generation of home computers and bootstrapped countless careers.
I don’t understand why it isn’t taught to kids instead of scratch.
Visual coding is my nemesis. I just disagree with it in principle. It makes even the simplest things complicated and virtually impossible to debug.
BASIC was the first computer language I learned. It’s so basic I just taught it to myself from the help section when I was 12, without any exceptional ability on my part.
You're giving me ideas-- My oldest is nine and that's probably around the age when I first got my own computer (a 286) and dove into QBasic. There's no way he'd choose to spend time in BASIC unless it was his only option. I have an ancient Thinkpad gathering dust, maybe I'll install DOS 6.22 on that sucker and have it boot straight into QBasic from autoexec.bat.
At bedtime we're a "you don't have to sleep, but you have to be quiet" household so if he had it in his room it might see some use.
I think aiming for visual appeal is a dead end or at least a false dawn.
Instead aiming for that Frankenstein moment of excitement ‘holy shit this thing is kinda alive!’ Is where you want to get to.
I introduced a friend’s kid to basic the other day. She’s about 9 and was already getting the idea of an input, making some decisions and writing an output. Even with that just being text she was excited, and was already having her own ideas what to do next.
I failed my school computing class assignment in BASIC because instead of making the word game I spent all my time labouring away chasing the visual appeal of getting BASIC to draw a fancy intro screen.
I ended up working in computer graphics :-)
I agree with your sentiment re: scratch though. With scratch I struggle to pull kids away from the drawing and asset selection tools. I’d like scratch without this.
Why not both? My Atari 800 came with a BASIC and a Logo cartridge. Logo was the thing that got my attention first because it could draw pictures on a TV screen right away, but writing BASIC programs and storing them on a cassette tape was the thing that got me hooked for life.
Most BASICs had some primitive form of Logo language "on board". You send DRAW commands in strings e.g. "r90 f100". Clearly not as nice as having Logo installed on your computer.
The Apple II had single-pixel and line drawing with absolute coordinates. There was a clever “shapes tables” thing that was used to draw images on screen (I used it to draw text with nice looking proportional fonts)
I think we’re making things much too easy. Kids like challenges. my 6 year old can spell plenty of words. A 9 year old can definitely memorise PRINT, GOTO, INPUT and SLEEP.
The problems they solve sure aren't easy. I myself found it challenging to build a robust platformer character with wall jumping and enemy collisions and things. Zac and I both had quite different solutions, and Zac did some further research on youtube for a much better solution that both of us had.
When I was in high school (around 2000) they had three CS courses that kids could take - the first was in QBasic, the second was in Turbo Pascal, and the third was in C++ for the AP CS exam.
Ours also had Fox Pro, and we did all of them (one per year). They also had optional Novel, Linux, UNIX and Mac courses (with certifications). Late 90s - early 2000 were a hoot.
Yep, BASIC bootstrapped my programming interest even as late as the late 2000s. School library was ancient, the only programming books were on BASIC and internet access was limited. So I got started trying to use those to learn this: https://justbasic.com/ (surprisingly, updated even up till 2018, and the paid version updated just a few months ago).
As a clueless, overly ambitious 12 year old I was a massive annoyance for the skilled users on their forums, I remember getting ranted at for wasting people's time with stupid questions, writing awful code, not understanding licenses etc, but it was a pretty good entry point until I managed to get my hands on books for more modern languages.
AFAIK, my highschool still is offering BASIC in their intro CS curriculum. It's just so accessible and many of us preferred it over Python for intro classes
QBASIC and the printouts I could get of fanzines or Pete's QB Site kept me engaged in programming throughout middle school. I moved ok to VB 5/6 in high school and began my career making all kinds of small apps and utilities for people and companies.
Certainly did mine. I credit my career in programming to an after-school class in programming BASIC on the TRS-80 when I was in middle school, and then the TI-99/4a I had at home when I was in high school.
I even used BASIC professionally for a while in the 1990s.
Most people think of one of the MS BASIC dialects when they think of BASIC (at least in the US). The original Dartmouth BASIC had matrix primatives, including MAT READ, MAT PRINT, MAT INPUT, and functions like MAT A=INV(B) (yes, matrix inversion), MAT A=BC, MAT A=B+C, MAT A=B-C, MAT A=B(2) (scalar mult), MAT A=TRN(B) (transpose), MAT A=IDN(5,5) (5x5 identity matrix), MAT A=ZER(5,5) (zero), MAT A=CON(5,5) (fill with 1.0).
I cut my teeth on Wang 2200 BASIC, which was an extended Dartmouth BASIC, so it had the above MAT statements, but also a bunch of wild ones that did searching and sorting on arrays, merging two sorted arrays into a sorted output, and more.
Here is a statement that searches a character array A$() in columns 1-5 for a string in Z$: MAT SEARCH A$()<1,5>,=STR(Z$,1,5) TO B$ STEP 5. Every match writes the location to a descriptor array (this case B$), where each pair of bytes was the offset in the A$ array where the match was found.
Despite all that power, it still was quite limited: all variable names had to be a single letter or a letter and a digit. All variables were global. GOTO and GOSUB were either the line number or a "label" where the label was one of '0 to '255. Strings were statically allocated, not dynamic, and the max length was 64 characters (BASIC-2 extended that to 126 bytes). On the other hand, before the program started running everything was allocated there was no possibility of memory overflow during runtime, and no garbage collection, and any references to missing line numbers was caught up front.
Having QBASIC right there and available to play with was my introduction to programming as a curious 11 year old.
I remember reading every topic in the help browser over and over looking for how to write to the screen, because I didn't want my first program to waste paper with the PRINT statement.
One section of the manual told me to use labels instead of old fashioned line numbers, but I could never figure out the syntax to GOTO them. So I kept a nice index card with line number ranges for all the functions in my program. It worked great until I had to spend a day debugging a line number that ended with O instead of 0.
It was always a big mystery why renaming my program from .BAS to .EXE didn't let me click to run it like other programs.
Ahh, BASIC. I still consider it a bit of a naughty language.
When I first learned to program as a child, it was in Pascal (on a mainframe... microcomputers were barely a thing back then). Our instructor expressly forbade us from learning BASIC because "it would teach us bad habits".
That which is forbidden becomes attractive, of course, so a bunch of us kids started getting together on our own and we all learned BASIC on the sly. It felt so... wrong... and delicious. Forbidden knowledge is fun knowledge.
That's how BASIC became the second high level programming language I learned.
I read a book called A People's History of Computing in the United States, which wildly oversells itself, it's just a history of Dartmouth Basic and the culture surrounding it.
But even then it was very interesting! The philosophy was that anyone could program, and they really did build a culture of amateurs writing programs that answered their own needs. The author has access to a lot of ephemera from that time which gives some flavor of what it was like in the lab.
And then, BASIC culture spread by unlikely methods, like the Pillsbury Dough company. No, really. For whatever reason they got involved allowing local schools in the midwest to time-share with their big mainframes.
I have a great appreciation for BASIC, being the first language I was exposed to both at home on my Atari 400 and in school on TRS-80 and Wang computers. Since then I went through various machine/assembly languages, C, C++, Pascal, and modern procedural languages.
Lately I spend most of my time writing less-procedural code on procedural languages. Eliminating the step-by-step 'time' element and mutating variables is the best way I know to make more comprehensible software.
Just because computer hardware executes step-by-step in time, doesn't seem like a strong enough reason to learn programming this way. I'd really be curious what would happen if programming (not 'computers') were taught more transactionally with defined inputs, outputs, and a mapping definition that gets coded with intermediate expressions rather than time-varying data building. Basically, instead of starting with for/if/etc then eventually finding filter(predicate), map(function) start with them. There's a bit of learning curve up-front, but it seems flatter from there compared to all the accidental complexities created with the other approach. The first-class function aspects can even be bypassed by only using anonymous block syntax for a long time.
Is there a semi-popular introductory language that is more based on (or can use) immutable data and mapping expressions? Even for my own use, I can't really find much more approachable ones than Kotlin/Java/(Gleam?), F#/OCaml/Elm for statically typed ones. For dynamically typed languages, the close ones I can think of are Ruby and Elixir.
Happy birthday to the language that got me into software. Admittedly, BASIC as a language was quite limiting, and, well, basic. At least the flavor I was using. I made quite a few rudimentary games on my dad's old TRS-80 Color Computer, and eventually learned C because of it. BASIC may not be the greatest language power-wise, but it damn well may be the greatest just because of how iconic and important it was to the programming sphere as a whole.
BASIC was my first programming language. Of course I abandoned it for Fortran, C, C++, etc. But when I was considering developing D, I thought about string manipulation. It was so easy in BASIC. Why was it so terrible in C and C++? So, so many bugs in string manipulation code. So much time spent on it.
A major goal of D was to have strings work like in BASIC. And they do! Very happy about that. Thank you, BASIC!
My introduction to programming was with Integer BASIC on the Apple II. I was about 7 years old at the time and was hooked instantly. From there, I moved on to Amiga AMOS (also a basic), Pascal, C, and so on...
Given the state of the field these days though, I can't help but wonder if I should have gone into some other line of work instead.
I’ve been trying to teach my (admittedly pretty young) kids Lua and I have to say BASIC is just a lot simpler to understand when you don’t know anything about anything.
MAI Basic Four was one of the business software platforms for small businesses in the 1970s. MAI sold it as a turnkey solution including the computer which was a rebadged Microdata 1600. It was almost a BASIC machine the way Lisp machines were Lisp machines: all application level code, including that used for system maintenance, was written in BASIC.
The dialect was one of many called "Business BASIC", which basically extended normal BASIC with COBOL-like capabilities like better string handling, decimal math for currency handling, and ISAM-like file manipulation. It allowed for developing the same kinds of applications as COBOL while having a nicer development environment than COBOL.
The major accounting suites for small business of the 1970s, MAS 90 and MAS 200, were written in Basic Four BASIC. A lot of applications were. Other dialects, like Pick BASIC, supported business applications as well. All of these were much more fully featured than like Microsoft BASIC on Commodore/Apple/Tandy machines. Those were toys in comparison to minicomputer BASICs.
Basic Four itself shipped on some microcomputers like the Tandy 2000. Compatible environments came out for PC, including AB86 for DOS, Thoroughbred/OS, BASIS BBj, and ProvideX. Keeping those old systems running on newer hardware was an enticing business, just like for COBOL programs.
Based on my limited exposure to "professional" software in the BASIC era... some pretty good stuff was a hybrid of BASIC and assembly language, leveraging the best of both (BASIC was pretty good at laying out screens, input fields etc, at least on the Commodore PET, whereas hand-coded assembly language had the code density and speed).
Was it a "toy" language? Sure. I once implemented a non-scrolling toy spreadsheet program with it - just a fixed grid of cells - with some simple formula capacity and a manual "recalculate" trigger. Was that educational? You bet. Was it sophisticated? Not really.
But I'll bet there were absolute tons of one-off business applications written in it. A simpler version of what Excel was used for later, and still is. And scientific calculations? If Fortran could do it, BASIC could. Until something better came along to replace both.
Were there many complex programs written in BASIC? Or was it largely a teaching tool?
People who weren't old enough to be in business remember BASIC as something from their home computers, but BASIC was integral to many businesses in the early years of general purpose computing.
There were plenty of business programs written in BASIC, and part of its appeal was that any business owner with a little time could learn how to customize those programs to suit their particular business' needs.
BASIC wasn't just for homes and home computers. Virtually every computer or computing device produced in that era had BASIC available for it, and for good reason. It was quick to learn, versatile, and when you knew the basics on one system, you could use that knowledge on other systems.
BASIC was available on machines ranging from $250 to $200,000 or more. There wouldn't be BASIC on $50,000 machines if there wasn't a demand for it.
My memory is a bit fuzzy on this specific, but I'm pretty sure that HP had a computer that came with both BASIC and AP/L. Nobody was using that machine in their homes.
It depends on what you mean by "BASIC". Nobody in that world cared much about portability or standardization, so the language had a protean quality; every vendor offered their own flavor, tailored to the needs of its platform. The variant you used may well have been a mere teaching tool, but there certainly were other dialects which served as serious application development platforms.
I was a big fan of BASIC when I was young, and that led to spending the early portion of my career working on a series of BASIC compilers, all of them intended for complex software development. Two of them still sort of exist, in much-mutated form; one is now called "Xojo", and the other is Microsoft's rather-better-known Visual Basic.
Right. Still remember the day in college when I booted up my Radio Shack Micro Color Computer (MC-10) and someone exclaimed excitedly, "it has Microsoft BASIC."
At my first job, our order entry system was written in BASIC. The second version of the system was written in QBasic. I wrote lots of test and demo code in the language. We used it in all our manuals, since it was the one language that we knew our customers (mostly engineers and scientists) would be able to program in.
I started writing a spreadsheet in BASIC, but never finished. I wrote a couple of simple games in it also.
There are more, but I've forgotten about them.
Now, if we expand the definition to include VisualBASIC, then the amount of production software written in the language explodes into at least 100,000 programs.
MAI Basic Four Inc. was a relatively succesful computer manufacturer that sold business computers that used BASIC as the development language for business applications: https://en.wikipedia.org/wiki/Basic/Four
> Were there many complex programs written in BASIC?
I don't know generally, but I worked in housekeeping at a large hotel for a few years in my younger days, and the software they used to track the rooms was in interpreted BASIC.
I didn't know that until my manager started cursing because the software broke. When I looked at the screen, the error message syntax was clearly that of BASIC. I just typed "RUN" at the prompt and everything worked again. She thought I was a genius.
Also "awfully basic" compared to what? For me it was the first exposure to programming, period, and totally got me excited. Heck, back then even programmable calculators were exciting. There was just this hunger to program something, anything.
I was recently playing a commercial Atari game from 1981 called "Ricochet" that was written in BASIC, which came on a cassette.
Atari BASIC stored its programs in memory using a tokenized format - it did syntax checking when the line was typed in, and then the tokenized form was stored to save memory. There was a table of variable names, indexed by token. So a quick and easy obfuscation technique was to overwrite the variable names with something like just carriage returns, so that when you LISTed the program it had no variable names and lots of extra line breaks.
As I recall, at least. Haven't reinforced those memories in a while.
I am curious how do you write software that takes a day to run. Today I can write line by line, and because computers are so fast, even "long" tasks complete/crash fast enough for me to iterate. I assume you had test cases but I still want to know.
Do you mean how do you write something that takes that long at all? By having data that takes that long to process.
If you mean the actual accomplishment of it in general:
1. Get a subset of data that lets you create a representative set of test cases. You can validate your code in minutes, not hours or days. Then you run it on the full thing once you've seen that the 5-minute job works as expected.
2. Sacrifice a goat, pray to hopefully the right god, and hope it wasn't their son from a goat mother that you sacrificed.
3. Spend a lot more time thinking before doing.
4. Read a lot.
(1) works if you can run the task on your own system or have access to a system to run it on. This is the best option, or some variation on it.
(2) is unfortunately what happens a lot, they usually sacrifice the wrong goat and end up cursed instead of blessed.
(3) and (4) are the next best option after (1), and should be done alongside (1) anyways. The system I'm on now is legacy and being upgraded. The test bed is available to me maybe 1 hour a week right now because everyone needs it and everything is urgent, apparently. I spent a lot of time reading the code, the documentation, and thinking about how to structure my solution to a problem our users have. My first pass validated the solution concept and took 3 days or so of thinking hard about the problem and 5 minutes of coding. The second pass is more robust (error handling) that took several more days of reading and thinking to identify what error cases could even occur, and two hours of coding.
Yeah, if I could run it locally I probably could have finished it all in those first 3 days (honestly my 5 minutes of coding was figured out by the end of day 1, but I wasn't certain since I was new to the codebase). But when that's not an option, you spend more time thinking about the problem you're solving and the problems your solution will generate so you solve it before you run it in the first place.
It's Turing complete.. and my apple II library had all sorts of crazy apps written in basic. I remember taking them apart when I was like 10.. and being like who has the time to write all these lines! Which.. I still think is crazy considering no IDE and how you would just input them line by line... leaving space between lines just in case you needed to put a new line in later.
When using line numbers you wouldn't go from 1 to 2 to 3 etc, but from 10 to 20 to 30 so that you can always insert a line (e.g. 11) between 10 and 20. After a while when the numbering became to messy, you'd issue a RENUM command to renumber the entire program, e.g. RENUM 10 would make the first line 10, and then use increments of 10 for subsequent lines. At that point you start over by re-inserting new lines between the others.
Lots and lots of BASIC was used in production for routine IT-ish tasks at the dawn of the personal computing era. It was the only meaningful way to implement custom tasks until the mid-80's when environments like Turbo Pascal showed up. For years and years technically-savvy small businesses were buying Apples and PC's and then writing their own BASIC to glue together whatever automation they needed.
Was much commercial software written in BASIC? (Edit, because this is being misunderstood: I'm not talking about the evolved BASICs being pushed by the late 80's, only about the ones like Applesoft and GWBASIC the commenter is asking about) No, very little. As you point out BASIC doesn't offer much to developers who already understand a macro assembler. But the market was much bigger than that.
> Was much commercial software written in BASIC? No, very little.
There was a huge amount of commercial software written in BASIC dialects such as classic Visual Basic and ASP, Pick/BASIC, HP Business Basic, Wang 2200 Basic, DEC BASIC-PLUS, etc. Boring business software you would likely have never heard of but which was (and in some cases still is) essential to running all kinds of different businesses.
I used to work for a university and both the student administration system and the accounting system were off-the-shelf software, mostly written in VB6 and classic ASP (I believe the vendor also had some COM components written in C++, they had their own app framework, but the business logic was all VB6). At the time, we were waiting for the vendor to finish porting it to VB.NET. 20 years later, it probably still is in VB.NET.
FWIW those are all third generation "structured BASIC" languages, not what I understand the upthread commenter to be asking about. Obviously you can evolve the syntax into a more popular language, and Microsoft did to great effect. But that's not the BASIC that was "taught in school in the 80's".
> FWIW those are all third generation "structured BASIC" languages, not what I understand the upthread commenter to be asking about.
They weren't. Many minicomputer BASICs of the 1970s and early 1980s, such as Wang's, lacked those structured programming features you are talking about, at least originally. They were classic GOTO/GOSUB line number spaghetti code. And huge amounts of business software was written in them.
Some of those apps still run today, because the languages have been ported to Windows/Linux/etc. And eventually, just like Microsoft did, they added a lot of those structured programming features. But sometimes you'll find pre-structured spaghetti-style code surviving long after the dialect gained the ability to do better.
Suffered from a few very large non-starts in attempting to port it all to browser-agnostic JS and other frameworks by offshored teams. Couldn't capture the same UX and layouts; too much proprietary business logic in the background that less and less people have knowledge of. Unconvincing demos, bad sales, sunk cost. Good guess.
Lots of commercial software was written mainly in BASIC. Plenty of games (a couple popular examples are Temple of Apshai and Questron, but there are certainly hundreds, particularly if you look at educational games of the 80s). And a lot of productivity stuff was written in BASIC, like database management (e.g. APX Data Management System - lots of the APX titles were written in BASIC), accounting (early versions of the very popular Peachtree accounting software), and even tax software (early versions of TaxCut).
> Had some similar capabilities as COBOL without the IBM tax.
COBOL never had an "IBM tax", because almost every non-IBM vendor had a COBOL compiler. If you didn't want your COBOL from IBM, you could buy it from DEC, HP, Wang, Unisys, NCR, Honeywell, Microsoft, Micro Focus, Watcom...
That said, if your COBOL was running on an IBM platform, you often were using lots of IBM proprietary features (e.g. CICS) which made it hard to port to another vendor–and that could indeed be an "IBM tax". But that's wasn't due to COBOL in itself. If you limited yourself to standard COBOL, and avoided IBM proprietary stuff, moving your COBOL app to another vendor didn't have to be difficult
BASIC attracted business users because it was viewed as simpler and easier to learn, because it could run on smaller machines, because (often) using an interpreter instead of compiler resulted in faster development (no edit-compile cycle).
> A free copy of DEC's original COBOL compiler for the VAX can be found in the VMS 1.0 image at this site:
Where? I don't see any VMS 1.0 image linked to on that page.
Instead I see instructions to join the HP OpenVMS hobbyist program, which no longer exists, in order to install OpenVMS 7.3 on an emulated MicroVAX.
There is no longer any hobbyist program offering legal access to VMS for VAX. HP's hobbyist program was terminated and replaced by VSI's, which never included VAX (and more recently they appear to have dropped Alpha and Itanium, making it x86 only). Licenses to legally run VMS for VAX are very limited (e.g. maybe buy a used MicroVAX or VAXstation which comes with a VMS license)
> technically-savvy small businesses were buying Apples and PC's
The outfit I worked for at the time sold directly into this area. We had a product line of simple I/O modules for physical automation (measuring temperatures, controlling motors, etc...) and all our programming instructions and examples were given in BASIC because it was on all computers and it was the one language that we knew everyone would be familiar with.
VBA was used for tons of enterprise applications in the late '90s and early oughts. The implementation in things like Excel was surprisingly powerful and they had to sort of dial it back because they realized it was a huge security risk. (You could open up a spreadsheet that was a powerful virus.)
In the '90s when we were developing a 3D game (in C++) I made an early iteration of the level designer in VBA on Excel. You would color cells in a spreadsheet and then hit a button, and the button would output a text file that told the game engine what mesh or object to put where. Terrible way to do it, but a great way to work fast in those primitive days.
People still use VBA all the time. I think of it differently than the basic language of the 80s or even the more powerful commercial compilers used by some today like PowerBasic. VBA is just so highly tied to Excel. There is a new way to also script Excel with some kind of typescript. It's built into the latest version of Excel and seems to be more straightforward.
At this point, I think there are multiple sufficiently general-purpose languages bolted onto Excel if you have 365 (sadly enough, I work at a place with LTSC) - Power Query, the array language subset of Excel's formula language, Python, Office.js, VBA. But if you're collaborating with people I think you only predictably have VBA.
I still have nightmares about having to write the Validation procedure documents for a medical device production Quality system written in VBA/Excel. The program had started out as some scientist's desktop tool and somehow over the years, morphed into an actual production tool that now needed to be formally validated since we needed to make a change to it. Worst combination of spaghetti code and Big Ball of Mud that I've ever seen. I had the misfortune of being the only SW dev who was senior enough to do the task and who wasn't busy at the time, so I drew short straw!
I shudder to think of the millions of dollars of product that have been shipped as a result of that code!
Yes there were very serious software written in different Basic dialects.
One that I was interacted with was a CAD software written in QBasic. It was about civil engineering and static analysis tool for concrete buildings. You could export projects to dxf format so you could import into AutoCad to fix bugs and plot.
Funny how the name was MGCad and author insisted it stood for MegaCad. I suppose It was a nice coincidence that the Author's initials were MG :)
I seem to remember some pretty serious (as in actual paid) programs written in QuickBASIC - the compiled version of QBASIC.
Lots and lots of 'business middleware' was written in various forms of BASIC, the most famous being VBA, but also quite a bit in things like QuickBASIC in an older period.
I wrote a document management system in VBA for Word for a law firm I worked for in the late 1990s. Created a unique filename for new documents, stored and retrieved, maintained an index of titles, etc. We replaced it a year later with a much better system, but it was a valuable stopgap for something we desperately needed.
We had a version of Bomberman that was written in some version of BASIC in high school (maybe QBasic?). It was great because we could hack on it to modify the game and immediately play with those modifications.
In elementary school my uncle gave me his old LASER 286S. It was too old for all the games my friends played so I mostly just farted around in QBasic all day.
I really wish I still had that system and all my BASIC scripts but those are long gone.
My start to programming was accidentally signing up for a class in high school that taught Turbo Pascal (1995). I then starting playing on my TI-85 (TIBASIC) and then bought a friend's old 286 and started hacking around in QBASIC. That unlocked a memory from when I was elementary school in the early-mid eighties and we did some programming on an Apple (II I'm guessing), writing BASIC, early enough that line numbers were still required.
I learned to program with BASIC. My first program was one to balance my Dad's checkbook. I copied it from a manual and added some extra PRINT statements for flair. I was in 4th grade. It was on a Timex Sinclair. Then I tried to draw a smiley face and ran out of RAM -- it only had 1K.
Learning QBASIC with assistance from my dad on our family Tandy PC when I was 4-6 years old was a major driver for my career in technology later in life. Who else remembers the simple game Gorillas that came with QBASIC with its source code visible to read? That was a key inspiration for some of my early programs.
An interesting aspect of this is why there wasn't a BASIC on the Mac early on (save for an text-based version offering from Microsoft which barely allowed writing to the screen):
Microsoft didn't understand GUIs yet. Amiga BASIC was also written by Microsoft and the GUI support is also limited. Apple didn't create a BASIC for the Mac because was into Pascal and had used it for the Lisa OS and apps. Much of the Lisa code was reused in the Mac OS.
>Donn was making good progress and looked to be on track to ship in early 1985; we were excited to show the world what Basic should really look like on the Macintosh.
>He knew that Donn's Basic was way ahead of Microsoft's, so, as a condition for agreeing to renew Applesoft, he demanded that Apple abandon MacBasic, buying it from Apple for the price of $1, and then burying it.
I bought Microsoft's BASIC for the Mac, and it was a waste of money, and I'd've much rather had Apple's based on my reading of the books which were published about it despite it not having been released save as a beta:
I recall using TrueBASIC on the Mac in the early '90s, and IIRC, it had already been around for a while. It was a nice, structured dialect that didn't rely on line numbers.
Apple Logo->Commodore BASIC->Fortran->Pascal->PHP->Java->VB6->.NET...and other modern things.
...With scripts of various types mixed in there. But BASIC is what got me hooked. Being able to write my own games on the Commodore 128 was fantastically addicting. Leaving demo store Commodore's flashing background colors with POKE 53281 and looping around felt like I was the king of the world.
What was really great with BASIC on computers like the C64 or C128 was that the barrier of entry was so low. It was just there, it was the shell. So you might as well try that
I've never heard of the original BASIC being compiled in any way, JIT or otherwise. Far as I know, the most it did was tokenize keywords into one or two bytes, something every other BASIC interpreter took up as a matter of course.
I've never heard of the original BASIC being compiled in any way, JIT or otherwise. Far as I know, the most it did was tokenize keywords into one or two bytes, something every other BASIC interpreter took up as a matter of course.
There were dozens and dozens of BASIC compilers available, for all kinds of platforms from Commodore 64's to mainframes.
Having grown up in the 8-bit era with Apple IIs and C64s and various weird Z80 boxen, I can tell you for sure BASIC did not normally get compiled on those platforms. Tokenized, yes, but nothing more than that. Dartmouth had more to work with even in the 60's so it doesn't surprise me they wrote a static compiler for it, though it's still news to me.
Apparently people can't read, as I explicitly mentioned 8 bit home computers were the ones responsible for people thinking BASIC was originally interpreted.
Unless I've misread the code (and it is 134 pages of assembly with comments so I'll admit that's possible). The first 68 pages are the compilation process and a bunch of constants and things. That completes execution before RUN begins. RUN executes the compiled program by, on page 73, jumping to address P (07724) which is where the compilation routine has built out the object program. At that point execution is inside the object program unless there's an interrupt or a subroutine calls to one of the built-in subroutines.
I don't think this compiler is just a pre-processing activity.
As a language, it's very low-level. It has nicer syntax than assembly had, and is relatively portable, but the concepts are all really close to the metal.
That depends a lot on the implementation. Global scope certainly wasn’t the only scope for all of them: dialects such as AMOS on the Amiga had procedure level scope as well. BBC BASIC definitely had DEF PROC but I can’t remember whether it supported different levels of scope.
Which were created decades after the original versions and are only identifiable as "BASIC" in that they share a few keywords like PRINT and FOR...NEXT.
The later "structured BASIC" dialects resemble more COMAL than traditional BASIC.
> I explicitly mentioned that 8 bit home computers were the ones to blame for the fame of BASIC being interpreted, and unstructured.
Interpreted yes, unstructured no. Dartmouth BASIC was unstructured until 7th edition (1980). The home BASICs started coming out before then and could fairly claim their unstructured nature as a consequence of the contemporary, to them, Dartmouth BASIC.
If you look at the BASIC that's 60 now, you won't see a lot of the features that appeared later in SBASIC (in the late 70's) and on dialects from Dec, IBM, Nixdorf, and others. In 1964, it was a very simple language with the impressive feature - and this is the most important ergonomic aspect - of allowing interactive exploration.
Original Dartmouth BASIC is a thing of beauty. Simple enough to learn in an afternoon, but powerful enough to do useful (and fun) things, from numerical computation to games.
And it wasn't just the BASIC language (and its compiler) that made it so effective, but the entire system: a remotely accessible, timeshared/multiuser, interactive environment.
The idea that every student (including humanities and social science majors) could learn how to program (and be given computer time) seems extraordinary and inspiring. The idea that computing could be useful and important outside of science/math/engineering departments was also visionary (probably going back to LISP - note John McCarthy organized the first AI workshop in 1956 at Dartmouth.)
That's amazing. Of course the Casio might have been more powerful than the original machines that FORTRAN was designed to run on (IBM 704 etc.) Also: no punched cards.
A big chunk of my job was doing tedious manual edits in the guest management software that tracked who was in what room, what phone and pay-per-view charges they'd racked up, etc. It occurred to me to peek at its database file and see if I could pull any useful data out with automation. The DB turned out to be a flat file of fixed-length records. The DOS PC had a copy of QBasic on it and I used a bunch of trial and error to map those records to types, and then I could loop across the records to get interesting data out of them.
Long story short, I ended up with a system we'd run nightly to correct misspellings, build reports of which companies did the most business with us and how recently, identify regular guests who hadn't been around in a while, and a thousand other little things that made my job much more pleasant and my boss extremely happy.
It would be much easier to recreate that program today in a nicer language. I didn't have a nicer language available, though, and while it wasn't pretty, QBasic got the job done.