Palo Alto Tiny BASIC 1.0 for 8080

[Udo Munk]

Li-Chen Wang published a Tiny BASIC for the 8080 in Dr. Dobbs magazine
Volume 1 Nr. 5 in 1976. This was the famous Copyleft version in response
to the Gates letter.

I was not able to find the source for the original anywhere, but an archived
PDF of the Dr. Dobbs issue with a listing of the BASIC interpreter.

Unfortunately Li-Chen had no 8080 assembler, so he used the Macro Assembler
from some Mainframe with a Macro set to produce 8080 object code.

Besides that the syntax makes my eyes bleed, the Macro set used is not available.
So I converted the source to Intel 8080 Macro Assembler syntax, the assembler is
available and so the source can be modified and the object file build, hope that's
in the spirit of Li-Chen.

The original program is for the Altair 8800 with 88SIO Rev. 0, you might need
to modify it for the machine you use. I/O is done in 2 subroutines only, so that's
very easy.

I compared the hex bytes against the ones in the Dr. Dobbs listing, matches, so
the program is correct, typos in the comments are my fault.

All relevant files are available at:
http://www.autometer.de/unix4fun/z80pack/ftp/altair/

There was a 2.0 version, also translated to 8080 mnemonics by Roger Rauskolb,
published in Interface Age December 1976 issue. I cannot find the source file
nor the archived magazine, so if anyone has this version I would like a copy,
thanks in advance.

[Peter Dassow]

On 22.08.2016 at 21:08 Udo Munk wrote:
>
> All relevant files are available at:
> http://www.autometer.de/unix4fun/z80pack/ftp/altair/
>
> There was a 2.0 version, also translated to 8080 mnemonics by Roger Rauskolb,
> published in Interface Age December 1976 issue. I cannot find the source file
> nor the archived magazine, so if anyone has this version I would like a copy,
> thanks in advance.
>

The 2.0 is indeed very difficult to find.
So far I found only a version 1.1:
http://www.pcorner.com/list/BASIC/TBASIC.ZIP/INFO/
or at
http://home.myfairpoint.net/fbkotler/tbasic.zip
Unfortunately this seems to be 1.0 but with 8086 mnemonics and MS-DOS
interrupts.
Some hits can be found referring to "Best of Interface Age Vol 2 Issue 1
(Software in BASIC)", but I fear this was also only Tiny BASIC 1.0.
Because it was also published in Dr. Dobb's Journal, may be you take a
look into Dr. Dobb's Journal itself, some can be found at:
http://6502.org/documents/publications/dr_dobbs_journal/

Regards
Peter

[Peter Dassow]

On 22.08.2016 at 21:08 Udo Munk wrote:
>

> There was a 2.0 version, also translated to 8080 mnemonics by Roger Rauskolb,
> published in Interface Age December 1976 issue. I cannot find the source file
> nor the archived magazine, so if anyone has this version I would like a copy,
> thanks in advance.
>

I've found within the mentioned Dr. Dobb's Journal issues a few hints:
In Dr. Dobb's J. Vol 1: Page 14 a first improvement to the IL
In Dr. Dobb's J. Vol 2: From page 80 to 82 several extensions (e.g.
string handling) to Palo Alto Tiny BASIC.
In Dr. Dobb's J. Vol 3: From page 273 onwards several extensions (e.g.
Tape I/O and Peek/Poke) to Tiny BASIC. In the article from the well
known Leor Zolman you will be able to find a hint about the second Tiny
BASIC version (-> Interface Age, as posted before).

I guess this "Best of Interface Age" issue (Vol 2) is worth to be
investigated. Unfortunately I have no PDF nor any paper version of it.

Regards
Peter

[Al Kossow]

On 8/23/16 8:27 AM, Peter Dassow wrote:
> On 22.08.2016 at 21:08 Udo Munk wrote:
>>
>> There was a 2.0 version, also translated to 8080 mnemonics by Roger Rauskolb,
>> published in Interface Age December 1976 issue.

I just scanned and ul'ed the article to bitsavers.org/pdf/interfaceAge/197612
along with part 1 of the LLL BASIC series.

It should show up on the mirrors in about three hours (noon PDT)

[Peter Dassow]

That was really pleasant to all.
Btw. Version 3 (CP/M) of Tiny BASIC can be found in SimTel CPMUG Disk 002...

Regards
Peter

[Udo Munk]

On Tuesday, August 23, 2016 at 5:27:15 PM UTC+2, Peter Dassow wrote:
>
> I've found within the mentioned Dr. Dobb's Journal issues a few hints:
> In Dr. Dobb's J. Vol 1: Page 14 a first improvement to the IL
> In Dr. Dobb's J. Vol 2: From page 80 to 82 several extensions (e.g.
> string handling) to Palo Alto Tiny BASIC.
> In Dr. Dobb's J. Vol 3: From page 273 onwards several extensions (e.g.
> Tape I/O and Peek/Poke) to Tiny BASIC. In the article from the well
> known Leor Zolman you will be able to find a hint about the second Tiny
> BASIC version (-> Interface Age, as posted before).
>
> I guess this "Best of Interface Age" issue (Vol 2) is worth to be
> investigated. Unfortunately I have no PDF nor any paper version of it.

Thanks Peter, that is all stuff I also found while searching for a
source file or archived magazines with the published programs.

But I wanted the original source versions 1.0 and 2.0 in a form,
that can be used on machines. If it is available again anyone can
modify and extend it from there on for their needs, in the spirit
of those who made it available 40 years ago.

[Udo Munk]

Many thanks Al, much appreciated, I'll pick it up when available here
and try to get it working.

[Udo Munk]

On Tuesday, August 23, 2016 at 6:38:00 PM UTC+2, Peter Dassow wrote:

> That was really pleasant to all.
> Btw. Version 3 (CP/M) of Tiny BASIC can be found in SimTel CPMUG Disk 002...

If that is the Sherry Brother's 3.0 CP/M version I have it already
in the z80pack repository. This CP/M adaption was the most reliable
one and seems to work as good as the original.

However, I hope to have 1.0, 2.0 and 3.0 complete sometime, so that
anyone can try this on machines...

[Bill]

On Mon, 22 Aug 2016 12:08:41 -0700 (PDT), Udo Munk
<udo....@freenet.de> wrote:

