From: shaman AT nlc DOT net DOT au
Newsgroups: comp.os.msdos.djgpp
Subject: Idea for powerful IDE
Date: Sun, 01 Dec 1996 14:37:44 +1100
Organization: NHJ NORTHLINK COMMUNICATIONS
Lines: 104
Distribution: inet
Message-ID: <32A0FD87.66AA@nlc.net.au>
Reply-To: shaman AT nlc DOT net DOT au
NNTP-Posting-Host: dialine17.nlc.net.au
Mime-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
To: djgpp AT delorie DOT com
DJ-Gateway: from newsgroup comp.os.msdos.djgpp

I've noticed that a lot of compilers/IDEs are still in the ice ages
where code organisation is concerned. Even the most expensive IDEs
cannot do much more than a simple text editor. Some can automatically
reformat each line so it looks neat (VBasic) and some can check for
simple things like missing brackets and auto-highlight code, but this is
all quite simple. When projects are being made by several people, most
IDEs do not have features to help out. Some examples of things that irk
me:

* Have you noticed that linkers will link an entire object file even if
you only use a single function in it?
* A lot of programming is playing about with a small section of code
over and over again. Backup files are useless if you do it more than
twice. I want to be able to backup a selected area(s) of code and
restore them at will in case the mucking about wasn't too good.
* I want to be able to get to the function I'm interested in without
flipping through pages of code. Why can't IDEs put each function/class
on it's own? (Visual Basic does this)
* What if several people are working on the same project? Keeping
everyone's version of the code up to date is a bitch, compiling is
difficult at best and with very large projects it becomes a total
nightmare. No wonder projects like Windows 95 are so badly organised.
* Why can't compilers automatically notice and warn me about common
mistakes like leaving out semi-colons at the end of class declarations
using colored highlights?
* Why can't ALL the files of a project, including the project be kept in
a single file that the IDE edits with bits of it exported as necessary?
Eg: I could export everything into .h and .cc files or the IDE would
automatically export everything necessary into a temp dir when
compiling.
* Why aren't there nifty features in compilers like being able to see
what a typedef/constant/macro actually is in a seperate window just by
moving the cursor over it?

	Considering people are thinking of porting RHIDE to Win95/97, wouldn't
it be smarter to make an IDE that is head and shoulders above the rest
and can invoke other compilers (Including DJGPP of course) by exporting
the appropriate files? Some features I would like to see in an IDE:

	* If I write a full class declaration, the IDE would parse it and
automatically create all the empty functions, so I won't have to do half
an hour of cut and pasting, removing and adding things, etc.. (Like
putting the xxxx:: in )

	* The IDE could transparently create things like semi-unrolled loops.
This would make the code more readable, but compilers wouldn't have to
be changed. Eg: If I wrote:

	for ( int i = 1; i < count; i++ ) [x16]
	{
		doSomething( somedata );
	}

Then the IDE would export that as a loop that executes the loop 16 times
before making a compare. (An [x8] loop would look like this:)

{
    int i = count;
    if ( i > 16 )
    {
        for (; i > 8; i-=8 )		// main loop.
        {
			
        }	doSomething( somedata );
    }
    for ( ; i; i-- )				// cleanup loop.
    {
	doSomething( somedata );	
    }
}


* The IDE could support multiple programmers by allowing coders to
simultaneously edit the same project file. The file would be stored on a
central server and if one person starts modifying a class/function,
he/she would "freeze" it while editing. This would mean that others can
compile using the original code, but the person editing it would compile
with the new, edited code. When the person is finished, he/she would
unfreeze the block and it would be updated. 
* The IDE could keep track of who last modified each part, who wrote it
originally, etc.. If something becomes obscure it would make finding the
original coder easy.
* The IDE should read in and interpret any headers and automatically
detect any identifier name conflicts. (Not always possible)

* I wonder if it would be possible for a compiler/IDE to link individual
functions instead of entire object files. This would mean the compiler
and the linker would have to modified somewhat to be able to recognise
inter-dependencies.

	etc, etc.. I'm sure everyone can think of hundreds of things that
annoys them about compilers/IDEs..

	So.. anyone feel like making and IDE this good? 8)

-- 
                                       . . .   the Lord Shaman
      
------------------------------------------------------------------
          Your conscience does not prevent sin. It merely prevents you
                               from enjoying it.
          http://www.nlc.net.au/~shaman  or  mailto:shaman AT nlc DOT net DOT au
      
------------------------------------------------------------------