Talk:BASIC/Archive 1

BASIC's (former) great popularity

 * BASIC was at one time the world's most popular programming language,

When and reference ? --Taw 01:48, 1 May 2002 (UTC)

"Most widely distributed"

 * However, the Visual Basic programming language and its close relatives, which have diverged greatly from the original BASIC, are probably the most widely distributed languages in the world today due to their inclusion in every major Microsoft Office application, so BASIC's influence continues to be strong.

This sentence make no sense. First, being "the most widely distributed" is of no importance as compared to be language where actual programs are made, and second - Javascript is much more "widely distributed" than Basics thanks to webbrowsers. --Taw 01:48, 1 May 2002 (UTC)


 * Its clearly nonsense. The most realistic measure is number of active programmers, for which Basic in all forms is probally the most popular. The difficulty lies in measuring the number of programmers, attempts at which have failed. The most common attempt is "number of web hits" which simply gives the language that people are talking about right now, not necessarily using. By any estimation, Basic is runaway popular for small and demo programs.--Samiam95124 01:37, 17 Jun 2005 (UTC)

Scorned by professionals

 * Despite its popularity, BASIC has been scorned by most computer professionals since shortly after the development of the first version. The disdain comes from the misconception that BASIC is a "slow interpreted unstructured language". However the first version of BASIC, Dartmouth BASIC, was not interpreted, and not particularly slow. All versions of Dartmouth BASIC and its direct descendants have been compilers, as are many modern dialects.

This is clearly anti-antibasic and not npov. If you think that majority of computer scientists are "misconcepted" you have to prove it. Quote from Jargon, which explains some issues:

BASIC /bay'-sic/ n. A programming language, originally designed for Dartmouth's experimental timesharing system in the early 1960s, which for many years was the leading cause of brain damage in proto-hackers. Edsger W. Dijkstra observed in "Selected Writings on Computing: A    Personal Perspective" that "It is practically impossible to teach good     programming style to students that have had prior exposure to BASIC: as     potential programmers they are mentally mutilated beyond hope of     regeneration." This is another case (like {Pascal}) of the cascading {lossage} that happens when a language deliberately designed as an    educational toy gets taken too seriously. A novice can write short BASIC programs (on the order of 10-20 lines) very easily; writing anything longer (a) is very painful, and (b) encourages bad habits that will make it harder to use more powerful languages well. This wouldn't be so bad if historical accidents hadn't made BASIC so common on low-end micros in    the 1980s. As it is, it probably ruined tens of thousands of potential wizards. --Taw 01:48, 1 May 2002 (UTC)


 * Anyone claiming that their favourite language is faster or that someone else's is slower should post timings of the same algorithm written in both languages. Otherwise such discussion generate more heat than light. Kjwhitefoot 10:57:49, 2005-08-29 (UTC)


 * The idea that "Basic ruins programmers for futher work" is attributed to Dijkstra. It isn't proven out by any actual studies, likely because the comment was bombast and not meant to be factual. Basic makes it easy to enter programming. It is also easy to LEAVE Basic and advance to better languages. All this makes Basic a great introductory language. Why this translates to scorn is beyond me, and I suspect a mystery to most reasonable people. --Samiam95124 20:36, 20 October 2005 (UTC)


 * It isn't even borne out by Dijkstra's article in which he made a facetious comment about every major language current at the time bar his own favourite, Algol 60. -- Derek Ross | Talk 06:07, 12 November 2005 (UTC)


 * People can learn bad programming habits in any language, not just BASIC. The large number of buggy, bloated commercial programs written in C by professionals is proof enough!  Quicksilver 19:56, 11 November 2005 (UTC)


 * Intellectual snobbery, plain and simple. Xcrivener (talk) 18:03, 23 August 2010 (UTC)


 * The reputation comes entirely from its common implementation as an interpreter. Aside from that, even a compiled Basic is not going to be fast, because users are encouraged to use strings for everything, which is not going to result in the best code. Nobody seems to care that Basic is slow, look at VB's lack of a compiler.--Samiam95124 01:41, 17 Jun 2005 (UTC)


 * VB Does not lack a compiler. VB6 is compiled using the same back end as Microsoft C++. Kjwhitefoot 10:54:41, 2005-08-29 (UTC)