>Li-Chen Wang published a Tiny BASIC for the 8080 in Dr. Dobbs magazine
>Volume 1 Nr. 5 in 1976. This was the famous Copyleft version in response
>to the Gates letter.
>
>I was not able to find the source for the original anywhere, but an archived
>PDF of the Dr. Dobbs issue with a listing of the BASIC interpreter.

Seems to me, Kildall mentioned knowing Tom Pittman, and his Tiny
Basic.

Does that fit into this discussion somewhere?

Bill

[Ed]

Udo Munk wrote:
> Li-Chen Wang published a Tiny BASIC for the 8080 in Dr. Dobbs magazine
> Volume 1 Nr. 5 in 1976. This was the famous Copyleft version in response
> to the Gates letter.

The idea of a free BASIC to challenge Gates may have been a good strategy
for magazines such as Dr Dobbs - but weren't free BASICs comparable to
Gates already available such as LLL BASIC for the 8008?

I can understand the nostalgic interest in TB today, but wouldn't users of the
time have found it quite limited? I can remember trying use Fig-Forth in the
early 80's and found it more novelty than useful.

[Udo Munk]

On Wednesday, August 24, 2016 at 4:42:39 AM UTC+2, Bill wrote:

> Seems to me, Kildall mentioned knowing Tom Pittman, and his Tiny
> Basic.
>
> Does that fit into this discussion somewhere?

Tom Pittman never did a 8080/Z80 BASIC:

http://www.ittybittycomputers.com/IttyBitty/TinyBasic/

It was interesting what he did, many also used 6502 or 6800
based systems, but it was not CP/M related.

[Udo Munk]

On Wednesday, August 24, 2016 at 5:28:39 AM UTC+2, Ed wrote:

> The idea of a free BASIC to challenge Gates may have been a good strategy
> for magazines such as Dr Dobbs - but weren't free BASICs comparable to
> Gates already available such as LLL BASIC for the 8008?

With a 7-level call stack the 8008 was pretty limited for running
BASIC, in no way comparable to the "360 at my finger tips" machines,
that came with the 8080.

> I can understand the nostalgic interest in TB today, but wouldn't
> users of the time have found it quite limited? I can remember trying
> use Fig-Forth in the early 80's and found it more novelty than useful.

Not at all, Sky (Space) is the limit, Li-chen commented into the sources,
it was build with beeing extendable in mind.

Same with Fig-Forth, that could be extended to anything needed, and a
lot of people found it very useful.

[Udo Munk]

I created the Tiny BASIC version 2.0 sources from the article Al made available,
thanks again.

Wasn't too much work, Roger Rauskolb also used the Intel 8080 Macro Assembler, so
I could use my 1.0 retyped/converted sources instead of typing it all in.

In that process I found a few typos/goofs in the comments of the 1.0 source file,
which I have fixed also.

I have verified the 2.0 hex bytes against the article printout, matches, code is identical.
Then I modified the IO for Altair 88-2SIO, so that I could test and play with it. Roger used
a homebrew 8080 system and was a bit short of memory, I modified the ORGs for the
memory sections, so that it is similar to version 1.0, now both version use memory from
0000 - 1FFF and leave ca. 5.5K for BASIC programs.

Version 2.0 fixes a few things but adds a new bug, multiplication of negative number with
Null won't work anymore. Should be easy to fix, the expression parser is written well and
understandable.

All files are available here:
http://www.autometer.de/unix4fun/z80pack/ftp/altair/

Those with archives for Altair/IMSAI machines, please make copies, because the source
files so far were not available.

[dott.Piergiorgio]

Thanks. and more thanks for having uploaded also THE primary source on
criticism of numbered-line-based BASIC language, the 1970 "Notes on
avoiding GOTO statement" aka "GOTO considered harmful" :)

Thanks and

Best regards from Italy,
dott. Piergiorgio.

[Udo Munk]

On Tuesday, August 30, 2016 at 2:34:22 PM UTC+2, dott.Piergiorgio wrote:

> Thanks. and more thanks for having uploaded also THE primary source on
> criticism of numbered-line-based BASIC language, the 1970 "Notes on
> avoiding GOTO statement" aka "GOTO considered harmful" :)

Fortunately Li-Chen Wang is a very good programmer :)

OK
>LIST
10 A=30
20 GOTO A
25 STOP
30 PRINT "NO GOTO <LINE NUMBER>!"

OK
>RUN
NO GOTO <LINE NUMBER>!

OK
>

[Peter Dassow]

On 30.08.2016 at 17:30 Udo Munk wrote:

>> Thanks. and more thanks for having uploaded also THE primary source on
>> criticism of numbered-line-based BASIC language, the 1970 "Notes on
>> avoiding GOTO statement" aka "GOTO considered harmful" :)
>
> Fortunately Li-Chen Wang is a very good programmer :)
>

> LIST
> 10 A=30
> 20 GOTO A
> 25 STOP
> 30 PRINT "NO GOTO <LINE NUMBER>!"
>
> OK
> RUN
> NO GOTO <LINE NUMBER>!
>

Udo, this looks like the same mechanism you can use with GOSUB (with
Tiny BASIC or in other BASIC versions).
Unfortunately I have the same opinion about using GOTO, regardless of
using a value or just a variable name.
If you take a look at the available BASIC sources of that time (not all,
but many), you will see many uses heavily GOTO statements and also back
and forth. It sounds like a religious war, but programming in a way that
code can be reused (aka modular), and also can be read and modified
easily also from others than the programmer itself is NOT really
supported by the early BASIC dialects.
Visual BASIC, and also a CP/M BASIC of that time - S-BASIC (delivered
also with Kaypros) - supports it much better (even if only WHILE .. WEND
and also REPEAT... UNTIL and PROCEDURE command exists, also well known
from PASCAL).
See
http://maben.homeip.net/static/S100/kaypro/software/Kaypro%20SBASIC.txt
for example...

You can create also readable BASIC programs with Tiny BASIC, but with
much more (severe) discipline. Most of the (hobby?) programmers don't
follow such discipline.

Regards Peter

[Udo Munk]

On Wednesday, August 31, 2016 at 12:59:31 PM UTC+2, Peter Dassow wrote:

