[continued from previous message]   
      
   In some of these cases, it is easier to scale up than scale back down.   
      Easier to take simpler code and add features or improve performance.   
      Than to take more complex code and try to trim it down.   
      
      
   And, sometimes it does make more sense to just write something starting   
   from a clean slate.   
      
   Well, except for my attempt at a clean slate C compiler, except this was   
   more a case of realizing I wouldn't undershoot BGBCC by enough to be   
   worthwhile, and there were some new problem points that were emerging in   
   the design. Partly as I was trying to follow a model more like that used   
   by GCC and binutils, which I was then left to suspect is not the right   
   approach (and in some ways, the approach I had used in BGBCC seemed to   
   make more sense than trying to imitate how GCC does things).   
      
   Might still make at some point to try for another clean-slate C   
   compiler, though if I would still end up taking a similar general   
   approach to BGBCC (or .NET), there isn't a huge incentive (vs continuing   
   to use BGBCC).   
      
   Where, say, the main thing that would ideally need to be improved would   
   be improving BGBCC's performance and reducing memory footprint. As-is,   
   compiling with BGBCC is about as slow as compiling with GCC, which isn't   
   great.   
      
   Comparably, MSVC typically being a bit faster at compiling stuff IME.   
      
      
   ...   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)