Mainframes

 * The false reputation for BASIC's slow performance may be tied to the GE FORTRAN compiler for that hardware which placed the startup code at the beginning of the runtime tape and the shutdown code at the end resulting in an empty FORTRAN program taking a very long time to run. Dartmouth BASIC has never had this problem.

I seriously doubt it has anything to do with some mainframes. Basics for PCs are also very slow. --Taw 01:48, 1 May 2002 (UTC)

Speed of basic compilers

 * Since the early days of the personal computer, BASIC compilers, some of them generating code as fast as the fastest versions of Pascal and C, have made a comeback; but despite the addition of structured programming capabilities, their reputation remains.

Really ? Which basic compiler makes code "as fast as the fastest versions of Pascal and C" ? That would be very interesting to know. --Taw 01:48, 1 May 2002 (UTC)


 * PowerBASIC makes a BASIC compiler which outputs code with speed comparable to that of code output by fast PASCAL or C++ compilers. Don't know how it would compare with the fastest versions though. -- Derek Ross 14:38, 10 June 2002 (UTC)

"Best-selling"

 * Some versions of the best-selling Visual Basic product line are also compiled, although Microsoft has altered Visual BASIC into a language minimally compatible with even early versions of Dartmouth BASIC.

"best-selling" ? That's enciclopedia, not an ad. --Taw 01:48, 1 May 2002 (UTC)


 * "Best-selling" is a fine adjective for an encyclopedia article, especially when it had at some points in history as much as 70% of the market of all implementations of the language. It should be put back, because this statement is a simple, accurate statement of historically important facts (and I'm typing this on my Linux machine, so it's not because of any pro-MS bias on my part). -- LDC 02:12, 1 May 2002 (UTC)


 * Well, we can objectively state that by just giving exact figures, of course if there is such thing as "exact figures" in software, what I seriously doubt. --Taw 02:26, 2 May 2002 (UTC)

Unstructured program example origin
Re the unstructured star program...

Question: What is the origin of this program? I recognize it, and seem to recall typing it in sometime in the early 1980s from a book by TAB publishing.

— Preceding unsigned comment added by 63.106.72.133 (talk • contribs) 03:13, 1 June 2002