> Udo, this looks like the same mechanism you can use with GOSUB (with
> Tiny BASIC or in other BASIC versions).
> Unfortunately I have the same opinion about using GOTO, regardless of
> using a value or just a variable name.
> If you take a look at the available BASIC sources of that time (not all,
> but many), you will see many uses heavily GOTO statements and also back
> and forth. It sounds like a religious war, but programming in a way that
> code can be reused (aka modular), and also can be read and modified
> easily also from others than the programmer itself is NOT really
> supported by the early BASIC dialects.
> Visual BASIC, and also a CP/M BASIC of that time - S-BASIC (delivered
> also with Kaypros) - supports it much better (even if only WHILE .. WEND
> and also REPEAT... UNTIL and PROCEDURE command exists, also well known
> from PASCAL).
> See
> http://maben.homeip.net/static/S100/kaypro/software/Kaypro%20SBASIC.txt
> for example...
>
> You can create also readable BASIC programs with Tiny BASIC, but with
> much more (severe) discipline. Most of the (hobby?) programmers don't
> follow such discipline.
>
> Regards Peter

Every von Neumann digital processor implements an unconditional
jump instructions, so does any programming language running on these
things, at least if used for pratical problem solutions.

You have to learn programming these thingies, if not, no WHILE, REPEAT...
constructs will help, you'll create a mess nevertheless.

[rand...@hotmail.com]

Not every language has an jump/goto, a small minority require you program without one.

There are some that argue these exceptions are not "true" languages since it is missing.

Some of the exceptions are old world dbase, and modern HTML.

I find it adds to the complexity of the program when it isn't there.


Randy

[Udo Munk]

These are no general purpose programming languages, in dbase GOTO is used to move
the record pointer, well it is a data manipulation language.

With IF and GOTO you can build any of the other constructs, for example RATFOR
just does this. For most macro assemblers the usual constructs are implemented
as macros.

The argumentation that those who won't understand the basics of such languages would
understand constructs, build from the basics, is a religious one, you have to believe in that,
because it makes no sense at all. You either can program in an organised manner, or you
just can not, the language used doesn't matter, it's an expression for describing some logic.

This is no fun reading logic, where someone tries to break out of the 4th nested level
of some funny constructs, by using flags with conditions en mass, due to a simple missing
GOTO.

[rand...@hotmail.com]

While I agree HTML is a specialized programming language the other example of dBase is.

dBase allows programmers to develop a plethora of programs, and no the do not need to be just a relational database application even though the language is biased as such, just as Cobol is accounting biased it is a general purpose language.

The simple fact is to avoid jumps/gotos is possible doing so can add so much complexity that all meaning is lost no matter how well documented it is. People that refuse to use tools provided to them are just self destructive.

Not only should jumps/gotos be used they are usually relished they can quickly clean up code.

Today programmers cant program code less than a few hundred thousand bytes of object code. We sent people to the moon by learning how to program efficiently with machines that could not even address anywhere near that amount of code.

I learned on early computers and learned you should program to be efficient and be aware how large your code is and how fast it runs.

CP/M could not exist outside those parameters and it could not exist on a 16K computer without jump instructions.

Please don't be that obnoxious know it all that knows nothing but what he is told.

Program clarity comes from how well written the program is, you can write a program that uses a jump in the middle of anything and still be clear. You can write a structured program without any gotos and be both huge and confusing to read. It is a matter of the quality of the programmer.

Now please go build a house without a level, it can be done but I have the feeling most people would prefer to use the right tools.


Randy

[1alvina...@gmail.com]

On Wednesday, August 31, 2016 at 4:07:22 PM UTC-6, Udo Munk wrote:
> This is no fun reading logic, where someone tries to break out of the 4th nested level
> of some funny constructs, by using flags with conditions en mass, due to a simple missing
> GOTO.

GOTO has occasional legitimate use but it's not very common.

GOTO in basic has been a disaster, however. If you've ever had occasion to modify, try to understand or port a basic program without structured constructs, you'll find these programs are messes and very frustrating to deal with.

The people writing them also have a hard time understanding what is going on -- I've found in almost all the programs I've looked at the original author couldn't determine what variables were currently active so he just invented new ones with the result that there are many more variables present than needed, something of a problem in small memory environments. It goes without saying that it's hard to have variable names that are descriptive when you're constantly having to invent new unique ones not used elsewhere in the source.

The line numbering too is problematic -- quite often the author runs out of line numbers to insert some code and ends up inserting a goto someplace else instead so the program flow is all over the source, making it difficult to follow.

The goto, spaghetti flow, lack of indentation that is introduced by structured constructs makes such code very difficult to maintain or understand. This is why GOTO deservedly has a bad rep.

I did some programming in Fortran77 too which also did not have anything but goto to change program flow. The difference was the programmers were trained to simulate for, while, repeat, and so on with boiler plate forms and properly indented source code to indicate the construct's extent. This made it just as readable as regular structured programming in other languages that directly supported it. This is something that never happened in basic's heyday for two reasons: (1) most users were amateurs and didn't know anything about structured programming or program maintenance (beginner's all purpose instruction code, after all) and (2) basic was interpretted and most commonly had its source squashed into memory co-resident with the interpretter in a tokenized form minus any whitespace someone might add to help identify control structures.

In conclusion, I would broadly agree with anyone who says GOTO is a disaster because usually it's misused. It is, however, approporiate in some circumstances.

[rand...@hotmail.com]

Pats you on the head gently and says go on little boy, come back when you grow up.


Randy

[Mark Garlanger]

FYI, Javascript doesn't have a goto statement.

[rand...@hotmail.com]

Some languages have a got some do not.

Some have indexed gotos.

Palo Alto has computed gotos, this allows things like a menu selection easy. Just go to input value time a multiplier add a constant now you have a line number based on menu selection.

Some languages are just silly, some are rich and powerful.

Basic was originally intended to teach the basics of programming. Later dialects were developed for a variety of uses. Palo Alto was commonly used for control process. It and other tiny basics could have simple programs quickly written to do specific tasks controlling equipment with very few computing resources (ie ROM based small computers w/o much RAM and no disks).

One early tiny basic computer I used to work on some traffic control apps was the Cromemco SCC. The software was tested on the SCC before building a system to be used (the SCC did not handle the environmental specs).


Randy

[Axel Berger]

1alvina...@gmail.com wrote:
> The line numbering too is problematic -- quite often the author
> runs out of line numbers to insert some code

The first and oldest BASICs I ever knew all had a renumber, the later
ones were number numberless and had named GOTO markers.

Axel

--
/¯\ No | Dipl.-Ing. F. Axel Berger Tel: +49/ 221/ 7771 8067
\ / HTML | Roald-Amundsen-Straße 2a Fax: +49/ 221/ 7771 8069
 X in | D-50829 Köln-Ossendorf http://berger-odenthal.de
