f



Palo Alto Tiny BASIC 1.0 for 8080

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.
0
Udo
8/22/2016 7:08:41 PM
comp.os.cpm 3422 articles. 0 followers. Post Follow

60 Replies
1460 Views

Similar Articles

[PageSpeed] 7

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

0
Peter
8/23/2016 11:22:59 AM
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

0
Peter
8/23/2016 3:27:12 PM
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)


0
Al
8/23/2016 4:19:42 PM
On 23.08.2016 at 18:19 Al Kossow wrote:
> 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)
>

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

Regards
  Peter

0
Peter
8/23/2016 4:38:00 PM
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.
0
Udo
8/23/2016 5:09:54 PM
On Tuesday, August 23, 2016 at 6:16:31 PM UTC+2, Al Kossow wrote:
> 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)

Many thanks Al, much appreciated, I'll pick it up when available here
and try to get it working.
0
Udo
8/23/2016 5:11:52 PM
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...
0
Udo
8/23/2016 5:16:37 PM
On Mon, 22 Aug 2016 12:08:41 -0700 (PDT), Udo Munk
<udo.munk@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
0
Bill
8/24/2016 2:42:47 AM
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.



0
Ed
8/24/2016 3:29:01 AM
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.
0
Udo
8/24/2016 10:30:36 AM
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.

0
Udo
8/24/2016 10:48:48 AM
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.
0
Udo
8/25/2016 6:30:11 PM
On 23/08/2016 18:19, Al Kossow wrote:
> 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)

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.


0
dott
8/30/2016 12:34:21 PM
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
>
0
Udo
8/30/2016 3:30:54 PM
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

0
Peter
8/31/2016 10:59:26 AM
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.
0
Udo
8/31/2016 12:26:00 PM
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
0
randy482
8/31/2016 6:01:10 PM
On Wednesday, August 31, 2016 at 8:01:13 PM UTC+2, rand...@hotmail.com wrote:
> 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.

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.
0
Udo
8/31/2016 10:05:22 PM
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 n=
ot need to be just a relational database application even though the langua=
ge is biased as such, just as Cobol is accounting biased it is a general pu=
rpose language.

The simple fact is to avoid jumps/gotos is possible doing so can add so muc=
h 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 quic=
kly 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 effi=
ciently 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 1=
6K computer without jump instructions.

Please don't be that obnoxious know it all that knows nothing but what he i=
s 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.  Yo=
u can write a structured program without any gotos and be both huge and con=
fusing 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
0
randy482
8/31/2016 10:30:36 PM
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 const=
ructs, you'll find these programs are messes and very frustrating to deal w=
ith.

The people writing them also have a hard time understanding what is going o=
n -- I've found in almost all the programs I've looked at the original auth=
or couldn't determine what variables were currently active so he just inven=
ted new ones with the result that there are many more variables present tha=
n needed, something of a problem in small memory environments.  It goes wit=
hout 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 t=
he 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 el=
se 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 structu=
red constructs makes such code very difficult to maintain or understand.  T=
his is why GOTO deservedly has a bad rep.

I did some programming in Fortran77 too which also did not have anything bu=
t goto to change program flow.  The difference was the programmers were tra=
ined to simulate for, while, repeat, and so on with boiler plate forms and =
properly indented source code to indicate the construct's extent.  This mad=
e 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 an=
ything about structured programming or program maintenance (beginner's all =
purpose instruction code, after all)  and (2) basic was interpretted and mo=
st commonly had its source squashed into memory co-resident with the interp=
retter in a tokenized form minus any whitespace someone might add to help i=
dentify control structures.

In conclusion, I would broadly agree with anyone who says GOTO is a disaste=
r because usually it's misused.  It is, however, approporiate in some circu=
mstances.
0
1alvinalbrecht1
8/31/2016 11:16:28 PM
Pats you on the head gently and says go on little boy, come back when you grow up.


Randy
0
randy482
8/31/2016 11:31:07 PM
On Wednesday, August 31, 2016 at 5:07:22 PM UTC-5, Udo Munk wrote:
> On Wednesday, August 31, 2016 at 8:01:13 PM UTC+2, rand...@hotmail.com wrote:
> > 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.
> 
> 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.

FYI, Javascript doesn't have a goto statement.
0
Mark
9/1/2016 2:06:11 AM
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 di=
alects were developed for a variety of uses.  Palo Alto was commonly used f=
or control process.  It and other tiny basics could have simple programs qu=
ickly written to do specific tasks controlling equipment with very few comp=
uting 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 w=
as 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
0
randy482
9/1/2016 3:19:24 AM
1alvinalbrecht1@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

-- =

/=AF\   No  |    Dipl.-Ing. F. Axel Berger    Tel: +49/ 221/ 7771 8067
\ /  HTML |    Roald-Amundsen-Stra=DFe 2a     Fax: +49/ 221/ 7771 8069
=A0X    in  |    D-50829 K=F6ln-Ossendorf      http://berger-odenthal.de
/ \  Mail | -- No unannounced, large, binary attachments, please! --
0
Axel
9/1/2016 7:49:31 AM
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 ;-)
0
Udo
9/1/2016 10:12:44 AM
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).