Bad programming habits
Could someone please give examples of the sort of bad habits that BASIC encourages in newbie programmers? --User:Juuitchan (208.58.249.223) 23:24, 11 June 2002 (UTC)


 * I think that the two main problems that led Dijkstra to his famous comments were
 * BASIC did not have proper function/procedure definition facilities, fully formed IF/THEN/ELSE or WHILE structures and therefore it was easy to write malformed code since one had to use GOTO quite often and it is difficult for a newbie to decide whether its use is properly structured or not.
 * Unlike other languages of the time, BASIC had a built in IDE and was intended for use directly on the computer. This was more likely to lead to "code first, think later" behaviour or even "code, test, code, test... " behaviour (no thinking involved) compared to other languages and that type of behaviour mostly leads to poor programs.
 * Point 1 doesn't apply to modern versions of BASIC and point 2 applies to just about all modern programming languages, so Dijkstra's comments, although understandable at the time, no longer have the same force. In my opinion, a modern BASIC like QBASIC is no more likely to lead newbie programmers into bad habits than any other language. --Derek Ross 02:50, 12 June 2002 (UTC)


 * Gotos, gotos, gotos, and maybe gotos. Largely erased from modern implementations, I say we let Basic off this particular hook, goto only Basics have been dead for a while.--Samiam95124 01:43, 17 Jun 2005 (UTC)


 * Try using DASM on an average program and, lookie lookie, one third of all the CPU insturctions used are JUMPs, which are GOTO equivalents. The only diffirence between BASIC and all those other programming languages is that in BASIC, you can choose to do plenty of GOTOs, while in all the other programming languages, the compiler just does it for you... So much about BASIC being the cause of bloated programs.--DustWolf 15:43, 14 December 2005 (UTC)


 * I'd argue that it's less the problem of GOTO, more the wierd "line number" based format of a lot of primitive (low-RAM, etc) BASICs. QBASIC doesn't get around the issue so much by deprecating GOTO as obsoleting (though not necessarily removing) line numbers and out-and-out linear programming (introducing C-like modules, etc). Most BASICs did have reasonable IF/THEN/ELSE capability (though the ELSE was implicit rather than explicit --- e.g.
 * 120 IF K>9000 THEN GOTO 310
 * 130 REM The 'else' code goes here, i.e. the action to be taken if the value stored in variable K is 9000 or less.
 * 140 PRINT "This will be an easy victory..."
 * 290 GOTO 120
 * 300 REM This return is of course optional... think of it like a musical score, almost
 * 310 PRINT "That's not possible!"
 * 320 REM The above is the code for what happens if K is over 9000.
 * And of course it could even be contained in one line - 100 IF L$="Y" OR L$="y" THEN GOTO 200: IF L$="N" OR L$="n" THEN GOTO 300: PRINT "Sorry, please enter (Y)es or (N)o.": GOTO 90
 * Which will bump the user to line 200 if they answer Yes, line 300 if they answer No, or print an error message and loop to the input prompt line on any other answer, the colons effectively taking the place of ELSE statements.
 * BBC (Acorn) BASIC is a nice example of an early BASIC which tried to do away with some of these contraints, with GOSUB/RETURN and (IIRC) DEF SUB (jump to *named* subroutine, and escape it, returning to the previous point in program control flow regardless of where the GOSUB or the subroutine were, and allowing several references to the one subroutine from multiple places without having to resort to quite Heath Robinson multiple-goto/variable based returns) and FN/DEF FN arguments that allowed use of non-line number and non-goto based jumps. However its main structure was still line number based, and still allowed use of GOTO.
 * Additionally, it is still not that bad a thing - it merely makes some routines quite verbose in this language, and makes editing a potentially quite longwinded and error prone process... for example if you needed to insert a small section needing 11 lines of code in between line 130 and line 140... with other parts of the program referencing line 140, rather than some named marker. I think Sinclair BASIC had a function ('renumber'??) to try and sidestep some of the issues (by re-labelling each line to start on a multiple of 10, and presumably fixing any GOTOs that referenced it), but otherwise, you'd then be in a nightmare of spaghetti code and misplaced jumps, and having to rewrite large parts of it just to deal with a small insertion & line number alteration. I suspect low-level Assembler is just as bad, but at least then it has an excuse ;)
 * Also it didn't preclude planning. In fact any decent BASIC program would need a fair bit of it due to some of these issues, and the fact that good programs rarely write themselves. The best I ever managed without putting something down on paper was an experimental multi-part QBASIC program on a 486 that was reminiscent of a demo from 1983... no real structure, just random very simple built-in effects and silly minigames. Even trying to get textmode Space Invaders off the ground required a quick plan-out on paper - it never would even have got to its abortive peak (one alien... then the computer on which that copy of GWBasic was installed broke down) otherwise. My father even wrote several quite complex games using Sinclair BASIC on the 48k Spectrum, and somewhere all his paper notes and handwritten proto-code is stored up... Having seen whole, decent quality commercial platform games written in STOS BASIC on the Atari ST, it's maybe not so much the quality or structure of the language as a whole that gives it a bad name, as the fact that it's easy to pick up (but like so many things difficult to master) - STOS in particular as it had several utilities for inserting graphics and music - and so attracts a lot of complete, untutored beginners, who pick it up as they go rather than absorbing any best practice. Sort of like allowing new drivers out on the road in limited performance Microcars without any lessons or testing... the cars themselves will become a byword for dangerous, untutored driving and habits, even though a competent driver would be perfectly safe and find it an adequate vehicle for shopping and commuting even if not for intercity travel.
 * Note from the BBC Basic thing above... you could still implement something similar to the GOSUB system using GOTO anyway, it would merely involve a lot of forward planning, and use of variables to store where the program flow had jumped from, and therefore where it should jump back to (i.e. using LET to store the line number or other mnemonic reference in the variable, then a load of IF/THENs to return to a given line depending on what the variable said (or even using GOTO, if the version of the language allowed it)). Byzantine and longwinded, easily confusing and hard to edit, but operable. As demonstrated with purposefully obfuscated languages such as Intercal and Befunge, you can carry out pretty much any task of a higher language (and wider instruction set) with very few base operators, enough thought, and enough programming/processing time. Everything else is basically a shortcut or a macro to make things easier and quicker, rather than more possible... such as GOSUB being a macro for the above process, or the more refined structures of professional languages (which also often have the benefit of e.g. more memory and more sophisticated IDEs) being macros for the programming process and planning/thoughts themselves.
 * (any innaccuracies or falsehoods above are due to me pulling this stuff from memory and not having any BBC or Sinclair references available to crib from without going for a potentially lengthy websearch - even if the terms are wrong, the ideas are valid so far as I know)
 * 82.46.180.56 (talk) 16:16, 12 April 2008 (UTC)

