Re: Alternatives to C: ObjectPascal, Eiffel, Ada or Modula-3?

[wwilson <leon.winslow@notes.udayton.edu>]

On Sat, 25 Jul 2009 02:05:03 -0400, robertwessel2@yahoo.com  
<robertwessel2@yahoo.com> wrote:

> On Jul 24, 8:15 pm, wwilson <leon.wins...@notes.udayton.edu> wrote:
>> On Fri, 24 Jul 2009 05:31:45 -0400, Jon Harrop <j...@ffconsultancy.com>  
>>  
>> wrote:
>>
>> > tm wrote:
>> >> Simplicity of languages and their implementation got lost somehow...
>>
>> > The F# team at Microsoft used to advertise that their compiler was  
>> under
>> > 10kLOC.
>>
>> Am I the only one that remembers when computers came with a maximum of  
>> a  
>> few kbytes.  I personally know of one full FORTRAN IV compiler for the  
>> IBM  
>> 1130 that fit into 8 K bytes.  My favorite programming feat was the way  
>>  
>> that IBM squeezed a whole COBOL compiler into 1400 bytes on the IBM  
>> 1401.
>
>
> While it’s true that compilers of that era ran in very small amounts
> of memory, they often ran very many passes, the code for each of which
> was loaded sequentially, and much use was made of temporary files to
> hold intermediate transformations of the program being compiled.  Some
> compilers used upwards of 20 passes (which wasn't great for
> compilation speeds either).  The compilers were in fact much larger
> than could fit in memory (at least on the smaller machines), they just
> arranged things so that it didn't all need to be loaded at once.


Hey,its nice to find somebody who remembers when men were men and  
programmers where gods who walked on the earth.

You are right that in many cases the compilers used multiple passes.  If I  
remmeber correctly, the COBOL compiler for the IBM 1401 used 28 passes.   
But this still meant that the compiler fit in 28*1.4 Kbytes (=39.4 kbytes)  
A remarkable feat.

On the other hand, the FORTRAN compiler that I refered to was developed  
for student use.  It remained in the lower half of memory and the compiler  
put code into the upper half.  The compiler was loaded followed by a stack  
of student jobs which the compiler processed one after the other. (Forward  
references were put into a table and cleaned up after the compiler loaded  
the break card that went between jobs.  Each job executed as soon as it  
was translated and when it finished executing, control returned to the  
compiler for the next job.) For its time and the computer, it was very  
fast and efficient.  Many faculty prefered it to the FORTRAN on the  
school's mainframe (384 Kbytes) which took hours to turn a job around.   
(Of course this meant that your job had to fit iinto 8 kbytes!)

One thing that made a difference is that some of the common languaages of  
that era were designed so that the compiler could determine the kind of  
statement from the first two or three letters of the statement.  Both  
FORTRAN and the early BASICs were this way.  At this point the compiler  
jumped to a statement specific translation.  No LL(1), parse tables, or  
other more powerful techniques needed.  Not that I would give up the  
language advantages that these techniques allow.  There is no free lunch  
and, IMHO, many newer language features justify all the extra power that  
is necessry to compile them.

As I said at the beginning it is good to find someone that remembers and  
cares about the early days.

-- 

Using Opera's revolutionary e-mail client: http://www.opera.com/mail/