0
Peter
9/1/2016 10:22:22 AM
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.
0
Udo
9/1/2016 10:46:10 AM
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.

0
Peter
9/1/2016 11:26:40 AM
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.
0
Udo
9/1/2016 11:34:11 AM
On 01.09.2016 um 13:34 Udo Munk wrote:
> 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.
>
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.

0
Peter
9/1/2016 11:45:19 AM
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.
0
Udo
9/1/2016 11:50:03 AM
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 ar=
e 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 memor=
y with LOCK, LOAD, SAVE, and EPROM commands. These programs can be called b=
y other programs with a special version of the RUN command. A STOP in a cal=
led 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 doe=
s 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 3C=
B is available only in copies that run at E400 (not zero), which many peopl=
e 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

0
Mr
9/1/2016 6:13:08 PM
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
0
randy482
9/1/2016 6:26:39 PM
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.



0
Ed
9/2/2016 12:51:37 AM
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.
0
Udo
9/2/2016 9:03:47 AM
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.

0
unk
9/2/2016 10:51:57 AM
On 01/09/2016 05:19, randy482@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

Best regards from Italy,
dott. Piergiorgio.
0
dott
9/3/2016 9:57:27 AM
"Ed" <invalid@nospam.com> wrote in message 
news:nqaidc$1q0t$1@gioia.aioe.org...
> 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.
>

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

0
Charles
9/5/2016 12:10:01 AM
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
0
randy482
9/5/2016 12:15:36 AM
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



0
Udo
9/5/2016 4:05:40 PM
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.
0
Udo
9/5/2016 4:13:23 PM
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
0
randy482
9/5/2016 6:15:48 PM
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.

0
Udo
9/5/2016 7:05:04 PM
<randy482@hotmail.com> wrote in message 
news:71c0dff4-1e19-49ec-9eea-187c91e99c25@googlegroups.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.
>

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...

-- 

numerist at aquaporin4 dot com

0
Charles
9/6/2016 12:49:49 AM
"Udo Munk" <udo.munk@freenet.de> wrote in message 
news:3e40a551-7504-4bff-9f6a-4a7235ffa7d1@googlegroups.com...
> 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
>

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.

-- 

numerist at aquaporin4 dot com

0
Charles
9/6/2016 12:52:12 AM
"Udo Munk" <udo.munk@freenet.de> wrote in message 
news:a17488a0-5e04-4293-9390-5219190521ae@googlegroups.com...
> 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.
>

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.

-- 

numerist at aquaporin4 dot com

0
Charles
9/6/2016 1:04:22 AM
Charles Richmond wrote:
> "Ed" <invalid@nospam.com> wrote in message
> news:nqaidc$1q0t$1@gioia.aioe.org...
> > 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.
> >
>
> It was Professor Edsger W. Dijkstra who wrote the influential paper:  "GOTO
> Considered Harmful".
> ...

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



0
Ed
9/6/2016 1:53:31 AM
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
0
randy482
9/6/2016 3:10:19 PM
On 05/09/2016 18:13, Udo Munk wrote:
> 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.

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.

0
dott
9/7/2016 10:05:08 AM
On 05/09/2016 20:15, randy482@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)
0
dott
9/7/2016 10:10:58 AM
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
0
randy482
9/7/2016 10:51:43 AM
On 07/09/2016 12:51, randy482@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....

0
dott
9/7/2016 10:54:36 AM
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
0
randy482
9/7/2016 6:55:09 PM
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 thr=
ough some old Interface Age Magazines a couple weeks ago when this thread s=
tarted 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 m=
agazine on a plastic record.

http://retrowagon.org/wiki/index.php/Interface_Age_Floppy_ROM
0
Jeff
9/14/2016 4:17:31 PM
On Tue, 23 Aug 2016 21:42:47 -0500, Bill <bill@sunsouthwest.com>
wrote:

>On Mon, 22 Aug 2016 12:08:41 -0700 (PDT), Udo Munk
><udo.munk@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
0
Bill
9/29/2016 5:08:13 PM
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....

Best regards from Italy,
dott. Piergiorgio.

0
dott
10/2/2016 7:32:03 AM
On Sunday, October 2, 2016 at 12:32:04 AM UTC-7, dott.Piergiorgio wrote:
> 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....

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

0
George
10/2/2016 11:03:38 PM
On Sun, 2 Oct 2016 16:03:38 -0700 (PDT), George Phillips
<gp2k00@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
0
Bill
10/3/2016 12:48:24 PM
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.
0
George
10/3/2016 5:22:17 PM
On Mon, 3 Oct 2016 10:22:17 -0700 (PDT), George Phillips
<gp2k00@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
0
Bill
10/5/2016 1:25:36 PM
Reply: