50 Years of BASIC, the Language That Made Computers Personal 224
harrymcc (1641347) writes "On May 1, 1964 at 4 a.m. in a computer room at Dartmouth University, the first programs written in BASIC ran on the university's brand-new time-sharing system. With these two innovations, John Kemeny and Thomas Kurtz didn't just make it easier to learn how to program a computer: They offered Dartmouth students a form of interactive, personal computing years before the invention of the PC. Over at TIME.com, I chronicle BASIC's first 50 years with a feature with thoughts from Kurtz, Microsoft's Paul Allen and many others."
Re:In 3, 2, 1... (Score:3, Informative)
https://www.gnu.org/fun/jokes/... [gnu.org]
Now seriously. Pascal was published some 2 years before Kernighan and Ritchie released their masterpiece. Having the opportunity to have a long look at Pascal and yet coming up with something like C shows a very strong character.
Re:Was FORTRAN really that hard? (Score:5, Informative)
It isn't hard. I think the only issue that anyone has had with it was the column restrictions, and the important development there was interactive computing and a decent text editor, not a new language.
Bear in mind, also, that most people haven't ever attempted to write in original FORTRAN. Most have seen nothing earlier than FORTRAN 77 and that was tremendously easier and far less irritating than FORTRAN IV. I am old enough to have written FORTRAN IV on card decks, the "good old days" sucked for the most part.
I always found BASIC to be far more irritating to program in anything more than trivial applications.
I don't think the language is the problem, it was all other things that where difficult and mostly solved in the 60's and 70's.
FORTRAN is certainly still in use for Real Programming. I haven't seen a way to use BASIC- in the way it was originally conceived - in 25 years.
Re:Was FORTRAN really that hard? (Score:5, Informative)
FORTRAN wasn't the language in 1964 that you think of as FORTRAN today.
Most people's concept of FORTRAN is FORTRAN 77 or its descendants, which was 13 years in the future from BASIC's introduction.
At the time of BASIC's introduction, FORTRAN IV was the current version.
FORTRAN wouldn't be ANSI-fied for another two years as FORTRAN 66, so every version had machine-specific features. Also, because FORTRAN's development was largely driven by IBM until FORTRAN 66, all the non-IBM versions were "nonstandard." Imagine if, today, every computer came with a C compiler and there were no ANSI or ISO standard to constrain its behavior. The last common reference would have been K&R '78.
Another fun feature of early FORTRAN was fixed column layout [wikipedia.org], common among languages invented in the punched card era. That is, you had to do things like start all statements in column 7 or later, because the first 6 columns had other meaning.
Early FORTRANs also had very primitive program structuring concepts, hardly raised from the level of assembly language.
Read through the Wikipedia article [wikipedia.org]. You'll probably be shocked at how primitive FORTRAN was in the early 1960s.
Re:In 3, 2, 1... (Score:4, Informative)
No, it just shows habit. C was descended from B, which descended from BCPL. They just did more of the same, instead of going to someone else's syntax.
And, having programmed in Pascal for 15 years. Pascal as defined was not suitable for large projects, whereas C was. Every Pascal compiler had to have some non-standard add-ons to handle modularity. And they were all different. Obviously, the Borland model came to have the status of a de-facto standard, but that was not till some years later. You could not have written Unix in standard Pascal; it was written in standard C. Wirth acknowledged the modularity failings of Pascal in his Modula language family, but by that time he had missed the bus.
Re:Was FORTRAN really that hard? (Score:3, Informative)
Well there were a few key advantages.
BASIC was an interpreted language, vs FORTRAN or COBOL that required compiling. This gave beginner programmers quicker response in terms of code it run it. vs. Compile find a slew of cryptic errors try to find them and fix and try again.
Secondly BASIC was a line driven language vs. procedural.
10 print "hello"
20 goto 10
yes it created a lot of bad programming habits. But it really explained how the computer processed the stuff better then the procedure. But I am sure some of you taking CS 101 (Those without previous programming experience) often got hung up on function and procedures, loops and nested loops. The BASIC GOTO and if you get advanced use the GOSUB and RETURN makes these concepts easier.
Third BASIC handles free formatting much easier. FORTRAN you needed to follow a Particular set of formatting the first few spaces were reserved for labels or line wrap numbers, limit to 80 columns... In general nitpicking stuff that a started just doesn't want to handle.
As time went on, we really loss the simple computer programming language. BASIC turned to QBASIC then to Visual Basic then to VB.NET which made it a formatted language with all the hold ups the other professional languages has.
There isn't really a good starting language anymore.
Re:I grew up writing games in BASIC (Score:2, Informative)
You had a text editor? Wimp.
Real programmers didn't have editors. If we wanted to change a line in an Applesoft Basic program we either had to type it over or 'List' the line press ESC and up arrow to the line.
Re:Was FORTRAN really that hard? (Score:5, Informative)
FORTRAN isn't that complex. Originally, it only had 7 statements (or was it 10)? The only halfway complex thing about it was the expression compiler parts.
But BASIC had several advantages. It was intended for interactive use, at a time when most FORTRANs were batch-only. It originally only supported a very limited set of variable names like "A", "B", "C", and so forth, meaning that you didn't have to implement symbol table logic, and the associated storages on machines when 16K RAM space might be considered at lot - instead the variable name was the hash code to a value table. Refinements such as the rich set of built-in functions and extensive string services were also later additions.
The original BASIC was so minimalist that even the first effort from Gates &Co. exceeded it. But it introduced a lot of people to "instant gratification" programming, and thus its influence can be felt in many places to this day.
Re:Was FORTRAN really that hard? (Score:5, Informative)
I've actually programmed in Fortran and BASIC way back in the day (late 70s early 80s). From a language point of view early dialects of Fortran (e.g. Fortran IV ca. 1961 and still in widespread use in the 70s) and BASIC were in fact *very* similar. What was different was that Fortran was *compiled* and BASIC was *interpreted*.
It was common until the mid 1970s for Fortran programmers to physically drop off a deck of punched cards at the operator's window. They'd get their results some hours later, if not the next day, after the operators got around to running the job. Most of the time those results wouldn't the desired computation, but a compilation error. So to be productive in Fortran you had to think about your *entire* problem in advance, carefully preparing your deck to get as much as possible correct before handing the job off.
BASIC was an interpreted language initially. That meant you to type in little snippets of your program, even individual expressions, to see how or if they did what was expected. If you typed in a program and there was a syntax error, you'd know as soon as you hit "return". This allowed a more exploratory approach to programming and learning to program. Of course, you could get the *same* interactive experience in a much more sophisticated language by using Lisp.
I started programming in C in the 1980s, and this use-style distinction between compilation and interpretation remained. A full compile and link of our modest application took something like 30 minutes on the minicomputer we were using, which had a clock speed in the single digit MHz range. So we prepared our source changes *very* carefully, and used our down time to read the full 8 volume Unix manual from cover to cover, over and over again. There was something to be said for such an approach to programming, but it was not for the faint hearted.
By the 90s this had changed. Compilers were orders of magnitude faster; you'd actually hit "compile" and *watch* the compiler do its thing. A decade earlier that would have been like watching paint dry. Editors became syntax-aware too, and debuggers went from requiring mad voodoo skills to being interactive and usable by ordinary mortals. So now compilation vs. interpretation is a packaging and runtime issue; there's not much to choose between them with respect to how *hard* a language is to use. Naturally someone who cut their teeth in the modern era look at BASIC and Fortran as they were in the 60s and wonders what the big deal was. But it *was* a big deal, at least for people who weren't going to learn Lisp.