Hacker News Reader

Comment by pjmlp | Hacker News Reader

Happy birthday BASIC!

A short reminder that the original Dartmouth BASIC was actually JIT compiled, including while using the REPL.

And most big iron OSes like VAX/VMS had proper compilers.

It was due to the 8 bit home microcomputers that it got the fame of being interpreted, as naturally there is only so much that fits into 16 - 64 KB.

View on HN

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.

Microsoft BASIC Compiler for IBM: https://archive.org/details/stx_Microsoft_BASIC_Compiler_Fun...

Convergent BASIC Compiler for the Burroughs B20: https://archive.org/details/bitsavers_convergent0BASICCompil...

BASIC compiler for Burroughs mainframes: https://archive.org/details/bitsavers_burroughsS00InternalMe...

http://dtss.dartmouth.edu/scans/BASIC/BASIC%20Compiler.pdf

Dartmouth BASIC was compiled.

Compiled can mean many things. For instance it can mean that only the parsing is done at compile time, leaving the rest for runtime.

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.

I always thought that was called "pseudocompiled" or "semicompiled".

Which is in fact the original BASIC.

+1 for linking to a scan of the compiler source (and object!) code (note the 20 bit instruction words for the 1964 GE-235?)

That was how 8 bit home computers worked.

Dartmouth BASIC always compiled the code before execution, just like Lisp.

> Several versions were produced at Dartmouth, implemented by undergraduate students and operating as a compile and go system.

https://en.m.wikipedia.org/wiki/Dartmouth_BASIC

The historical video also mentions this at some point.

https://www.dartmouth.edu/basicfifty/basic.html

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.

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.

Which meant a quite good performance, in a memory managed language, and ability to do systems programming.

There was nothing missing in VMS Basic, Turbo Basic, QuickBasic, DevPac BASIC, that would make me reach out to C.

On my Apple II's (with AppleSoft BASIC) I missed proper functions and the ability to use a stack. Recursion was next to impossible to express.

Yeah, but that was a 8 bit system, not what made BASIC in first place.

8-bit computers were pretty important for the widespread adoption of BASIC. For most of them, BASIC was the OS shell.

Moving goalposts, I explicitly mentioned that 8 bit home computers were the ones to blame for the fame of BASIC being interpreted, and unstructured.

Dialects like VMS Basic predate them.

> 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.

Ignoring mainframes during the 1970's, predating home micros.

Why don't you actually read my comments fully?

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.

http://www.bitsavers.org/pdf/dartmouth/BASIC_Oct64.pdf

https://support.hpe.com/hpesc/public/docDisplay?docId=emr_na...

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.)

The BASIC version that run BBC Micro had proper functions and subroutines with local variables (I think it even had recursion, but I'm not 100% sure).

AFAIK, all Microsoft BASIC (of which AppleSoft BASIC was a descendent) versions did not have the above until QBasic.

It did have recursion.

    >LIST
       10PRINT FNFACT(6)  
       20END
       30DEFFNFACT(N) 
       40IF N=1 THEN =1 ELSE =N*FNFACT(N-1)  

    >RUN
           720

Thanks for letting me know, BBC BASIC was indeed advanced for the period.

Structured programming was not easy.

You didn't have functions, you had GOSUB to a line number, which was just a slightly glorified GOTO. There was one global scope.

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.

Yeah, if you ignore the BASIC dialects that actually provided such features.

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.

https://en.wikipedia.org/wiki/COMAL

Again, ignoring mainframes during the 1970's.

VBA in Excel is only 4 times slower than C, I think (if you do typed code).

Also proper VB used the same backend as Visual C++ since version 5.

BASIC was largely a simplified, interactive FORTRAN.

Fortran is still used today, as it has a large software base of computation kernels and also lends itself to efficient compilation.

It is relatively easy to port Fortran 77 code to BASIC. I did that in college to run “FORTRAN code” on my Casio BASIC “calculator”.

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.

Reply on news.ycombinator.com