Why did Visual Basic use parentheses for both function call and array access?

Question

In VB both array access and function calls are done with () which makes it difficult to differentiate between those with a quick look. It also makes more nested levels of parentheses like MyArray(GetIndex()) which is much more readable when written as MyArray[GetIndex()]. I don't know about BASIC but it looks like that the same syntax is also used in BASIC

In fact there's no {} and [] in VB either, and other symbols like @, !, #, ~... are also unused, making the syntax very verbose for no reason

Answer 1

In the early days, many machines running BASIC had limited character sets. For example, the stock TRS-80 Model I couldn't display the lowercase portion of ASCII, which omitted curly-braces, tilde, and the vertical bar as well. Worse yet, the character codes that usually map to [ \ ] ^ instead mapped to up, down, left, and right arrow characters!

Reaching further back, EBCDIC didn't have a consistent mapping for square brackets, either. There were many different code pages for EBCDIC, each intended for a different region, language, and/or use case. Different code pages could map square brackets to different code points. As a result, a card deck or paper tape from one machine containing those characters might display them as something completely different on another type of machine.

BASIC's syntax, at least in older versions, is well-supported by an uppercase-only display that supports the most common symbols and punctuation.

Answer 2

I don't know about BASIC but it looks like that the same syntax is also used in BASIC

Because Visual BASIC is a BASIC?

Since the very first days of BASIC, arrays are indexed in parentheses and function parameters as well.

When Microsoft added user defined functions to BASIC (*1), they stayed with the existing syntax. A change in either would mean leaving the realm of BASIC - not to mention breaking compatibility with any existing software and any BASIC examples of indexing and/or function calls.

Visual BASIC is a continuation of MS-BASIC 5.x, aka GW-BASIC and QuickBASIC (and QBASIC) and mostly source compatible with them. It was also QuickBASIC that introduced named functions and procedures, as well as made the GOSUB keyword optional.

It's the same natural way any other BASIC developer went when adding named user defined function. From BASIC 09 (1980) and BBC BASIC (1981) all the way to Super BASIC (1984) and GFA BASIC (1986).

In fact there's no {} and [] in VB either, and other symbols like @, !, #, ~... are also unused, making the syntax very verbose for no reason

What you're calling for is a different language. Languages are (mostly) defined by their syntax, as keywords are rather exchangeable. Maybe you're looking for PASCAL? It was quite popular in the early 80s and uses square brackets for array indexing, for exactly that reason (*2).

It's the basic way of BASIC to use parentheses for arrays and function - and symbols like @, !, # and % to qualify variable types.

---

Some history

Now, going all the way to BASIC's origins, we end with the DTSS running on a GE-200 system. From today's view the GE-200 might be an odd beast, but back in the early days (*3) it's 20 bit words holding 3 6 bit characters weren't unusual. That 6 bit character of course restricted the character set to 64 encodings. In addition, usage of them was highly application specific. For example their COBOL compatible (*4) did support 49 characters including parenthesis, but not square brackets:

On the other hand, their high speed printer did (by default) not provide parenthesis, but square brackets:

(Taken from this scan)

So while it is quite likely that original the usage of parenthesis for index and parameters might have been due the restricted character set of original GE-200 environment, an easy answer can not be given. Though, some information could be gathered by meditating over the original source code.

What is clear is that it was not due some (more or less) standard character set. Especially not ASCII or EBCDIC, as neither of them was already developed and/or available at the time BASIC was defined.

---

*1 - That is beyond the rudimentary support of FN() of earlier MS BASIC dialects.

*2 - Inherited from ALGOL - the very same way C did :))

*3 - I.e. pre /360 designs.

*4 - Yes, COBOL compatible as at the time, there was still haggling about what features are to be included and ho they are to be handled in source. Mainly about I/O handling, including character set (and Hollerith conversion) .

Answer 3

The Minimal Basic Standard, ECMA-55, 1st Edition, January 1978, contains a very limited character set, only upper case, and very few non-alpha-numeric characters (including parenthesis, but no other brackets); certainly not the full ASCII character set.

This is likely due to compromises in the standards committee between corporate implementers of various existing BASIC versions, many of which were earlier designed for input on keyboards that did not support a full ASCII character set (Apple I, et.al.).

For Tiny BASIC implementations, this also reduces the size of the token recognizer.

Answer 4

A number of BASICs from the minicomputer era used []'s for array access. The most notable was HP Timeshare BASIC, which I assume inspired the other versions that used the same syntax. In HP, it was optional, and () and [] were synonymous. By convention, () was used for array access while [] was used for array and string slicing. This was by no means universally used, as one can see in books like What To Do After Hitting Return.

Answer 5

BASIC was originally developed on DTSS, which used Model 33 Teletypes for user I/O. The Model 33 didn't have [] characters, so BASIC couldn't use them.

Answer 6

What a bunch of whippersnappers!

EBCDIC was part of the IBM S/360 announcement April 7, 1964. Basic first ran May 1, 1964. No connection.

While DTSS was a time sharing system, the GE-225 also ran batch programs. My second or third assembly language was VFAP (Valley Forge Assembly Program) on a 225 at the San Fernando Valley State College. And we submitted jobs on cards.

The card punch most frequently used at the time of Basic's inception was the IBM 026. This was developed in the late 1940s. It was originally designed for use with the IBM 407 accounting machine. So the character set on the original 026 did not even include parentheses. (Parenthetically, if you will pardon the phrase, a later 026 version was developed which included parentheses for that newfangled Fortran programming language.)

026 CE manual: http://bitsavers.informatik.uni-stuttgart.de/pdf/ibm/punchedCard/Keypunch/024-026/22-8319-0_24_26_Customer_Engineering_Preliminary_Manual_of_Instruction_1950.pdf

Doug Jones lists a GE card code with both parentheses and square brackets. See: https://homepage.divms.uiowa.edu/~jones/cards/codes.html

I really think that those were developed for the later time sharing machines (e.g. 415, 635). But I never used these in a time sharing environment.

I received an introduction to the differences between 026 BCD and 029 EBCDIC when my first COBOL program, punched on an 026, generated a raft of errors due to the 360-50 expecting 029 EBCDIC. And 029-punched programs never printed correctly on a 407 which many of us sued for proofreading.

So, to answer the original question - Basic did not use square brackets or curly braces because at least some of the hardware they used for input did not have square brackets or curly braces.

In contrast, the DecWriter terminals used at Bell Labs when Unix and C were developed included those characters. So the C language reflected their input devices in much the same way.

Have to cut this off. The museum keepers are coming around to dust the dinosaur bones and I have to pretend to be fossilized.