Re: Apple and the Holy War

[pausch@saafNOSPAM.se (Paul Schlyter)]

In article <8i0shskahio76qoj8f8o4d7jaqfr9rhv4s@news.newsguy.com>,
Paul Guertin  <pg@sff.net> wrote:
 
> pausch@saafNOSPAM.se (Paul Schlyter) wrote:
> 
>>> other's. But Paul, one of the early programs written on the DEC PDP -1 at
>>> MIT was a program called "Expensive Typewriter" the first known word
>>> processor. In the late 1950s.
>>  
>> BTW I believed at that time the very first computer games were also
>> created.
> 
> PDP-1 Spacewar (early 1960s) is considered by many to be the first video
> game. You use a joystick to maneuver a spaceship and try to shoot the
> other player down. See http://www.wheels.org/spacewar/index.html and
> http://www.enteract.com/~enf/lore/spacewar/spacewar.html for screen shots
> and information. You can play Spacewar in a Java PDP-1 emulator at
> http://kame.media.mit.edu/groups/el/Projects/spacewar/ . Have fun!
> 
> Everyone interested in the early days of computing (from the mainframe
> hackers to the video game boom of the 80s) should read the book "Hackers:
> Heroes of the Computer Revolution" by Steven Levy (see
> http://www.stevenlevy.com/hackers.html ).
 
Highly recommended reading!  This book starts around the PDP-1 era,
and ends in the 1980'ies with, among other things, Ken and Roberta
Williams adventures.
 
 
>> The CDC 6600 had a quite odd archtecture: it was word-addressed and
>> had 60-bit words.  Addresses were 18-bits, which means it could
>> address 256 Kwords (which approximately corresponds to some 2
>> MBytes).  It had no hardware stack, which made recursive functions
>> quite hard to implement.  The standard approach was to reserve the
>> first word of each function for the return address: the caller would
>> then store its return address there and then start executing code at
>> the next word - when returning, an indirect jump was made to that
>> first word. 
> 
> I believe this is also how the RCA 1802 microprocessor does it -- if
> you need recursion or reentrancy, just implement a stack in software.
> The 1802 is a cute and minimalist processor that should appeal to many
> 6502 enthusiasts.
 
The 1802 was quite flexible: it had a set of CPU registers (6 or 7 or so)
which could take any functionality the programmer wanted.  One could
at any time switch e.g. program counter or stack pointer at the will
of the programmer.
 
The CPU of the CDC 6600 was much less flexible: there were 8 data
registers of 60 bits each and 8 address registers of 18 bits each.
Some address and data registers were pre-allocated: one address
register was the program counter, and one data register was the
accumulator.
 
The data registers could be used to store integers (60 bits) or
floating-point values (49 bits mantissa, 11 bits exponent).  When
doing integer arithmetic, the full 60 bits were used for addition and
subtraction, but in integer multiplication and division the numbers
were first converted to floating-point, then the mul/div was
performed and finally the result was converted back to integer.  This
meant only 49 bits and not the full 60 bits were available for
integer mul/div -- so you could add/subtract larger integers than
you could multiply/divide on that machine!!!
 
The CDC 6600 also used a somewhat odd way to represent negative
numbers: one's complement, i.e. all bits were flipped.  This wasn't
applied to only integers but to floating-point values as well:
to negate a CDC 6600 floating-point value you just inverted all
the 60 bits - both mantissa and exponent !!!!!
 
The custom today is to use two's complement for integers and
sign-magnitude for floating-point values (the latter means a separate
"sign bit" is used to represent the sign).
 
-- 
----------------------------------------------------------------
Paul Schlyter,  Swedish Amateur Astronomer's Society (SAAF)
Grev Turegatan 40,  S-114 38 Stockholm,  SWEDEN
e-mail:  pausch at saaf dot se   or    paul.schlyter at ausys dot se
WWW:     http://hotel04.ausys.se/pausch    http://welcome.to/pausch