Forgot your password?
typodupeerror
Programming

50 Years of BASIC, the Language That Made Computers Personal 224

Posted by timothy
from the goto-10*5 dept.
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."
This discussion has been archived. No new comments can be posted.

50 Years of BASIC, the Language That Made Computers Personal

Comments Filter:
  • by Bill, Shooter of Bul (629286) on Tuesday April 29, 2014 @11:41AM (#46868609) Journal

    I mean Basic isn't difficult either, but I really don't understand the perspective at the time that FORTRAN was so complex that BASIC and COBOL were really needed for their syntax changes alone. All of the explinations I've read about them, invariably have the line somewhere about FORTRAN being so difficult to understand that only scientists could master it. I understand they were all invented for different problem domains and that's kind of a good reason in and of itself, but sheesh, its not like it was brain fudge.

    • by Brett Buck (811747) on Tuesday April 29, 2014 @11:56AM (#46868819)

      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.

               

      • I haven't seen a way to use BASIC- in the way it was originally conceived - in 25 years.

        To be fair, a lot of people were still using VB6 for Windows frontend programming as recently as 10 years ago. Now it looks like it is finally dying off, although I'm pretty sure a lot of legacy projects are still in use.

        • VB.NET is still very much alive.

      • > I always found BASIC to be far more irritating to program in anything more than trivial applications.

        Which version? It makes a huge difference.

        Sadly, many people think of BASIC as the early Apple, and MS, BASIC. Far better versions of BASIC have been available, for decades now.

      • by Darinbob (1142669)

        BASIC really took off when it was ported to microcomputers. On a minicomputer like at Dartmouth it was just one of many languages, and wasn't even the only interpreted language. However most languages were still rapidly evolving at the time and there was a lot more experimenting going on. The intent of BASIC though really was to be a "beginner's" language, for the undergraduates rather than grad students. At the same time it was introduced when time sharing was brand new, so the idea of interacting dire

    • by flyingfsck (986395) on Tuesday April 29, 2014 @11:57AM (#46868825)
      No, it is more a case that access to any computing resources was very limited. Twenty years later, universities still had old time sharing machines running Fortran and BASIC that first year students trained on and COBOL, while PL1 on Sperry-Univac machines was the new thing for the seniors. A typical university only had two to four computers in total. I also started by learning BASIC with punch cards on a mainframe, since that was the only thing that was available. The small computer population explosion only really happened in the 1980s.
    • by Jahta (1141213) on Tuesday April 29, 2014 @12:04PM (#46868895)

      Ob. quote from Real Programmers [mit.edu].

      "Real programmers don't write in FORTRAN. FORTRAN is for pipe stress freaks and crystallography weenies."

      Of course, it also says this about BASIC :-)

      "Real Programmers don't write in BASIC. Actually, no programmers write in BASIC, after the age of 12."

    • by tangent (3677) on Tuesday April 29, 2014 @12:11PM (#46868965) Homepage

      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.

      • That's all very useful information, thank you for sharing that. It doesn't change my opinion really as I've worked with early FORTRAN, but its pretty interesting for those that were not aware of that history.

    • Re: (Score:3, Informative)

      by jellomizer (103300)

      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 som

      • I can't speak to Fortran, having no direct experience with it, but every Cobol program I saw in the youth of my career was interpreted. I administered a multiuser Cobol-based accounting system on a Xenix box in the early 1990s (still probably the best accounting program I've ever seen, BTW), and it was was all i code that ran on a Cobol interpreter. I imagine that for most of Cobol's history the majority of its software has run this way.

        • by mwvdlee (775178) on Tuesday April 29, 2014 @12:58PM (#46869415) Homepage

          I stopped programming COBOL about 5 years ago, after having professionally used COBOL for about 13 years.
          I've never even encountered a COBOL interpreter; it was all compiled.

          IMHO, interpreted COBOL makes no sense at all; you use COBOL because you want raw performance.
          If performance isn't top priority, you'd be better off using Java, C++ or most other languages.
          Perhaps if you need backwards compatibility for obsoleted hardware running legacy code.

    • by MightyYar (622222)

      It's not so much that FORTRAN was horrible, but AFAIK it did not lend itself to a simple interpreter and so the gratification was not instant. Compiling is an extra step and it is not a fun step. In addition (again relying on very faint memory), BASIC had easier string-handling functions built in until FORTRAN77 - and most of us were dealing with strings when we were learning to program.

    • by RabidReindeer (2625839) on Tuesday April 29, 2014 @12:34PM (#46869191)

      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.

    • by hey! (33014) on Tuesday April 29, 2014 @01:23PM (#46869681) Homepage Journal

      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.

    • FORTRAN at the time had string handling capabilities that sucked so bad, they caused local black holes. Not a problem for techies solving differential equations, but somewhat more of a problem for business and hobbyists (the latter of whom often fancied imaginative string handling to create the illusion that the computer was actually holding a conversation).

  • by DiscountBorg(TM) (1262102) on Tuesday April 29, 2014 @11:41AM (#46868617)

    I grew up with a little TRS-80 on which you had to learn BASIC to so much as load a file. In Grade Three I was learning things like coordinate geometry and algebra, while my peers were struggling with their multiplication tables. I remember when my peers were introduced to algebra for the first time, some of them had difficulty understanding how x could be a number, while I was busy making adventure games at home.
    Thanks to this head start in life, I now have a job in IT. BASIC gave me a great head start in computer literacy!

    • Re: (Score:2, Funny)

      by bluefoxlucid (723572)
      It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration.
      • Thanks. I was waiting for a Considered Harmful joke.
      • That isn't true.
        The CS 101 Class should have components about following up structure. Give assignments where the students may need to build off their code, if they start doing it the BASIC Way make assignments that shows how much harder it is to maintain over time. I went into CS with a Strong knowledge in BASIC, it was actually very helpful. As the other students were struggling with Loops and getting the darn thing to work, I was focusing more on trying to follow the guidelines for style and seeing if

        • by DiscountBorg(TM) (1262102) on Tuesday April 29, 2014 @12:24PM (#46869093)

          I agree, but this is actually an old tongue in cheek essay, in context it makes more sense perhaps:

          "FORTRAN --"the infantile disorder"--, by now nearly 20 years old, is hopelessly inadequate for whatever computer application you have in mind today: it is now too clumsy, too risky, and too expensive to use.
          PL/I --"the fatal disease"-- belongs more to the problem set than to the solution set.
          It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration.
          The use of COBOL cripples the mind; its teaching should, therefore, be regarded as a criminal offence.
          APL is a mistake, carried through to perfection. It is the language of the future for the programming techniques of the past: it creates a new generation of coding bums."

          http://www.cs.virginia.edu/~ev... [virginia.edu]

        • by Sarten-X (1102295)

          Sure I got the talking to when in a lecture I brought up using a GOTO to solve a problem. However that was about it.

          Crappy professor.

          GOTO is a perfectly reasonable solution for a very small set of problems. Dijkstra's famous essay has a less-famous rebuttal (that I'm far too lazy to find at the moment), with which Dijkstra agreed: Code should be readable first, well-formed second, and functional third.

          Using a GOTO is usually only functional. It doesn't preserve the structure of the code like the two ends of a loop, and being one-ended, it's not easily followed when reading. Other mechanisms are usually better.

          However, in

          • Re: (Score:3, Insightful)

            by z80man (3532145)

            Every processor I've ever used has a "JUMP" op-code, synonomous to the "GOTO" statement. If its good enough for the processors machine code, its good enough for me :-)

      • I learned to program on 8 bit computers (Tandy and Commodore), all of which were running BASIC interpreters, and I had no problem moving on structured programming like Pascal, and ultimately OOP languages like Java.

      • /sarcm Riiiiiight, because programmers "never" dissect and disassemble Basic to see how it was implemented, learning such topics as Taylor Series,Horner's Evaluation for Polynomials, learning how to use memory-mapped IO, to learn how parsers work, or any other advanced topic in interpreters.

        Guess what, a great programmer is STILL great in-spite of or independent of brain-dead languages, such as Basic or Javascript. At the time Basic freed programmers from the mundane and tediousness of assembly language.

    • It's different when you cover algebra before you hit programming.

      Algebra teacher: "X + 1 = 2X. Subtract X from both sides. X = 1."

      Me: "OK"

      BASIC program: "X = X + 1"

      Me: "No, it isn't!"

      Me, years later, in a class using Prolog: "X = X + 1"

      Prolog interpreter: "No, it isn't!"

  • by Captain Emerald (2882375) on Tuesday April 29, 2014 @11:46AM (#46868687)
    10 PRINT "Happy Birthday, Basic"
    20 GOTO 10
    • by Toad-san (64810)

      Throw in a counting loop (1 to 50 .. or 0 to 49 if you wish), just to show off your l33t skills.
      Make it 0.0 to 49.0 if you want to test your math coprocessor at the same time :-)

  • by serviscope_minor (664417) on Tuesday April 29, 2014 @11:48AM (#46868725) Journal

    The BBC Model B equipped with BBC BASIC was released in 1981. As well as the usual litany of BASIC like features (i.e. goto), it had proper named procedures and functions with local variables, which allowed structured programming. It didn't have proper block structured if though.

    It also had dynamic memory allocation and pointer indirection (not that wretched peek and poke stuff).

    It was still tied to line numbers though, but in practive you (a) didn't need them except for computed goto and jump tables and (b) it had a proper renumbering command if you needed to insert space which corrected all the gotos, gosubs and jump tables (but not obviously computed goto).

    It had a 5 byte floating point system build in too, which while slow was pretty decent.

    Was quite powerful. It also had graphics and sound built in, which made it very nice to play with.

    And then I graduated on to QB when I switched to a PC. Mostly QBasic then a pirated version of QuickBasic. Actually my dad was very against piracy but relented when we phoned a Microsoft sales office and they denied all knowledge of such a product and tried to hawk us an early version of Visual Basic.

    QBasic was a fantastic system, especially given it was free with PCs, and I challenge anyone to claim otherwise with good justification.

    • by Jahta (1141213)

      The BBC Model B equipped with BBC BASIC was released in 1981. As well as the usual litany of BASIC like features (i.e. goto), it had proper named procedures and functions with local variables, which allowed structured programming. It didn't have proper block structured if though.

      Yes indeed. I initially learned to program on a BBC, and I learned a number of good habits in the process.

      • You both forgot to mention the BBC had a built in 6502 multipass assembler.

        So unlike my spectrum I didn't have to reload the assembler every time I made an error and my code stomped all over ram.

        Additionally, you had direct access to OS routines from basic, OSBYTE, OSWORD, OSCLI etc.

        The BBC was and still is far ahead of anything else as a teaching machine. Simple enough to understand, complex enough to be useful and enough I/O to put a pi with gertboard to shame even today.

        • You're absoloutely correct. It did have those and it was awesome. It meant you could freely mix ASM and BASIC code. Handy so one could do inner loops in ASM and the more complex outer logic in basic without sacraficing anything. I seem to remember that the special variables A%, X% and Y% would be used to set the A, X and Y registers on entry and be set back on exit for easy communication.

        • by Jahta (1141213)

          You both forgot to mention the BBC had a built in 6502 multipass assembler.

          So unlike my spectrum I didn't have to reload the assembler every time I made an error and my code stomped all over ram.

          Additionally, you had direct access to OS routines from basic, OSBYTE, OSWORD, OSCLI etc.

          The BBC was and still is far ahead of anything else as a teaching machine. Simple enough to understand, complex enough to be useful and enough I/O to put a pi with gertboard to shame even today.

          Good point. The built-in assembler was excellent too. The whole BBC Micro project was designed educate people about the computer as a powerful tool they could use, and not just a games machine. And, as you say, they did a damn good job.

  • by null etc. (524767) on Tuesday April 29, 2014 @11:50AM (#46868751)

    Richard Garriott (of Ultima fame) is running an interesting challenge to port his very first RPG computer game, written in BASIC on a teletype connected to a PDP-11, into a web-friendly or Unity version. https://www.shroudoftheavatar.... [shroudoftheavatar.com]

  • by Baldrson (78598) * on Tuesday April 29, 2014 @11:54AM (#46868793) Homepage Journal

    If IBM had gone to Chuck Moore [slashdot.org] instead of Bill Gates (or rather, his mom) for their 4.77MHz 8088 PC, your title might have been "50 years of FORTH, the Language That Made Computers Personal".

    But, then again, if IBM had done that, the personal computer era might have been bypassed entirely with the network computer launching the equivalent of the WWW in 1983 [slashdot.org].

    • by westlake (615356)

      If IBM had gone to Chuck Moore instead of Bill Gates (or rather, his mom) for their 4.77MHz 8088 PC

      Microsoft was selling microcomputer BASIC to Fortune 500 clients as early as 1976. It became the most visible --- and the most successful --- developer of programming languages for the micro in the eight bit era and well positioned to move into system software and applications.

      • by Baldrson (78598) *

        No doubt BASIC was the path of least resistance, but if you click through my link to 1983, you'll notice that Smalltalk was positioned to execute on a FORTH stack VM which was then reduced to hardware in the Novix chop. Moreover, the technology you see in the Javascript V8 engine had already been published in relation to Smalltalk in 1983.

        This was technically feasible at that time. The fact that it wasn't the path of least resistance hardly qualifies BASIC for the credit accorded it by the title of this a

        • This was technically feasible at that time.

          How much did Smalltalk cost and what were the hardware requirements?

          During the late 1980s to mid-1990s, Smalltalk environments ---including support, training and add-ons --- were sold by two competing organizations: ParcPlace Systems and Digitalk, both California based. ParcPlace Systems tended to focus on the Unix/Sun Microsystems market, while Digitalk focused on Intel-based PCs running Microsoft Windows or IBM's OS/2. Both firms struggled to take Smalltalk mainstream due to Smalltalk's substantial memory needs, limited run-time performance, and initial lack of supported connectivity to SQL-based relational database servers.... While the high price of ParcPlace Smalltalk limited its market penetration to mid-sized and large commercial organizations, the Digitalk products initially tried to reach a wider audience with a lower price.

          Smalltalk [wikipedia.org]

          • by Baldrson (78598) *

            The reason I promoted Forth as a graphics communications protocol alternative to NAPLPS is the Western Electric Videotex terminals for the Viewtron service were so limited in RAM and ROM (far more limited than the first 4.77MHz IBM PC) that it needed a highly compressed representation of the firmware for decent graphics performance. Forth provided that and it would have further allowed dynamically downloading tokenized Forth stack functions (called 'words'). I talked about this with the guys at PARC late

  • Text.

    Long before Lisp or Perl, Basic made things much, much easier to deal with text.
    C (and its children) had pointers and allocation to deal with.
    Cobol, Fortran and Pascal, by default, dealt with fixed-length strings (yes, later versions improved it).

    On the Digital operating systems (RSTS, RSX, VAX/VMS -- whose technology ended up influencing WinNT), BASIC was relatively sophisticated, long before Visual Basic: explicit variable declaration, access to database routines, etc. I got a LOT of stuff done wher

    • by sribe (304414)

      Long before Lisp or Perl, Basic made things much, much easier to deal with text.

      Ahem, Lisp predates BASIC by 6 years...

  • I bought a VIc-20 in 1982 to use in my woodworking business. I learned BASIC on it by trying to key in the Tank vs UFO game that was printed in the manual. I don't know if it was all of my typos or errors in the printed listing (both likely), but through debugging that ASCII character game, I got started in the direction that took me to working in IT.

  • LISP instead! (Score:3, Insightful)

    by Anonymous Coward on Tuesday April 29, 2014 @12:22PM (#46869065)

    Lisp was invented in 1958. Can you imagine a world were personal computers had Lisp instead of BASIC? We would have had the singularity the year after IBM released the AT!

    • by istartedi (132515)

      I think it's more likely that only a few people would have cared for it. Of those few, an even smaller few would have written something like a BASIC interpreter in Lisp and sold it separately.

      Either that, or they would have sold poorly until somebody came out with what we got, which was PCs that shipped with BASIC.

      I recall reading a review of one of the less popular systems at the time. The reviewer said something like, "it comes only with assembler, which is useful only for understanding how a computer w

    • (I ((am not) so (sure (about that))), (you (may (rest assured) (that (at (some point)) (someone (would have (forgotten (a closing (or opening) bracket)) ... ) ... )? ...

      oh fuck, let's start counting... one open, two open, three open, two open...

    • by xanthos (73578)

      LISP - Lots of InSipid Parenthesis

    • by Darinbob (1142669)

      Lisp had gone through a lot of experimentation, and it really didn't settle down until what we recognize as Lisp until later. Lisp 1 was somewhat crude. Lisp 1.5 was a lot nicer but still clumsy. MACLISP really made things a lot more modern but that wasn't until 1966 I think.

      • by Darinbob (1142669)

        Oh and the big difference I think, is that BASIC was explicitly intended for all the students and faculty at a liberal arts university, whereas Lisp was initially intended for mathematicians and researchers at a science and technology university.

  • by coolmoose25 (1057210) on Tuesday April 29, 2014 @12:43PM (#46869277)
    I started working on computers in the early 80's... The first one I used was a TI 99 4a. It had tape drives and a TV set as a monitor, and a horrific keypad (note: not keyboard). Then my brother got a PC Jr. and I started hacking with that and then went off to college. As an engineering major, I learned FORTRAN on punched cards. I hated it! Swore I'd never have a job where I used computers.

    Then my brother got the family to chip in and buy me a Tandy 1000a. It came with DOS, Deskmate, and Basic. I started programming in Basic using the concepts I had learned in FORTRAN. By the end, I think I had dumped about $5,000 into that computer. Printers, memory upgrades, floppy upgrades, hard drive, monitor, etc. And still was able to do amazing things with Basic and with BAT files.

    My first job was with Arthur Andersen. COBOL. Batch COBOL. 2.5 years of it. Learned it in 6 weeks, and spent the rest of my career there either coding it or writing tech specs for it.

    Went to work at an insurance company coding SqlWindows, a now obscure 4th gen programming language. But hey, it was Windows programming. Spent 10 years there in a variety of roles.

    After that I set up my own web development shop... Wrote classic ASP which is essentially Basic for the web. And then went to work at another insurance company, writing, you guessed it, Microsoft VB.net. Granted, VB.net was a far cry from the original basic, and probably would have been better off learning C#. But that was Microsoft's strategy with .Net - recycle old VB programmers and old C programmers using the CLR. At the end of the day, not much difference between C# and VB.net. Now I don't code anymore, I'm a VP at that insurance company. But I owe a lot of my career for having a tool like Basic available to me in my formative years. Sure, it teaches you some bad coding habits. But just like anything else, you learn from that, and others, and classes (and objects for those who like puns). Those who say that you can't be a good programmer after having learned basic are either elitist snobs or idiots. Sometimes you have to do it wrong first to see how doing it right makes all the difference. So Happy Birthday Basic - I love ya' baby.
  • I would have liked to hear from Ric Weiland but it's not possible since he died in 2006. He was responsible for the BASIC that I learned on: The Microsoft BASIC-in-ROM that came with my family's Ohio Scientific Challenger 4P (a 6502-based system from 1978 that had hardware similarities to Commodore systems). It also featured the first "Easter Egg" I remember: The system's boot prompt was "C/W/M?" (i.e. cold boot, warm boot, monitor). If you selected "A", it responded with "WRITTEN BY RICHARD W. WEILAND."

    • by Dadoo (899435)

      I recognize that message. I have one of those in my garage and, the last time I checked, it still worked. I finally wrote an emulator for the thing, copied the roms to a modern computer, and play with that, occasionally.

  • by mark-t (151149) <markt&lynx,bc,ca> on Tuesday April 29, 2014 @01:07PM (#46869499) Journal
    Basic was my first programming language, and I actually spent almost 10 years using it before moving onto more structured languages like C, but it wasn't too long after I learned Basic that I found that my favorite features of the language were the ones that enabled me to extend it with my own customizations, which I would have to write in assembler. If I remember correctly, the relevant basic keywords in the implementation that I used were 'usr' and '&... practically turning it into another language with all of the extensions that I would throw in.
  • by bill_mcgonigle (4333) * on Tuesday April 29, 2014 @02:36PM (#46870595) Homepage Journal

    editors:

    s/University/College/

    (hoping that wasn't an editorial 'correction' since TIME got it right)

    Also, there's a party [dartmouth.edu] all day on campus tomorrow.

  • It was Conways Game of Life recently explained in Scientific American Mathematical Games. I wrote it on a teletype (text terminals awaited cheap 512-bit ROMs for character sets in 1975) connect from my school to a local university computer (PDP-8?). Numbered lines were convenient in early BASIC when you could only edit one line at a time. The output was an asterisk and blanks grid. I think the printing took about 30 seconds which was longer than it took to compute the next generation. I found a listing a
  • There's still something awesome about the idea of sitting at a Teletype Model 33ASR playing Star Trek. Yes, you'd go through a lot of paper, but it was still fun. Of course what was even more fun was a version of BASIC I had on my 2nd computer, which allowed for INPUT statements that had a timeout feature on them. I was then able to write a version of Star Trek that would have the Klingons be able to attack you if you sat at any command prompt too long. Added an entirely new element to the game, you couldn'

All life evolves by the differential survival of replicating entities. -- Dawkins

Working...