BASIC tutorial
I wonder why I do not see anything like a manual of BASIC functions here. Would a BASIC tutorial on Wikipedia violate anyone's copyright? --User:Juuitchan (208.58.249.223) 23:24, 11 June 2002 (UTC)


 * My understanding is that another Wikimedia project, Wikibooks, is better than Wikipedia for things like programming language tutorials. Perhaps you could help write Wikibooks:Programming:BASIC ? --68.0.120.35 16:37, 2 May 2007 (UTC)

Compiled/interpreted
History paragraph 3: Does anyone have a reference stating that BASIC started out as a compiled language? I've never heard that one before. Rlee0001 08:24 Jul 25, 2002 (PDT)


 * Jean Sammet (History of Programming languages) discusses this. Admittedly that book is hard to find now.--Samiam95124 20:42, 20 October 2005 (UTC)


 * Just for an explanation, that at the time BASIC was made, it wasn't made specifically for the concept of interpreter or compiler, so you have some characteristics of interpreters and some characteristics of compilers. Hence you are unlikely to come accross a book saying "BASIC is a compiler-driven language".
 * For one, the program first needed to be written down in a memory area, and then the RUN command executed, which included no debugging engine, and all of the BASIC instructions pretty much were (alternate names for) CPU instructions. That is Very simmilar to the way Intel uses microcode to execute normal instructions in their CPUs. And since binaries running on Intel processors are not considered to be interpreted (in the programming language sense), you can pretty much say that prefomance-wise BASIC was a compiler-driven language, even tho in all theory, it would probably still be an interpreter-driven language.--DustWolf 15:56, 14 December 2005 (UTC)


 * . I have come across a book saying "BASIC is a compiler-driven language". It was written by Kemeny and Kurtz, the inventors of the language. It is called Back To BASIC: The History, Corruption, and Future of the Language. It explains how the very first version of BASIC (Dartmouth CardBASIC) was used before the Dartmouth Time Sharing System was ready. BASIC programs had to be entered on punch cards and fed into a punch card reader at that time. They were then compiled and executed.
 * The book explains that once DTSS was introduced it was used to write the programs and RUN various different compilers (not just BASIC). When you typed RUN (which was a DTSS command, not a BASIC command), the DTSS would pick the correct compiler for the job -- ALGOL, FORTRAN, and BASIC were all available -- and compile and execute the program. BASIC was most definitely a compiled language until the introduction of DEC BASIC which was an interpreter. -- Derek Ross | Talk 20:13, 14 December 2005 (UTC)

Dialect links and upper case BASIC
I'm going to move the dialects in such a way that they are all suffixed with "programming language" for consistency as described in talk:programming language. Furthor, I propose that the acronym "BASIC" be capitalized consistently in all the dialect pages. Anyone have any objections? Rlee0001 00:12 Jul 29, 2002 (PDT)


 * Seems like a good idea to me. Jeronimo 00:20, 29 July 2002 (UTC)


 * I disagree. While the core BASIC language is properly all caps, the case does matter for product names. Therefore, it's valid capitalize in HP BASIC but not for HTBasic. ^_^ Of course, this could just be lingering bias from workin case-sensitive languages like C... Sean Duggan 11:02 Dec 07, 2004 (EST)


 * Sean Duggan is 110% right, of course (how can this even be discussed... beats me). There are also some BASIC dialects where the dialect name is capitalized as well, such as ATARI BASIC (see, for example, De Re Atari, Ch.10). --Wernher 19:01, 7 Dec 2004 (UTC)