/ \ Mail | -- No unannounced, large, binary attachments, please! --

[Udo Munk]

On Thursday, September 1, 2016 at 1:16:29 AM UTC+2, 1alvina...@gmail.com wrote:

> It goes without saying that it's hard to have variable names that are
> descriptive when you're constantly having to invent new unique ones not
> used elsewhere in the source.

Your variable names in Tiny BASIC are A-Z, deal with it.

> I did some programming in Fortran77 too which also did not have anything
> but goto to change program flow. The difference was the programmers were
> trained to simulate for, while, repeat, and so on with boiler plate forms
> and properly indented source code to indicate the construct's extent.
> This made it just as readable as regular structured programming in other
> languages that directly supported it. This is something that never
> happened in basic's heyday for two reasons: (1) most users were amateurs
> and didn't know anything about structured programming or program
> maintenance (beginner's all purpose instruction code, after all) and (2)
> basic was interpretted and most commonly had its source squashed into
> memory co-resident with the interpretter in a tokenized form minus any
> whitespace someone might add to help identify control structures.

Fortran77 already had a few more control constructs, Fortran and Fortran IV
were somehwat more limited. And of course there were Ratfor.

Amateurs don't have to know anything about structured programming, software
mantainace and all that. And they had to deal with machines that always
lacked memory due to the high costs. Even if the CPU could address a lot
we had machines with 4-8KB in the beginning, so lots of size optimisation
was done. I had to strip comments from source files more than once, even
from assembler sources, because of memory constrains. That enabled me to
use the software on hardware I could afford and frankly, I really didn't
care if anyone would understand this programs ;-)

[Peter Dassow]

On 31.08.2016 at 14:26 Udo Munk wrote:
>
> Every von Neumann digital processor implements an unconditional
> jump instructions, so does any programming language running on these
> things, at least if used for pratical problem solutions.
>
> You have to learn programming these thingies, if not, no WHILE, REPEAT...
> constructs will help, you'll create a mess nevertheless.
>

I totally disagree. That's not the point. We talk about a high level
programming language. I've been a programmer for about 25 years, and I
saw a lot of source code which isn't maintainable.
For a complex task/project, it's cleary an advantage to have a tool to
give it a structure in a way others can easily read the code, too.
I mean you do *not* have always to use assembly language for solving a
problem. Even 'C' is supporting these structural elements, in 'C' you
should *NOT* use goto and you don't have too.
If you are an expirienced programmer, you think about what you want to
do BEFORE you write the code. So planning a structure (e.g. with a
Nassi-Shneiderman-Diagrams or a Jackson Diagram) is a good start.
Also, coding modular is a BIG advantage. Definition of module/subroutine
interfaces is a big advantage. It's highly increasing the quality of
program code.
Of course all programming language compiler will create machine code and
so finally also with a lot of JUMP instructions. But as stated before,
you are a human and so you don't need to imitate a processor (that's
because you mentioned von Neumann).

[Udo Munk]

On Thursday, September 1, 2016 at 12:22:26 PM UTC+2, Peter Dassow wrote:

> I totally disagree. That's not the point. We talk about a high level
> programming language. I've been a programmer for about 25 years, and I
> saw a lot of source code which isn't maintainable.

Not long enough then ;-)
There is no not maintainable code, and certainly not those tiny programs
written in BASIC on the small systems of the 70th.

> For a complex task/project, it's cleary an advantage to have a tool to
> give it a structure in a way others can easily read the code, too.

Yep, many need a tool to organize them self.

> I mean you do *not* have always to use assembly language for solving a
> problem. Even 'C' is supporting these structural elements, in 'C' you
> should *NOT* use goto and you don't have too.

As I said before, the language doesn't matter because it is not the
problem. One can write nicely structurd programs in Assembler, Fortran,
BASIC, whatever. And one also can write in a way that is very difficult
to understand in any language.

> Of course all programming language compiler will create machine code and
> so finally also with a lot of JUMP instructions. But as stated before,
> you are a human and so you don't need to imitate a processor (that's
> because you mentioned von Neumann).

Well, that is because when I started computing there were almost no tools,
so you manually assembled to object code and debugged with a simple
monitor, and for that you need to know what the thing really does.

[Peter Dassow]

On 01.09.2016 at 12:46 Udo Munk wrote:
>
>> I totally disagree. That's not the point. We talk about a high level
>> programming language. I've been a programmer for about 25 years, and I
>> saw a lot of source code which isn't maintainable.
>
> Not long enough then ;-)
> There is no not maintainable code, and certainly not those tiny programs
> written in BASIC on the small systems of the 70th.

For those tiny BASIC programs like seen in the early eighties, that's
true. But I didn't focused my thoughts to these small hobbyist programs.

>
>> For a complex task/project, it's cleary an advantage to have a tool to
>> give it a structure in a way others can easily read the code, too.
>
> Yep, many need a tool to organize them self.

I guess you have no idea how to organize big project teams.
If you code just for fun and only in your free time, may be you don't
need such tools. Documentation for example is always needed.
It's NOT demoting using helpful tools, lol. Are you drunken ?

>
>> I mean you do *not* have always to use assembly language for solving a
>> problem. Even 'C' is supporting these structural elements, in 'C' you
>> should *NOT* use goto and you don't have too.
>
> As I said before, the language doesn't matter because it is not the
> problem. One can write nicely structurd programs in Assembler, Fortran,
> BASIC, whatever. And one also can write in a way that is very difficult
> to understand in any language.

That's true, but that was not mentioned from me. If a language does not
support spaghetti coding, this is helpful for all. Even for a
expirienced programmer.

>
>> Of course all programming language compiler will create machine code and
>> so finally also with a lot of JUMP instructions. But as stated before,
>> you are a human and so you don't need to imitate a processor (that's
>> because you mentioned von Neumann).
>
> Well, that is because when I started computing there were almost no tools,
> so you manually assembled to object code and debugged with a simple
> monitor, and for that you need to know what the thing really does.
>

Well, you're not alone with "started computing there were almost no
tools", but I have still the opinion syntax elements in a language which
supports structuring programs are helpful.
I guess this leads in no further meaningful discussion, so I will stop
with that for now.

[Udo Munk]

On Thursday, September 1, 2016 at 1:26:45 PM UTC+2, Peter Dassow wrote:

