Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Posting-Version: $Revision: 1.6.2.16 $; site ima.UUCP
Path: utzoo!watmath!clyde!bonnie!akgua!gatech!seismo!harvard!bbnccv!ima!johnl
From: johnl@ima.UUCP
Newsgroups: net.micro
Subject: Re: Re: 386 Family Products (8086 sucks
Message-ID: <97800013@ima.UUCP>
Date: Fri, 6-Dec-85 22:35:00 EST
Article-I.D.: ima.97800013
Posted: Fri Dec  6 22:35:00 1985
Date-Received: Mon, 9-Dec-85 03:12:45 EST
References: <133@daisy.UUCP>
Lines: 43
Nf-ID: #R:daisy:-13300:ima:97800013:000:2473
Nf-From: ima!johnl    Dec  6 22:35:00 1985


/* Written  1:44 pm  Dec  3, 1985 by 5@utzoo@ecn-pc in ima:net.micro */
>>>>As in "I'll be rich if I can only convince my program to run on this
>>>>@%&$^%$#!& processor with those @$#@#&^%&! 64KB segments!"?  :-) :-)
>>>2) High level languages make this problem transparent to the user.
>>     What about "modules" which have to call other "modules" that are
>>     not in the same segment?  How about compiler models?  How do they
>>     impact execution speed?  
>Nor will I dispute that the segmented architecture can degrade (significantly)
>the performance of the Intel products in many "real world" situations.  
>In the vast majority of situations, the problem is made transparent to the 
>PROGRAMMER using high level languages.  That does not imply that it will occur 
>without a penalty such as a more complex compiler or a degrading of performance
>due to an increase in overhead or that it is often necessary to "code around"
>the problems that a (64k) segmented architecture causes.
>Thank heaven that a good compiler can help hide strange hardware from the 
>programmer.

Oh, stop it.  It's just not true that existing compilers can hide the 
808x's segmentation.  I have just spent the last year and a half writing a 
large program for the 808x with 5 other people.  We spent about 1/4 of our 
time dealing with the addressing nonsense on the Intel chip.  The problem 
is that if you have more than 64K total of data, you have to worry about 
allocating that data to segments, and about addressing those segments.  
Compilers are not much help.

I really wish that it were true that a good compiler existed that could 
hide the addressing from us, but it's not.  I looked hard, and there is no 
compiler of any sort that simultaneously hides the addressing problems and 
generates code adequate for programs that one can sell.  There just isn't.  
Nor is there likely to be one any time soon.  Please correct me if I'm 
wrong, but don't bother if you haven't run at least a 1,000 line program 
through your compiler.  

The sooner the 386 gets into the world and lets me ignore segmentation, the 
better.  You'd think that a 386, having thousands of segments each which 
can be huge, would let you make real use of segmentation, but you'd be 
wrong because there are no languages around that make using them worth it.  

John Levine, ima!johnl

PS:  PL/I "areas" are the closest I've seen to a high-level equivalent of
big segments, and they're still awful.