Here's some extracts from the manual's intro section. They should give a better understanding of the question "why?" The new language's tentative name is "STANDARD".
Our goal with STANDARD is simple: to create a compiler which generates safe, fast code for processors which provide hardware memory protection and privilege control. Our starting point was C, arguably the most awesomely efficient language on the planet, but whose unbridled power exposes razor-sharp edges to the unwary. It is impossible for a C compiler to generate universally efficient safe code. In keeping with its first incarnation as the original systems language, C guarantees complete and unfettered access to the computer's hardware, including all memory without limitation. These implicit guarantees that C makes cannot be kept if in application mode, the hardware, for instance, will not permit random bits of data to be grabbed from anywhere in memory, or a chunk of data to be designated as executable code and forced to run. In C, string handling is simple but also incredibly dangerous - it is possible to overflow buffers, overwrite other data, and corrupt entire programs merely by concatenating two strings. Even by accident.
Ideally, a compiler should be able to guarantee all features its designers wish to grant the programmer, and ensure that those features work uniformly and safely; and firmly forbid any other features that cannot be guaranteed. This would create a reliable framework with no unexpected behavior that leads to sudden crashes. But then user-level applications, by necessity, must deny operations that only make sense to operating-system level utilities; they should not permit actions that compromise security, hinder efficiency, or annoy other users. So C is not the answer.
The safest language, historically, was COBOL. The largest repository of business programs, numbering in the millions, is now "legacy" code - because you could trust COBOL. Everybody appreciated decimal numbers that didn't give annoying binary fractions. But its wordiness and glacial pace didn't endear it to all, and the attempt to repair its unstructured jumping-around with the PERFORM verb was a pathetic failure that descended into monstrously sphagettified code - where the same paragraph could be simultaneously fallen-through and remotely PERFORMed.
BASIC was loved by the vast majority. It was a simple language that made no unnecessary promises. Its processes and assumptions were very much in line with the philosophy of secure processors, because it was implemented from the very beginning as a multi-user system where it was important to play nice with others; and a little tweaking was all that was necessary to make a safe, friendly, efficient server applications programming language.
Thus was born the concept of STANDARD: written in lightning-fast C, implementing the safety and reliability of COBOL and the friendliness of BASIC syntax, and incorporating the formidable mathematical toolkit of FORTRAN.
STANDARD is not intended for front-end applications, having no GUI features, and supports only server-side events. It is designed to crunch data and to service requests, and to do these as fast and efficiently as possible. It retains and enhances BASIC's reputation as the best text processing language ever designed; it is also perfectly suited for batch processing, periodic processing and reporting; and obviously for embedded services. FORTRAN's awesome number-crunching power, which was partially given to BASIC, has been implemented in full with double-precision and complex number support. For accuracy in business applications, currency values may be computed entirely in decimal. In fact, STANDARD guarantees that its data types, from 18-digit numbers and petabyte strings to 10-dimensional complex-number arrays, will work efficiently out-of-the-box in every implementation, thereby removing all concerns about portability.
In addition, the availability of certain software libraries is required. STANDARD uses the IBM Informix C-ISAM library for file indexing, the Berkeley Sockets interface for networking, and the GNU Scientific Library mathematical toolkit. These are available almost universally, having been ported by many enthusiasts. The MySQL database client code is used for RDBMS integration and Windows clients are written in FreeBasic source for simplicity - the Unix and Linux clients have custom-written C terminal drivers.
STANDARD's syntax is a little different from that of its predecessors. Some useful features have been borrowed from other languages, and redundant statements have been dropped. Why, if we are implementing a version of BASIC to maintain compatibility with that language, would we then "break" it by changing the syntax?
The answer is simple - this language is not meant for porting existing applications. We have given this language new abilities and new responsibilities. We are changing the most basic "rules of engagement" and setting into place a new set of tools and rules, and backward compatibility would be a huge millstone around our necks. This is only for new applications where the programmer understands the underlying concepts of safety, efficiency and maintainability. The reason for sticking with BASIC language concepts is - they are very well thought-out and designed for maximum ease of use. Kemeny and Kurtz were absolute geniuses and way ahead of their time. Why create yet another language when an almost perfect one already exists?
Some keywords defined in the original BASIC, and some others added in later versions, are not available in STANDARD. Executive and editing commands such as EDIT, REPLACE, and RENUM are not implemented because STANDARD is not an interactive interpreter but a compiler, but SAVE and LOAD are re-purposed as Mat extensions. New and Del are retained for use in ways familiar to users of structured-data pioneering languages such as Pascal. The comment statement REM was made redundant in most versions of BASIC, but we have brought it back as a directive to designate block comments. Program control statements GOSUB and GOTO are not necessary because subroutines are called by simply using their name, and looping is provided in a structured way with While and Repeat. Obviously, line numbers are not used either. The On keyword allows indexed branching and finer control, and parallel programming is supported by a simple launcher symbol similar to a shell operator.
Most BASICs cleave to the original separation of statements, functions and operators. STANDARD blurs the divisions quite a bit, permitting functions to be used as operators and some keywords working as both statements and functions.
Internal data-table keywords Data and Read are augmented by the more general static initialization of data at program load. The Var statement is required for declaring all data variables, and it can instantiate objects and initialize data simultaneously. Def now defines record structures, unions and objects. Fn and Sub separately define functions and subroutine procedures. For functions, Ret is used to return some data structure or element.
Another change is to the specification of numeric non-decimal constants, traditionally preceded in BASIC by '&h' for hex and '&b' for binary. The rest of the programming world has followed C's lead with '0x' and '0b' because not only is it less ugly, it makes parsing expressions easier and less prone to ambiguity - and so we have too. And JavaScript decided that strings could be delineated by either double or single quotes, and we couldn't find a convincing reason why not - so that's included, too.
Input and output statements Input and Print work much as they always have. INPUT LINE (or LINPUT or LINE INPUT), for reading entire records into a single string, is not needed because it's done automatically. The FMT$() function duplicates the USING subcommand's formatting for any string assignment. Character string functions LEFT$(), RIGHT$(), MID$(), etc. are replaced by the generic range operators, e.g. "(x to y)". These operators work on arrays, lists and strings. Some VB string function equivalents are available here under different names: FMT$() for Format(), and SRCH() for InStr(). STR$() and VAL() are augmented by more flexible functions. LSET is redundant because fixed-length strings exist; but there is an enhanced command Rset .
End is no longer used to halt the program, but to terminate statement blocks for the Def, Fn, For, If, On, Sub, Unless, and While statements . Stop halts the program in the usual way, but can also issue an error message or be used as a bug trap. Files are no longer referred to by number; they are dignified by a channel name which can be passed into subroutines. Semaphores are built-in with the If LOCK statement, with completely invisible locking and release to make locking bugs all but impossible.
In general, STANDARD aims to "fail soft" rather than "fail hard". For instance, attempts to access nonexistent nodes or unread records will simply return Null instead of crashing; likewise de-referencing object instances that do not exist will return zero or empty strings, and not program halts. Where there is a wrong assumption or improper operation, the compiler will highlight the problem, instead of leaving it to cause trouble later. Errors during runtime that can be fixed are fixed in the background, although the programmer can inquire into such situations; failures that can't be fixed give trappable errors.
Many new, useful commands have been added. The File command can perform very handy file maintenance from within a program, including file repair and remote send-receive, and can export and import entire XML, JSON or CSV files to and from an internal list of records in a single statement. The complementary Mat FILES command (Mat basically handles anything that returns an array) retrieves directory information; SED$() can edit strings using the powerful regular expression syntax.
To accommodate the console-programming model, the cursor-addressing command LOCATE and the color-switching command COLOR have both been folded into the "Print @" extension statement originally brought out by Tandy in 1977. This helps us to avoid adding further trivial commands that complicate the basic command set.
The beauty of BASIC is its utter simplicity and lack of syntactical adornments. STANDARD attempts to carry on this tradition by making it as markup-free as possible; the resulting programs are uncluttered and easy to read. One will notice, as we go through this manual, how much effort has been expended on making notation as natural, consistent and unobtrusive as it could be.
For example, function and subroutine prototypes are not necessary; type conversion is automatic (within numeric and string categories); parentheses are eliminated in a large number of places; functions may be used as operators. Many restrictions and requirements were in an age when machines were slow and memory scarce; they no longer apply to the architecture of modern machines. But the most important result - hugely reduced programmer labor.
STANDARD is basically BASIC. Except for the fact that no line numbers are required, at first glance STANDARD looks much as the original Dartmouth BASIC looked. But STANDARD makes more use of the ASCII character set to specify, notate and visually separate language elements in a harmonious and efficient manner. In this, STANDARD diverges from other BASICs that effectively abandoned special characters in favor of wordy declarations a la Pascal, most noticeably in the type suffixes for simple variables. For instance, STANDARD insists on strings being marked with the "$" suffix, so that it is instantly clear which variables are capable of mathematical operations and which aren't.
The non-alphanumeric characters are extensively made use of because they are awesomely efficient at conveying information; everyone understands the "=" symbol as signifying equality, and in the computer programming world of also implying assignment from right to left. Quotation marks are universally understood to delineate text that is not instruction; other symbols, once used in a particular way, are unmistakable even when casually glanced at.
