Mind-blowing BASIC example from the 1970's:
100 A$="ABCDEF"
110 A$ = REP ("123", 4, 0)
120 PRINT A$
You can't just PRINT the result directly, because then how would REP know what the string to change is?
Nowadays "weird" syntax has some solid foundational reason why it's useful or important. This not-really-a-function, though, simply has no justification whatsoever.
(This example is from the BASIC embedded in the Tektronix 4050 terminal).
There are enough variants of BASIC that there's a really nifty handbook with the differences at https://archive.org/details/Basic_Handbook_2nd_Edition_1981_...
The (actually second) BASIC interpreter on the Amiga was made by Microsoft. It was great and horrible at the same time. Great because it had while-loops, labels instead of line numbers, and basic (no pun intended) support for the Amiga GUI, i.e you could open windows and create menus. Horrible because it was super slow and, for some reasons unknown to me, Microsoft had decided to not implement stack frames for subroutines. So, all local variables in subroutines were static and recursions were not allowed.
The weird thing: You still had to write the "STATIC" keyword although all subroutines were static anyway! (I assume the STATIC keyword was optional in the other Microsoft BASIC version and non-static subroutines were supported there)
As DonHopkins notes, this appears substantially identical to the assign-equals operators which are generally thought of as "easy and convenient" rather than "weird". How is the line of code "a *= 7" meaning
"whatever the current value of a is, multiply that by 7 and assign the result to a"
weirder than the line 'a$ = REP("123",4,0)' meaning
"whatever the current value of a$ is, do a string replacement on it and assign the result to a$"?
Yes, it actually did exactly what it sounds like!
Chalk one up for DEC and BASIC. What other programming languages support that feature, huh?
DECSYSTEM 20 BASIC User's Guide: LISTREVERSE command
LISTREVERSE
LISTNHREVERSE
LISTREVERSE and LISTNHREVERSE print the contents of the
user's memory area in order of descending line numbers.
LISTREVERSE precedes the output with a heading,
LISTNHREVERSE eliminates the heading.
LISTREVERSE
EQUIV 10:53 13-NOV-75
40 END
35 PRINT "THE EQUIVALENT CURRENT IS",I, " AMPERES"
25 I=E1/R
10 INPUT R
5 INPUT E1
READY
Same might go for a terminal with no scrollback...
Come to think of it, this sounds actually rather useful. Had this been available when I was programming on the BBC Micro, I bet I'd have used it.
A$.REP("123", 4, 0)
perl -le '$A = "ABCDEF"; substr($A, 3, 0) = 123; print $A'
ABC123DEFEdit: Interesting...the Duinomite folks even noted the "Why Johnny Can't Code" post: https://www.olimex.com/Products/Duino/Duinomite/_resources/E...
I've also been enamoured by PICO-8, a programmable virtual game console - its retro aesthetics and ALL CAPS syntax remind me of BASIC. https://www.lexaloffle.com/pico-8.php
It's late but I'm confused why anyone would spend time doing this, and since it is in the official Google repository, presumably someone at Google was actually doing it on paid time.
https://flagxor.com/article/source-code
I might be coming around to the why of this.
Unlikely. Google (like many companies) assert ownership of everything their employees create, even on their free time. There are plenty of projects under Google organization that have no other affiliation with Google.
Plain, good, old fun?
This isn't that, but withering comments from Dijkstra aside, BASIC is still a great introduction to programming, and this is a fantastic idea; it'll be great to run loads of old type-ins in the browser.
Could have done with a crisper font, though.
BASIC was how I started programming, 30 years ago.
Is this the first time someone's implemented BASIC in JavaScript? It seems so... obvious in hindsight.
I wonder if this has any potential for kids who want to start to learn programming? Or if there are other better, more modern, places to start these days?
Also... why is this from Google of all places? Seems like more of a personal hobby project.
After this experience I can easily see how someone could still be writing BASIC for a living in 2018, whether for standalone desktop apps or for web CGI, etc.
Business BASIC was ported to mainstream PCs and other micros as the market for dedicated Business BASIC minicomputer systems waned. It still lives on today in the form of two dialects: ProvideX and BBj. And people are still writing/maintaining applications in it.
https://www.hanselman.com/blog/NETAndWebAssemblyIsThisTheFut...
https://blogs.msdn.microsoft.com/webdev/2018/02/06/blazor-ex...
"gwwwbasic" anyone??
I started on BASIC on the TRS-80 Model I in 1980, and it was a great introduction.
That said, newbies are probably better off starting Python (use IDLE for a decent REPL & editor), type `from turtle import *; reset()` to get a graphics window, and learning a nice language from the start.
Outside highly narrow application/context-specific situations, that is.
Is there at least GOTO?
Just as serious. Programming does not always require a solid reason before you can engage in it, quite a bit of it is like playing. If you actually enjoy programming then it is much nicer to do than if everything needs a financial justification.
There is a similar analogy with music, you could make money with it, but you can also simply enjoy it.
BASIC was for many people their introduction to programming, and it has a simplicity which is nearly unmatched today.
By providing a way to run the language inside the ubiquitous web browse, one may hope to spread the usage of BASIC as a learning tool, especially for youngsters.
> 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.
Each of those could be used to write very complete applications including GUIs and such.
I love the idea of a language that has the absolute fewest number of decisions between "I need a little program" and being able to share the program with a friend. The current trend where there's a seemingly bazillion steps before you can write a trivial utility is unfortunate.
However, the microcomputer BASICs had big usability problems. Us modern programmers are so used to block oriented languages that we assume every language just had them. For example, in C you can replace any statement with a list of statements enclosed in { }. In Python where blocks are indented statements, or Pascal where you can make a block of statements with a BEGIN/END.
But many microcomputer BASICs don't have that at all. The IFs often don't have the concept of an ELSE, and often the only thing you can do from an IF is a GOTO.
The end result is a mess of jumps where the programmer is "emulating" real blocks with GOTOs. I've had the recent fun of transcribing programs from a bunch of different early BASIC languages. The complaint that BASIC leads to spaghetti code is real. There are bazillions of GOTOs, and it's a real drain on your mental processing to keep them all straight.
Something like Turbo Basic or QBasic, with a REPL as well would do quite nicely.
On the other hand maybe what is missing is making those little boards with JavaScript or Python more widespread.
I grew up on basic on TRS-80/Apple II/Atari 800 and I have super fond memories of those times. You can even find lots of my BASIC code in old magazines from the 80s. But, I don't really believe those were better than today with kids with Scratch or Unity or other alternatives. Python or JavaScript (runs everywhere) etc... Maybe even PICO-8/Lua etc...
Are there some concrete reason BASIC is actually a good place to start?
It is easy to learn because it was the first language to come with batteries.
In some 8 bit micros it was as powerful as the underlying Assembly, only slower. So it was relatively easy to prototype.
Also the the runtime was the OS.
Nowadays a kid needs to learn how to access the development environment, probably configured by an adult and to do more complicated tasks might need some help getting libraries.
Maybe stuff like boards with MicroPython will help here.
> In the 1980s, Business Basics were ported from their original proprietary environments to many Unix platforms, CP/M, and to DOS. In the 1990s, some Business Basics were ported to Linux and Windows, ... [https://en.wikipedia.org/wiki/Business_Basic]
Know where I might be able to find some of the earlier versions? The DOS and CP/M versions simply for the archival/historic value, but I'd love to play with the Linux version in particular, early Linux software is virtually impossible to find. Early Windows versions would certainly be fascinating as well.
Nothing.
Microsoft Windows [Version 10.0.17134.285]
(c) 2018 Microsoft Corporation. All rights reserved.
C:\Windows\SysWOW64>cscript
Microsoft (R) Windows Script Host Version 5.812
Copyright (C) Microsoft Corporation. All rights reserved.
Usage: CScript scriptname.extension [option...] [arguments...]
Options:
//B Batch mode: Suppresses script errors and prompts from displaying
//D Enable Active Debugging
//E:engine Use engine for executing script
//H:CScript Changes the default script host to CScript.exe
//H:WScript Changes the default script host to WScript.exe (default)
//I Interactive mode (default, opposite of //B)
//Job:xxxx Execute a WSF job
//Logo Display logo (default)
//Nologo Prevent logo display: No banner will be shown at execution time
//S Save current command line options for this user
//T:nn Time out in seconds: Maximum time a script is permitted to run
//X Execute script in debugger
//U Use Unicode for redirected I/O from the consoleIn some ways it's like the grandparent of Electron or React apps, just a decade too early.
The last .hta I wrote was several years ago - a [mostly] complete clone of 'Active Directory Users & Computers' that anyone could use.
What happened was that Internet Explorer moved towards a more standards-compliant JavaScript implementation, leaving the kind-of-ES3-compliant JScript behind, while at the same time COM was being generally deemphasized in favor of .NET.
It's still there, but its usefulness is limited by several things:
* It can only make use of libraries that expose dynamically bound COM objects. No C libraries (so no win32 API) and no .NET.
* Even then, it can't subscribe to COM events, as far as I can tell. (There is some weird mechanism with some external XML file in certain contexts.)
* As for JScript, I haven't found any transpilers that target ECMAScript 3, so it would be difficult to use modern libraries with it. (And it would probably be slow anyway.)
I think it’s biggest value is that it offers a bridge for business users who’s only programming experience is some VBA to a more sane and modern language.
That's very true. Either C# or VB.NET, you're programming the NET Framework. All you can do in C# you can do in VB.NET, and even there's some features that are better implemented in VB.NET, like Type.Missing https://blogs.msdn.microsoft.com/eric_carter/2004/04/15/type...
Of course any language with "Basic" in its name will be look down, but in today's NET there's no objective reasons to do so. Nowadays, VB is a better choice than C# to develop in-house business management software.
But there are still instances where the VB.net syntax is nicer than c#, for instance date litterals, or array litterals:
C# foreach(var x in new string[] {"A", "B", "C"})
VB For Each x in {"A", "B", "C"}
Also switch statements in C# are horrendous. But there are also instances where C# has a better syntax, like "x=>x+1" is way more elegant and practical than "Function(x) x+1".
But I think the writing is on the wall. VB will go the way of Winforms, i.e. sort of supported but nothing more.
[1] https://en.wikipedia.org/wiki/C_Sharp_4.0#Optional_parameter...
LINE (x1, y1) - (x2, y2), 5, FB
Or, for example, MID$ is a function, except when it's not:
MID$(s$, 1) = "foo"
The reason for all this is that BASIC was never designed as a language in which the standard library could mostly be written, or even described, in that language. Thus, most features were implemented as intrinsics, with magic syntax and/or semantics, which varies drastically from feature to feature. This goes even for the standard functions - e.g. MID$ is a function (except when it's not, as above) - but it can take either 2 or 3 arguments, which is not something that you can declare yourself. As a result, when language evolved, it also did so in a haphazard way, as with LINE re-purposed for other reasons.
The original BASIC was very simple (but also non-extensible). The BASIC that most people remember - at its peak - was actually more complicated than an equivalent subset of Python.
Enhancing Applesoft using ampersand routines: https://link.springer.com/content/pdf/10.3758/BF03203836.pdf
>Applesoft BASIC's ampersand (&) jump feature gives the programmer an easy and fast way to connect machine language routines to BASIC. When the Applesoft interpreter encounters an "&," it does an immediate and unconditional jump to location $3F5 (decimal 1013). This feature, originally described as being "intended for the computer's internal use only" and "not a proper APPLESOFT command" (Apple Computer, 1978, p. 123), has become the favorite procedure for executing machine language routines from a running Applesoft program.
Transfers control to a machine-language procedure.
CALL ABSOLUTE ([argumentlist,] offset%)
▪ argumentlist Arguments passed to a machine-language procedure
as offsets from the current data segment.
▪ offset% The offset from the current code segment, set by
DEF SEG, to the starting location of the procedure.
Example:
'Calls routine for printing the screen to a local printer.
DIM a%(2)
DEF SEG = VARSEG(a%(0))
FOR i% = 0 TO 2
READ d%
POKE VARPTR(a%(0)) + i%, d%
NEXT i%
DATA 205, 5, 203 : ' int 5 retf 'Machine-language code
'for printing screen.
CALL ABSOLUTE(VARPTR(a%(0)))
DEF SEG
>>> s = 'foobar'
>>> s[1:2] = 'xxx'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
> Can you remember what it does? (no, it doesn't draw a line; it would, if not for "FB").
Yes. Draws a filled box (FB), from top-left (x1,y1) to bottom right (x2,y2) in Purple (colour 5).
Although thinking about it... I'm pretty sure that the co-ords of 0,0 were bottom left, not top left on DOS based graphic screens, so is quite probably bottom-left to top-right.
Source: One of my first 'paid' jobs was as a QB45 programmer for an accountancy firm in the mid 1990s.
A$ = "ABCD"
MID(A$,2,2)="12"
PRINT $A
>A123
x = [1,2,5,6]
x[2:2] = [3,4]
print(x)
https://visualstudiomagazine.com/articles/2017/02/01/pattern...