> For those tiny BASIC programs like seen in the early eighties, that's
> true. But I didn't focused my thoughts to these small hobbyist programs.

The thread is about Tiny BASIC, a language small enough to run BASIC
programs in 4-8KB memory of early 8-bit systems.

[Peter Dassow]

It was about using a variable for the GOTO instruction (and so also for
GOSUB), which was very helpful writing tricky programs even in Tiny
BASIC. But only a few years later S-BASIC supported all these things I
was mentioning. So have fun maintaining these Tiny BASIC programs.

[Udo Munk]

On Thursday, September 1, 2016 at 1:45:24 PM UTC+2, Peter Dassow wrote:

> It was about using a variable for the GOTO instruction (and so also for
> GOSUB), which was very helpful writing tricky programs even in Tiny
> BASIC. But only a few years later S-BASIC supported all these things I
> was mentioning. So have fun maintaining these Tiny BASIC programs.

I am having fun with Li-Chen Wangs's tinytrek, not much to maintain
with tho.

[Mr. Emmanuel Roche, France]

Randy wrote:

> One early tiny basic computer I used to work on some traffic control apps was the Cromemco SCC. The software was tested on the SCC before building a system to be used (the SCC did not handle the environmental specs).

- "Review of 5 Small Interpreters"
David North
"Creative Computing", Vol.3, No.5, Sept./Oct. 1977, p.299

(Retyped by Emmanuel ROCHE.)

Cromemco 3K Control BASIC ("3CB")
-------------------------

Price and Availability: $15 for a paper tape
Size: 3K
Reliability: No problems
Documentation: Very complete instructions are provided, but no source code
Speed: 40 minutes to Step 34
Features: Same as Palo Alto Tiny BASIC, with the following additions:

Commands
--------
LOCK (allocates area in memory for program files)
SAVE (saves files in locked area)
EPROM (burns in a file on an EPROM with a Cromemco Bytesaver)
LOAD (loads file -- opposite of SAVE)
WIDTH (sets terminal width)
NULL (number of nulls after a CR-LF)
QUIT (jumps to Monitor)

Statements
----------
PUT (stores a value in absolute memory)
OUT (outputs to an I/O port)

Variables
---------
A-Z and A0-Z0
Hex literals are denoted by a leading % sign

Functions
---------
+, -, *, /, SGN, AND, OR, XOR,
GET (gets a value from absolute memory)
IN (input from an I/O port)
LOC (to find absolute address of array elements)
CALL

User-defined functions
----------------------
None

Arrays
------
Has one other array, in addition to @(X), named &(X), 1-byte array.
It overlaps with @(X) in memory.

Machine language subroutine interfacing
---------------------------------------
Through the CALL functions.
Parameters are passed both ways through the stack.

Character strings
-----------------

Strings of up to 132 characters can be accessed by $(X), the way numbers are accessed by @(X) and &(X). String and array space intentionally overlap. There is a string INPUT statement.

Formatted statement print
-------------------------
Same as Palo Alto Tiny BASIC.

Editing functions
-----------------
None

External files
--------------
No data files. As mentioned before, program files can be kept in high memory with LOCK, LOAD, SAVE, and EPROM commands. These programs can be called by other programs with a special version of the RUN command. A STOP in a called program will function as a return to the calling program.

Error messages
--------------
Same as Palo Alto Tiny BASIC.

Extra stuff
-----------
None, other than the extensions already mentioned.


User comment
------------

Cromemco 3K Control BASIC ("3CB") is an expanded version of PATB (Palo Alto Tiny BASIC), primarily intended for process-control applications. For this reason, it seems to be more hardware-oriented, while the original PATB does not get the user involved in knowing absolute memory locations, hex math, or I/O ports. If you need to control devices, fine, get 3CB; if not, stick with PATB, which is smaller (1.75KB) and faster. It is unfortunate that 3CB is available only in copies that run at E400 (not zero), which many people will find to be a major obstacle in their use of 3CB, unless they want to burn it into a few PROMs on a Bytesaver.

(ROCHE> There were 2 versions of 3CB: the one at E400 was named CB-308, the one at zero MCB-216...)


EOF

[rand...@hotmail.com]

The 8 bit tiny basics were used for a lot more than fun and games.

They were used in industrial applications in place of the micro-controller apps used today.

The were also used as test bed to build algorithms that were then translated to assembly language.

There were development boards made to support industrial applications then as now.

Tiny basics had full hardware control and could control ports for direct process control.

Used in everything from traffic control to industrial air conditioners to anything you can imagine.


Randy

[Ed]

dott.Piergiorgio wrote:
> ...

> Thanks. and more thanks for having uploaded also THE primary source on
> criticism of numbered-line-based BASIC language, the 1970 "Notes on
> avoiding GOTO statement" aka "GOTO considered harmful" :)
>
> Thanks and
>
> Best regards from Italy,
> dott. Piergiorgio.

Unfortunately the "GOTO considered harmful" statement has been so oft
repeated that it came to mean GOTO should never be used. It's unlikely
Wirth intended that but it was a mantra quickly taken up vendors offering
alternatives to the BASIC's provided with early microcomputer systems.

[Udo Munk]

On Thursday, September 1, 2016 at 8:13:09 PM UTC+2, Mr. Emmanuel Roche, France wrote:
> Randy wrote:
>
> > One early tiny basic computer I used to work on some traffic control apps was the Cromemco SCC. The software was tested on the SCC before building a system to be used (the SCC did not handle the environmental specs).
>
>
> - "Review of 5 Small Interpreters"
> David North
> "Creative Computing", Vol.3, No.5, Sept./Oct. 1977, p.299
>
> (Retyped by Emmanuel ROCHE.)
>
> Cromemco 3K Control BASIC ("3CB")
> -------------------------

Manual and ROM image are available here:

http://www.autometer.de/unix4fun/z80pack/ftp/cromemco/

Can be loaded into the Cromemco Z-1 emulation, no sources available
so far.

[unk]

On Wed, 31 Aug 2016 20:19:24 -0700, randy482 wrote:

> Some languages have a got some do not.
>
> Some have indexed gotos.
>
> Palo Alto has computed gotos, this allows things like a menu selection
> easy. Just go to input value time a multiplier add a constant now you
> have a line number based on menu selection.
>

So did Sinclair basic in the zx81, indeed *everything* was computed in-
line. I cannot remember if it would automatically convert non-integer
results to integer line numbers...