Article deterioration?
The first time I read this article back in 2001, it was incomplete but reasonably accurate. Looking at it in Summer 2002, I find it larger but much less accurate. There seem to have been a lot of myths and half-truths added to it. For instance the original Dartmouth BASIC was a compiler, not an interpreter. From a fairly early stage, it included proper procedures and function based on the FORTRAN ones, not just GOSUB and RETURN. There are other examples like this. Someone has written that most languages don't differentiate between procedures and functions. Really ??? Well that certainly hasn't true for most of the last forty years that BASIC has been around and even if it has become true lately, it hardly seems to be relevant.

When adding to the article, please act as if a lot of what you know about BASIC history is actually untrue. Even if you are sure of a fact you should check it before adding to the article, particularly if it conflicts with what already exists there. That way we may end up with a collection of facts rather than a collection of nonsense. -- Derek Ross 16:23, 3 August 2002 (UTC)


 * Derek, I'm not an expert on the subject but I am one of the people who have been contributing to the article including some of the things that you are pointing out. Just as a matter of curiosity, are you sure that the original BASIC would have been a compiled language used for timesharing systems? That doesn't make sence. I've used some later (~mid-70s) time-shareing systems and the BASICs that were used were all interpreted. As you point out, IDE commands like LIST, NEW and SAVE are part of the language -- but how could a compiled language possibly have built in IDE commands? Furthor, why would you ever used a compiled language on a time-sharing machine? It seems that after you transmit the source tape into the machine, there would be a huge "compiler" overhead in terms of CPU time, before the program was ever executed. Or are you saying that the tape would have contained the binary of the compiled source? In which case the source still would need to have been compiled by the machine seperately. It just seems that timesharing and compiling doesn't mix well. I'm not saying your wrong or anything, you seem to know a lot more about it then I do. I was just curious. Also, I've read in several texts that basic is in fact the most popular language in existence.
 * http://www.digitalcentury.com/encyclo/update/BASIC.html
 * The above even mentions that the language was not only based on FORTRAN, but also on ALGOL. It also says that the language as it was originally created, allowed students to edit the program using an IDE, where commands could be executed immediately. That doesn't sound very compiled to me. I realize that the article in the URL above does state that the language was compiled. It just doesn't make sence. Enless only some of the commands were compiled where the IDE commands were not? I don't know. Anyways, I just wanted to let you know that I did do some research and that I had no intention of upsetting you view of history.
 * I used BASIC on a LEASCO time sharing system in 1969, there was nothing interactive about our use of it, we punched the source onto 8 bit paper tape and submitted the job to the remote data centre a 100 miles away. Whether it was compiled or not I don't know for sure but we were billed in CPU seconds and even very long jobs cost very little so i suspect that it was.  In fact our principal cost was the long distance telephone call (300 baud acoustic modem).  Might be able to find the reference card somewhere.  Kjwhitefoot 11:03:49, 2005-08-29 (UTC)


 * I know it's difficult to believe but Dartmouth BASIC was compiled. Every time the user pressed return after typing in a line that single line was checked.  If it didn't have a line number it was compiled and then executed in the current environment.  If it had a line number it was compiled and added to the list of compiled statements.  This is known as incremental compiling and it's routine in a time sharing environment nowadays although it was pretty revolutionary in 1964.  Paper tape just didn't come into it.  You could use paper tape to submit a program but you didn't have to.  Like you I've used mid-1970s mainframes for BASIC programming and I know that not all BASIC translators were compilers but I can assure you that the Dartmouth one was, just as it says in the article you referenced.  Re the other points about "most popular" -- that's probably true --; FORTRAN plus ALGOL -- that should be added to the article.
 * Finally please don't think I'm getting at you. I'm glad that someone is interested enough in BASIC to want to write about it.  But I'll still bring up or change things I think need correcting.  Just bear in mind that I get corrected all the time too.  It's just part of working on Wikipedia.  :)
 * -- Derek Ross 17:53, 3 August 2002 (UTC)

