The fascinating blog series about reviving JOSS, which was a “conversational” programming language in the same vein, and time frame, as BASIC. JOSS ran on the one-of-a-kind JOHNNIAC computer at RAND.
3 Likes
Nice! (We’ve seen JOSS mentioned a few times previously - see these results.)
From the blog, by way of orientation:
JOSS was a small language with the first version capable of being described on a single page. By design it looked similar to English in order to make it easier to learn for people who had never used a computer before. […] JOSS was well received, leading to an improved JOSS II being developed for the PDP-6. JOSS was also influential, with languages like FOCAL and MUMPS being derived from it. Shaw even saw some influence of JOSS in BASIC.
An attempt - work in progress - at reviving JOSS II is here:
1 Like
More computers should have a “hoot” instruction. JOHNNIAC’s was the appropriately terse HUT
I took a quick glance for the hoot instruction, but could not find it.
A beep yes. I love the Console.
Why did we get ASCII? That has allmost all the keys I
want but & and 10 superscipt. Could one get the typeball fonts and build
a new version. Did they ever have APL for the 6 or 10?
I read in this article about an engineer named Ed Smith that JOSS was implemented once as the standard language on a short-lived microcomputer called the PeCos One, from APF Electronics, released in 1978. Though, in marketing materials, the language was called the same name as the computer.
Irving Boilen, spearheaded the firm’s first personal computer project, the PeCos One (short for “Personal Computer One”). According to Sy Lipper, it was Boilen who chose to base the machine around an obscure defense contractor programming language called JOSS rather than BASIC, the industry standard. That one decision ensured the quick market death of the awkward computer upon its launch in 1978.
Ed Smith And The Imagination Machine: The Untold Story Of A Black Video Game Pioneer
Alan Kay always lamented that Basic won over JOSS. I actually looked at JOSS and its little brother, Focal, as an alternative to Basic for a demo I wanted to do. Given that DEC invented Focal due to JOSS not fitting on its minicomputers, I was surprised to read in the PeCos One manual that it was a 6502 machine with 25KB of ROM and 16KB of RAM. Obviously they were paying 3 times as much for their ROMs as their Basic competitors, but it wasn’t as bad as I had expected.
2 Likes
Re. Basic winning out over JOSS
I’ve heard Alan say that, as well. He said the reason Basic got popular was it was on the GE time-sharing service. I didn’t understand what he meant by this until I got into the ARPA history. GE was one of the contractors on Project MAC, working on Multics. They started their own time sharing service that ran Basic, and it became the most popular in the time-sharing market, with I think a subscriber base in the hundreds of thousands.
A little trivia is that Bill Gates got his introduction to Basic through that service, since his Jr. high school was a subscriber.
There are digitized demo films of JOSS online, and I can see a little resemblance to Basic. As I remember, you can define “steps,” to which you can pass parameters (like procedures). One really nice feature I saw with it was you can lay out a column format with an identifier, and then just use a series of underline characters and spaces. It figures out the rest. You can then tell it to “output this series of figures in that format.”
You can tell the language was designed around how one would use a teletype, but it had a bunch of good ideas.
1 Like
JOSS ran on the one-of-a-kind JOHNNIAC computer at RAND.
JOSS ran on JOHNNIAC for only a short period, it moved to the PDP-6 fairly quickly and spent most of its life there. There were also a number of versions of JOSS for other machines, they just weren’t allowed to be called JOSS. Examples include CAL, JEAN and FOCAL.
Alan Kay always lamented that Basic won over JOSS
I have not read his reasons for this statement, but I will disagree. I think BASIC is the better language, especially for implementation on small machines.
Backing up a bit, both JOSS and BASIC were written at the same time (within months) to solve the same problems. They both wanted to produce a cleaned-up version of FORTRAN that could be used interactively. They differed mainly in syntax. And for that reason, picking one over the other is not something that is going to be trivial as they are 80% or more similar.
JOSS had some nice features, but they were generally expensive to implement. For instance, JOSS uses logic structures that are “reversed”, so instead of something like:
IF A=5 THEN PRINT "IT IS 5"
In JOSS you have:
Type "IT IS 5" if A=5.
Now this may appear to be a minor change of syntax, but consider this at runtime. In BASIC, if A=5 fails, it immediately follows the pointer to the next line. In JOSS, it has to essentially cache the statement to see if it has a logical suffix before it decides to perform it.
A more direct problem was that JOSS did not address FORTRAN’s looping syntax, and used the same suffix style so loops only ran a single line:
Do part 5 for i=1(1)100.
I don’t think anyone would think that superior to BASIC’s version, which was explicitly created to clear up the terrible 1(1)100 syntax, and allowed multi-line blocks.
And finally, there was the way that some of the commands were just free-floating text at the bottom of the program. For instance, one could define a formula there just floating at the end, and other bits of the system, like Form, can only be used that way. I find this completely random.
I think JOSS’ primary notable feature is its line-numbering solution. I think the “part/step” concept is an excellent one. Because it is two separate numbers, scanning for a matching line is easier because you only need to do a compare on the step if you match on the part first. It also offers chances for optimization, if you have enough memory, by caching the entry points to each part. And its effect on the organization of the program is profound, it is very easy to scan a JOSS program and see the different parts.
But then they went and screwed it all up with Do. If you call a To, it works just like a GOTO and you simply execute from that point. But if you call a Do, then it has to note whether or not you are calling a part or a step. At the end of every line, you have to check whether you called a step and return if so, or if it is a call to a part, you have to check whether the next line has a different part number and then return. It is far more complex than it would seem from its seemingly simple description. The only upside is that it avoided dangling RETURNs which you see in BASIC.
Overall the two languages are more similar than they are different so there’s only little things to choose one over the other. JOSS is certainly the more powerful system, with Form and Let being standard features, a nice set of functions, and the part/step concept being a real advance. But at the same time BASIC has much better loops and branches, is generally easier to implement, and is much closer to its goal of a language that is essentially intended to be a cleaner, simpler, interactive FORTRAN.
I think it is also worth pointing out that the more direct comparison is FOCAL and BASIC. Most of the features that differentiated JOSS from BASIC disappear in FOCAL. So while we can look at JOSS’ advantages, we need to be mindful that many of those would have gone away on micros anyway.
It seems to me that whether you preferred JOSS or BASIC largely comes down to where you were located. People on the west coast, near RAND, invariably choose JOSS. The outlier is DEC, which was the machinery supplier. As BASIC spread - to some degree because, unlike RAND, they wanted people to use the BASIC name and thus avoided fragmentation - JOSS disappeared and I’m not convince we lost much in the process.
I agree with your impression of JOSS, Focal and Basic. Adding the two part line number scheme to Basic would make it nicer (though line numbers would be dropped soon enough as many Basics hoped to grow up to be Pascal) but I don’t see any other JOSS/Focal features that would make a difference.
There was a version of JOSS for the Burroughs B5500, originally named “BOSS” (Burroughs Open-Shop System) but later released as “INTERP.” The source code has survived and is available in an archive of the Mark XIII System Software release from 1971. See the file SYMBOL2/SYMBOL/INTERP in the zip archive. It’s written in B5500 Extended ALGOL
There’s no filename extension in the archive, but the file is just ASCII text. Note the following ASCII substitutions for the special characters used by B5500 ALGOL:
- “
~” left-arrow (assignment operator, “=” was used for equality) - “
|” small-cross (multiply operator, “*” was used for exponentiation) - “
!” not-equal operator - “
{” less-than-or-equal operator - “
}” greater-than-or-equal operator
The Charles Babbage Institute in Minneapolis, Minnesota, has a document from 1965 on the original BOSS implementation in its Burroughs Corporation Records collection, CBI90-74, Box 33, Folder 15.
2 Likes