From: erc@netcom.com (Eric Smith)
Subject: Gigabytes (was Re: The sin of MicroSoft)
Organization: Netcom - Online Communication Services (408 241-9760 guest)
Date: Thu, 21 Jan 1993 09:53:20 GMT

In article <1993Jan20.192533.20241@ns1.cc.lehigh.edu> bjs4@ns1.cc.lehigh.edu (BENJAMIN J SCHRAGGER) writes:
>I have a few more.
>4) Film and video post production.  with the MCC TB chip you can store

The biggest beneficiary of gigabytes of memory would be software
development.  Software development is a lot more important than most
people realize.  All other computer applications would be ridiculous
pipe dreams without it.

Name one person in all of history who could have imagined modern word
processors and spreadsheets.  No way, no one has an imagination that
weird, to imagine such ridiculous pipe dreams.

Software development can change the world.  We need to find ways to
make it more effective.  For every programmer, there are thousands of
person-years of software development work that needs to be done.  We
need to find ways to enable programmers to work thousands of times
faster than they do now.

Most of the work programmers do now, i.e., most of the time they spend,
is in dealing with limitations of their tools, and/or in doing work
that wouldn't be needed without those limitations.

With gigabytes of memory, we could implement software development
expert systems.  They could do most of the programmer's work, such that
the programmer would just act as a consultant to clarify any issues the
expert system might not be able to resolve due to lack of complete
information.

Consider, for example, the difference between programming in Scheme and
programming in assembler language.  The reason for programming in
assembler language is that it makes it possible to create the tightest
possible code, especially if you are an assembler language expert.  But
an expert Scheme programmer can often get the same program working 1000
times sooner.  So, a good way to get the advantages of both, is to use
Scheme first, and then after the program is done, give it to an
assembler language expert to create the tightest possible code with the
same functionality.

But with gigabytes of memory, that assembler language expert need not
be human.  It can have a large knowledge base about software in general
and about ways of optimizing various kinds of functionality, etc.  Its
knowledge base can help it decide when certain optimizations are safe,
etc., unlike most present optimizers that make half-educated guesses.
It can replace garbage collection with explicit allocation and reuse of
memory such that no time is wasted at all.  That would be terrible if
attempted by human programmers, because it would make their code
unmaintainable.  But when done by software, it would be no problem,
because the maintenance is done to the original source code input to
that software.

There is nothing a human programmer can do, in implementing a program
in assembler language to have the same functionality of a Scheme
program, that can't also be done by software, if the software is at the
same level of expertise as the human.  It needn't have human
intelligence, because Scheme to assembler translation is a fairly
narrow field of knowledge.  So it just needs gigabytes of knowledge
rather than human intelligence.  But it needs those gigabytes in fast
memory, because optimizing requires a lot of work, and having the
knowledge base on disk might cause it to take a year to complete.
Using virtual memory would not be a good compromise, because the nature
of the work is such that the accesses would be too random, and the disk
would be bogged down in seeking.  Virtual memory is good when the
accesses tend to be repetitive, which is the case for the more tedious
jobs computers do now.

Another point about optimizing Scheme is that a lot of the work is in
finding better algorithms, etc.  The Scheme program that best describes
the functionality is not the same as the Scheme program that best
implements it.  That is, you can write one program whose purpose is to
make it clear what the program is for, without regard to how fast it
executes.  Then you can find ways to make it execute faster.  The first
step, making it clear what the program does, could be done by humans,
and the 2nd step, making it execute as fast as possible, could be done
by the machine, as part of the overall optimization process.  But that
is part of the reason why it needs gigabytes of memory, as that kind of
optimization requires a tremendous amount of knowledge.
Newsgroups: comp.os.ms-windows.advocacy