Altair BASIC origin
195.186.243.65 wrote that:


 * Bill Gates, Paul Allen and Monte Davidoff ported BASIC from public domain sources to the MITS Altair microcomputer

This has been removed because, while it might be true, it's difficult to believe that there was a public domain 4K BASIC around that they could port from. If the sentence can be substantiated, it can be put back in -- Derek Ross 09:19 Aug 14, 2002 (PDT)


 * Dr Dobb´s Journal started as a journal devoted to TinyBasic, a BASIC implementation done in assembler. Somebody might check out old issues and verify if it was public domain at the time and verify the publication date. — Preceding unsigned comment added by 128.214.205.25 (talk • contribs) 14:49, 24 August 2002


 * It is entirely untrue. See the French history of Microsoft and other references. Microsoft developed and ran their Basic on a 8080 simulator running on a PDP-11 before they had access to an Altair at all, and this was in the very early years of the Altair.--Samiam95124 20:47, 20 October 2005 (UTC)

GNU/Fre/Open Source BASICs
Are there GNU BASIC compilers which directly compile to machine language? — Preceding unsigned comment added by 128.214.205.25 (talk • contribs) 14:49, 24 August 2002


 * I found the following (using Google):
 * http://xbasic.sourceforge.net/
 * http://lbpp.sourceforge.net/
 * http://www.sunbeem.net/quickforward/
 * -- Paul Ebermann 01:19 Sep 10, 2002 (UTC)


 * (replies moved to Talk:List of BASIC dialects by platform)

Dartmouth BASIC datatypes
Thanks for the information on Dartmouth BASIC datatypes, User:24.34.212.37, it's always good to have more since it is the BASIC. -- Derek Ross 16:35, 28 May 2003 (UTC)


 * Derek -- I think it's me that you're thanking. (I'm new to this and not quite sure about how to get a link to my name the way you've got one.  If anyone wants to point me in the right direction for some instructions on how to get myself attributed here by name instead of by IP address, email me at .)  I can attest to the fact that original Dartmouth BASIC was compiled.  I wasn't at Dartmouth at the time, but I was later, and I had courses taught by the creators of the language.  By the time I was there, a version called "SBASIC" was in use, which provided structured IF... THEN... ELSE, SELECT... CASE, and some other niceties.  SBASIC was a precompiler for the version 6 BASIC compiler.  The version 7 compiler directly implemented all of the SBASIC improvements.  One thing that was said above that I don't think is accurate is the bit about incremental compilation.  We certainly didn't have incremental compilation on the Dartmouth Time Sharing system in the 1970s.  Nothing was syntax checked or compiled until you gave the "RUN" command.  If you entered text without line numbers, it was interpreted as a system command (e.g. "RUN", "SAVE", etc.), not as a BASIC statement. — Preceding unsigned comment added by 24.34.212.37 (talk • contribs) 18:54, 26 August 2003


 * Well, thanks again, RHS. I'm interested in the history of Dartmouth BASIC and I like to read information like this so that we can make the article's historical section more accurate.  When there is enough, I'd like us to to create a separate Dartmouth BASIC page.  After all it's rather sad that we have a page for other BASICs of limited significance but none for the original. And if we're wrong about the incremental compilation part (or anything else), please change the article to reflect this.
 * Turning to your query, if you want to become a name rather than an IP address, follow these steps
 * Log in via the link in the top right of the screen
 * Fill in the page with details of your name, your nickname and anything else that you want to set.
 * Save your preferences.
 * That gives you a name, a user page which you can use to say a little about yourself (or nothing if you prefer), and a user talk page that other people can use to leave notes for you, ask questions, etc.
 * To sign your name after a comment like this one, you type three ~ signs in a row while you are editing. The Wikipedia server will automatically change them to your user "nickname" and a link to your user page when it saves this page.  If you type four ~ signs in a row, the server will also add the date and time when you made the modification which can be useful to others when they want to know when you asked a question or when you left a reply, for instance. -- Derek Ross 17:01, 27 Aug 2003 (UTC)


 * Thanks Derek, I've created my account, set up a brief user page, added some pages to my watch list, and I'll try to check in every now and then. Rhsatrhs 00:38, 6 Sep 2003 (UTC)