It also had the simplest best string slicing syntax - a single
expression, no bothering with right$/left$/mid$: instead "<x> TO <y>" and
of course the <x> and <y> could be computed values.

[dott.Piergiorgio]

On 01/09/2016 05:19, rand...@hotmail.com wrote:
> Some languages have a got some do not.
>
> Some have indexed gotos.
>
> Palo Alto has computed gotos, this allows things like a menu
> selection easy. Just go to input value time a multiplier add a
> constant now you have a line number based on menu selection.

I must confess, some decades ago I experimented with the usage of
computed goto as "harmful implement" ;) namely using calculated GOTO as
ersatz GOSUB/RETURN:

120 A=120: GOTO 4000
[...]
4020: GOTO A+1

I leave to the fellow denizens of c.o.cpm the classification of the
"harmful implement" above, I, being partial of my pet idea, I consider
it a Katana, but YMMV. :D

[Charles Richmond]

"Ed" <inv...@nospam.com> wrote in message
news:nqaidc$1q0t$1...@gioia.aioe.org...

It was Professor Edsger W. Dijkstra who wrote the influential paper: "GOTO
Considered Harmful".

https://en.wikipedia.org/wiki/Edsger_W._Dijkstra

--

numerist at aquaporin4 dot com

[rand...@hotmail.com]

Water is harmful, it kills more people than you know.

We can not live without poisons, we can not survive without water.

Poisons can kill us, water can kill us.


Goto is a tool, no more no less.



Randy

[Udo Munk]

On Monday, September 5, 2016 at 2:10:07 AM UTC+2, Charles Richmond wrote:

> It was Professor Edsger W. Dijkstra who wrote the influential paper: "GOTO
> Considered Harmful".
>
> https://en.wikipedia.org/wiki/Edsger_W._Dijkstra

That paper never was influential, it was ignored, or how come that
more modern languages like C#, Objective C++ and who knows what of
course implement goto?

And here, really nice one, tee hee:

https://github.com/footloosejava/JavaGoto

[Udo Munk]

On Saturday, September 3, 2016 at 11:57:29 AM UTC+2, dott.Piergiorgio wrote:

> I must confess, some decades ago I experimented with the usage of
> computed goto as "harmful implement" ;) namely using calculated GOTO as
> ersatz GOSUB/RETURN:
>
> 120 A=120: GOTO 4000
> [...]
> 4020: GOTO A+1

With BASIC on a 8008 or similar limited CPU you have to do it like this.

[rand...@hotmail.com]

With unlimited resources it is easy to throw away resources other people have ordered you to ignore.

Me I prefer to use the tools given to me and think for myself.

I write programs I am proud of and I believe are commented well enough to be understandable by other. I do this because I have seen so many poorly written programs - especially by "structured" programmers that don't know what they are doing.

Today more than ever schools are not a place of learning. Schools today are run by Nazi's that rather than teach you how to learn try to teach you how to think.


Randy

[Udo Munk]

There are so many places nowadays, where people hack digital devices
to the finest, exploiting everything doable, including tricky programming.

Has to do with the software terrorists trying to force very bright and intelligent
people to do religious stuff, that won't make logical sense. They might trying
to brainwash you in school, 'managed' jobs, whatever, but there's always escape
from that, no matter what. Even repeating the 'goto harmful' mantra for almost
50 years did not work. So for your own fun always program as you can and like,
doesn't matter what others think about your private stuff.

Of course it is better to program in structures, comment sources at least good
enough, so that you self understand what you were doing after years, and
keep goto's and the like to a minimum, but this is best done by learning it your
self.

[Charles Richmond]

<rand...@hotmail.com> wrote in message
news:71c0dff4-1e19-49ec...@googlegroups.com...

Structured programming languages use GOTO "behind the scenes". It pretty
much shields the programmer from using a bare "GOTO" in his/her code. There
are *too* many really bad programmers who would... without something
restraining them... write "spagetti code" with incomprehensible branching
directly using bare "GOTO"s. The unrestrained direct use of bare GOTO's
*is* harmful, just like shooting a gun into the air...

If the troll is still hungry, he'll have to feed himself...

[Charles Richmond]

"Udo Munk" <udo....@freenet.de> wrote in message
news:3e40a551-7504-4bff...@googlegroups.com...

Ahem... the point I was *trying* to make, Udo... was that the *idea* of GOTO
being harmful is attributed to Edsger Dijkstra, *not* Niklaus Wirth.

[Charles Richmond]

"Udo Munk" <udo....@freenet.de> wrote in message

news:a17488a0-5e04-4293...@googlegroups.com...

I very much agree, Udo. If one has a *good* reason to use a direct, bare
GOTO... then fine. But when there are safer and often more understandable
alternatives, I prefer to use those. It's *not* just others who have to
read my code six months from now... *I* have to be able to understand it
myself!!! :-)

It's very true that *bad* programs can be written in *any* language. I had
to take over a program at a PPoE once... that was *so* bad, I had to throw
out the code and start over!!! I knew what the other guy was trying to
accomplish, but his code was horrible!!! It was C code, and he had a
*variable* named FALSE (yes, all uppercase). And the variable was set to
different values, *not* just zero or one!!! Instead of creating a function,
he would copy the code for the function whenever he should be calling a
function. The indentation was all over the place... it had *no* rhyme or
reason. The hardest thing to understand... was why the company had *not*
fired this guy a long time ago!!!

Outside of APL and assembly language, I have found almost *no* need for
using a direct GOTO. I once had to use a "setjmp()/longjmp()" along with a
timer... used to wait for a communication from another program and continue
if the communication did *not* arrive within a two minute window.

[Ed]

> ...

But it was Wirth who coined the title everybody knows today :)

"The original title of the letter, as submitted to CACM, was 'A Case Against the
Goto Statement', but CACM editor Niklaus Wirth changed the title to 'Go To
Statement Considered Harmful'."
https://en.wikipedia.org/wiki/Considered_harmful

[rand...@hotmail.com]

As I said people drown in water, can we all agree we should outlaw water?

The goto statement isn't harmful - it is poor programmers that are harmful.

When teachers say they are too stupid to teach you how to be a good programmer lets just not teach part of it is just funny.

And even funnier when idiots that never learned how to program correctly turn around and believes the idiots that taught them to be idiots.


Randy

[dott.Piergiorgio]

well, the stunt was done on a C=64 (6502 m$ basic 8k) circa mid-80s in a
context of "experimenting on obfuscation"...

