Re: [Tinycc-devel] TinyC++

[Rick C. Hodgin]

> > It's all still a way-pre-alpha work, but I'm heading toward it.
> 
> I hope it will be soon published = "released" (even in alpha stage)
> under an opensource license (e.g. GPLv3). Please publish your
> work very early!

Open source is an ugly term. :-)  This will be free software released
under GPLv3, and probably around February of next year in late alpha /
early beta.

> Did you look at nwcc, http://nwcc.sourceforge.net/

Nope.  Will do so.

> Did you consider putting (or using) a full garbage collector inside
> your compiler (e.g. Boehm's one, or perhaps make your own)?

Nope.  The purpose of this compiler (for now) is to produce workable
code with solid logic that executes 100% correctly, regardless of
inefficiency, but one that allows source to be recompiled and updated in
memory while running.  I don't envision this being a long-term
production app, but rather something a user uses during development.
Once the code is developed and up-and-running and all of the basic bugs
are out of it, then the developer would migrate to GCC or some other
established toolset for the "finishing touches."

Right now, I'm developing in and working with the CodeLite IDE, and will
most likely implement a user-flag for it when I'm completed, something
like a toggle setting to move from "compile with GCC toolchain" and
"compile with RDC for edit-and-continue," and do so on a
project-by-project or file-by-file basis.

Also, I don't know if you remember the brief conversations I had in GCC
mailing list about my RDC and edit-and-continue desires in general, but
I honestly felt like I was alone in desiring this.  I even had one
person suggest that I learn/study-up on contract programming and learn
better programming techniques to catch simple errors like (for i=0; i <
some_var; i++) when it should be (for i=0; i<some_var-1; i++).  Simple
fixes like that can be corrected on-the-fly, and are such time savers.

I just don't think people realize the power of edit-and-continue, and
until they have the chance to use it they won't.

I'm also discovering as I develop my compiler, that the reality is there
is no need whatsoever to have just a compiler, but this code base I'm
creating is so small it could be incorporated directly into the IDE,
allowing for an on-the-fly continuous compile revealing all errors as
the code's being developed, and even unit testing, allowing the logic to
run from inside the compiler's built-in emulator, which could be
extended further into a full-fledged application of the logic applied in
a virtual machine, like Bochs, running some OS snapshot that's been
pre-prepared as an imitation of the target machine.  This ability would
allow it to just run continuously in the background, unwinding any data
it produced each time some source code is changed, and allowing the
developer to continuously develop and test the app at the same time.

Rapid Development Compiler.

I'll see how it all goes though.  A lot of work to do.  Peace. :-)

- Rick