Best regard from Italy,
dott. Piergiorgio.

[dott.Piergiorgio]

On 05/09/2016 20:15, rand...@hotmail.com wrote:
> With unlimited resources it is easy to throw away resources other
> people have ordered you to ignore.
>
> Me I prefer to use the tools given to me and think for myself.
>
> I write programs I am proud of and I believe are commented well
> enough to be understandable by other. I do this because I have seen
> so many poorly written programs - especially by "structured"
> programmers that don't know what they are doing.

well, this led to an interesting question: I'm assessing, in a
retrocomputing context, of doing a "working" and "documented" version
(basically, having a version with REMs and another without; and this led
to the actual question: exist that animal, a "remkill" utility, for CP/M
BASICs ? the indexing of the CP/M archives is sometimes lacking in
clarity... on context, esp. the oldest ones..

Best regards from Italy,
dott. Piergiorgio.

p.s. fall here, and I can remove the cooling brakes to the emulators
(200+ Mhz instead of 1-4 in the CP/M field, in this case)

[rand...@hotmail.com]

The big question is are you really stupid or just pretending to be. When using interpreted languages with tight resources it was common to have a master program with remarks and another compressed version to fit on computers without enough memory.

There were several utilities written to compress files by removing remarks and merging multiple lines together using colons.

The final version used on these limited resource computers were harder to read than the master but that was a necessity of the computer.

Some of these programs had synopsis written to help but they were never going to be able to be written clearly and run.

It is a bit like compare a mnemonic version of a program to an object version.


Randy

[dott.Piergiorgio]

On 07/09/2016 12:51, rand...@hotmail.com wrote:
> The big question is are you really stupid or just pretending to be.

the other big question is if you are really unrefined or pretending to
be....

[rand...@hotmail.com]

On Wednesday, September 7, 2016 at 5:54:36 AM UTC-5, dott.Piergiorgio wrote:

> On 07/09/2016 12:51, randy wrote:
> > The big question is are you really stupid or just pretending to be.
>
> the other big question is if you are really unrefined or pretending to
> be....

I am unrefined and do not put up with fools trying to prove their point with evidence unrelated to the topic.

Next time when you see an odd utility consider why people would want to use it. In this case to save space as number one and purposely hide their code from others as a possible second reason. Neither of which supports your supposition.

You have obviously never had to count bytes when you program yet choose to pick a forum and a specific topic based on that very idea, how many bytes can I do it in.

Please either learn what CP/M and Tiny means before writing stupid posts or go find a Windoze forum to prove who you are.


Randy

[Jeff Albrecht]

On Monday, August 22, 2016 at 12:08:42 PM UTC-7, Udo Munk wrote:
> Li-Chen Wang published a Tiny BASIC for the 8080 in Dr. Dobbs magazine
> Volume 1 Nr. 5 in 1976. This was the famous Copyleft version in response
> to the Gates letter.

Slightly off topic in that this is for a 6800 4K basic... I was looking through some old Interface Age Magazines a couple weeks ago when this thread started and noticed a "Floppy ROM" of 6800 4K Basic. I got around to putting up a short page this morning. Check it out; source code distributed in a magazine on a plastic record.

http://retrowagon.org/wiki/index.php/Interface_Age_Floppy_ROM

[Bill]

On Tue, 23 Aug 2016 21:42:47 -0500, Bill <bi...@sunsouthwest.com>
wrote:

>On Mon, 22 Aug 2016 12:08:41 -0700 (PDT), Udo Munk
><udo....@freenet.de> wrote:
>
>>Li-Chen Wang published a Tiny BASIC for the 8080 in Dr. Dobbs magazine
>>Volume 1 Nr. 5 in 1976. This was the famous Copyleft version in response
>>to the Gates letter.

>Seems to me, Kildall mentioned knowing Tom Pittman, and his Tiny
>Basic.
>Bill

Kildall mentioned meeting/knowing Pittman in connection with Pittman
working at Intel, and being the developer of Tiny-C for the 4004

Wasn't this mentioned in the so-called ''redacted Computer
Chronicles'' mentioned here a couple months ago?

Bill

[dott.Piergiorgio]

On 29/09/2016 19:08, Bill wrote:

>>> Li-Chen Wang published a Tiny BASIC for the 8080 in Dr. Dobbs magazine
>>> Volume 1 Nr. 5 in 1976. This was the famous Copyleft version in response
>>> to the Gates letter.
>
>> Seems to me, Kildall mentioned knowing Tom Pittman, and his Tiny
>> Basic.
>> Bill
>
> Kildall mentioned meeting/knowing Pittman in connection with Pittman
> working at Intel, and being the developer of Tiny-C for the 4004

sure that you remember well ? I have really hard time imagining a tiny C
for the 4004....

[George Phillips]

Slightly misremembered, yes. Here's the quote from page 42 of Kildall's redacted autobiography:

I met Tom Pittman on a journey to Intel. To me, Tom is the first personal
computer developer and user. (Later, Tom wrote Tiny-C, for which he is
best known.) Clever Tom wrote a "monitor" for the 4004, and a small
assembler that actually ran on the SIM4-01 itself.

This, in effect, was the first self-hosted single chip microprocessor
development system. Tom's "monitor" took 257 bytes, one more than the 1702
EPROM could hold. He condensed that to 256 bytes without changing the
monitor. Ask him how he did it if you run into old Tom, or if you ask me,
maybe I'll tell you

[Bill]

On Sun, 2 Oct 2016 16:03:38 -0700 (PDT), George Phillips
<gp2...@gmail.com> wrote:

>
>Slightly misremembered, yes. Here's the quote from page 42 of Kildall's redacted autobiography:
>
> I met Tom Pittman on a journey to Intel.

Page 42, check. How many pages in total?

My purported to be original is 232 plus appendices

Bill

[George Phillips]

On Monday, October 3, 2016 at 5:48:14 AM UTC-7, Bill wrote:
> Page 42, check. How many pages in total?
>
> My purported to be original is 232 plus appendices

I have the partial one released through the Computer History Museum:

http://www.computerhistory.org/atchm/in-his-own-words-gary-kildall/

It is 78 pages and ends with Chapter 7 "Digital Research".

Based on the family's reasons to publish only an excerpt, I imagine the rest of it is factually suspect, libelous and embarrassing.

[Bill]

On Mon, 3 Oct 2016 10:22:17 -0700 (PDT), George Phillips
<gp2...@gmail.com> wrote:

>It is 78 pages and ends with Chapter 7 "Digital Research".
>
>Based on the family's reasons to publish only an excerpt, I imagine the rest of it is factually suspect, libelous and embarrassing.

From page 78: ''The Microsoft, IBM, and DRI Challenge''

'' I apologize that this is a rather serious section, and I have been
advised not to write this story, because Bill Gates has sufficient
monetary resources to bury me if he so desires. However. I am writing
the truth, and the truth cannot be denied in any Court of Law''

Seems to me, Kildall believed what he had to share was the truth.

Bill

[franzp...@gmail.com]

On Monday, August 22, 2016 at 9:08:42 PM UTC+2, Udo Munk wrote:
> Li-Chen Wang published a Tiny BASIC for the 8080 in Dr. Dobbs magazine
> Volume 1 Nr. 5 in 1976. This was the famous Copyleft version in response
> to the Gates letter.
>

> I was not able to find the source for the original anywhere, but an archived
> PDF of the Dr. Dobbs issue with a listing of the BASIC interpreter.
>
> Unfortunately Li-Chen had no 8080 assembler, so he used the Macro Assembler
> from some Mainframe with a Macro set to produce 8080 object code.
>
> Besides that the syntax makes my eyes bleed, the Macro set used is not available.
> So I converted the source to Intel 8080 Macro Assembler syntax, the assembler is
> available and so the source can be modified and the object file build, hope that's
> in the spirit of Li-Chen.
>
> The original program is for the Altair 8800 with 88SIO Rev. 0, you might need
> to modify it for the machine you use. I/O is done in 2 subroutines only, so that's
> very easy.
>
> I compared the hex bytes against the ones in the Dr. Dobbs listing, matches, so
> the program is correct, typos in the comments are my fault.
>
> All relevant files are available at:
> http://www.autometer.de/unix4fun/z80pack/ftp/altair/
>
> There was a 2.0 version, also translated to 8080 mnemonics by Roger Rauskolb,
> published in Interface Age December 1976 issue. I cannot find the source file
> nor the archived magazine, so if anyone has this version I would like a copy,
> thanks in advance.

[franzp...@gmail.com]

I still have a pdf file of my original article
contact me if you would like to have a copy

Roger Rauskolb

[Udo Munk]

On Thursday, September 20, 2018 at 12:20:51 AM UTC+2, franzp...@gmail.com wrote:
> On Monday, August 22, 2016 at 9:08:42 PM UTC+2, Udo Munk wrote:

...

> > There was a 2.0 version, also translated to 8080 mnemonics by Roger Rauskolb,
> > published in Interface Age December 1976 issue. I cannot find the source file
> > nor the archived magazine, so if anyone has this version I would like a copy,
> > thanks in advance.
>
> I still have a pdf file of my original article
> contact me if you would like to have a copy
>
> Roger Rauskolb

Thank you very much. The CHM had the article and made it available. I typed
in your source from it and made it available too here:

https://www.autometer.de/unix4fun/z80pack/ftp/altair/

So whoever wants still can try it out on 8080 systems.

Best regards,
Udo Munk

[fit...@gmail.com]

On Monday, August 22, 2016 at 3:08:42 PM UTC-4, Udo Munk wrote:
...

>
> There was a 2.0 version, also translated to 8080 mnemonics by Roger Rauskolb,
> published in Interface Age December 1976 issue. I cannot find the source file
> nor the archived magazine, so if anyone has this version I would like a copy,
> thanks in advance.

Udo,
archive.org has the 197612 version of Interface Age.
https://archive.org/details/InterfaceAge197612

Best wishes,
Fitz

[Udo Munk]

On Thursday, May 9, 2019 at 12:28:51 AM UTC+2, fit...@gmail.com wrote:

> Udo,
> archive.org has the 197612 version of Interface Age.
> https://archive.org/details/InterfaceAge197612
>
> Best wishes,
> Fitz

Thanks, I got it a while ago and version 2.0 from the publication
is available as source file.

[Udo Munk]

On Thursday, August 25, 2016 at 8:30:12 PM UTC+2, Udo Munk wrote:
> Version 2.0 fixes a few things but adds a new bug, multiplication
> of negative number with Null won't work anymore.

I've added a fix for the sign bug, updated source, listing and hex
files are here:

https://github.com/udo-munk/z80pack/tree/dev/altairsim

[Udo Munk]

On Monday, August 22, 2016 at 9:08:42 PM UTC+2, Udo Munk wrote:
> There was a 2.0 version, also translated to 8080 mnemonics by Roger Rauskolb,
> published in Interface Age December 1976 issue.

And there was a 3.0 version in 1977, I've put the PDF document with the source
listing here:

https://www.autometer.de/unix4fun/z80pack/ftp/altair/

[Mr. Emmanuel Roche, France]

Udo Munk wrote:

> And there was a 3.0 version in 1977

According to Google, I published the doc and the source code the Saturday 7 June 2003. That's why it is widely available on the Internet.

Yours Sincerely,
Mr. Emmanuel Roche, France

[Nick Rosenberg]

On Monday, August 22, 2016 at 8:08:42 PM UTC+1, Udo Munk wrote:
> Li-Chen Wang published a Tiny BASIC for the 8080 in Dr. Dobbs magazine
> Volume 1 Nr. 5 in 1976. This was the famous Copyleft version in response
> to the Gates letter.
>
> I was not able to find the source for the original anywhere, but an archived
> PDF of the Dr. Dobbs issue with a listing of the BASIC interpreter.
>
> Unfortunately Li-Chen had no 8080 assembler, so he used the Macro Assembler
> from some Mainframe with a Macro set to produce 8080 object code.
>
> Besides that the syntax makes my eyes bleed, the Macro set used is not available.
> So I converted the source to Intel 8080 Macro Assembler syntax, the assembler is
> available and so the source can be modified and the object file build, hope that's
> in the spirit of Li-Chen.
>
> The original program is for the Altair 8800 with 88SIO Rev. 0, you might need
> to modify it for the machine you use. I/O is done in 2 subroutines only, so that's
> very easy.
>
> I compared the hex bytes against the ones in the Dr. Dobbs listing, matches, so
> the program is correct, typos in the comments are my fault.
>
> All relevant files are available at:
> http://www.autometer.de/unix4fun/z80pack/ftp/altair/
>

> There was a 2.0 version, also translated to 8080 mnemonics by Roger Rauskolb,