FreeLists / arachne / [arachne] Re: Unifying the sources

["Ray Andrews" <randrews@xxxxxxxxx>]

Arachne at FreeLists---The Arachne Fan Club!


More interesting stuff ...

      everyone has the right to make his own decision. If you want to be part
      of the team, why can't you accept this?

Of course! You and the others will do as you think best. I'm just trying
to convince you to consider a better way forward. As for me, after 4 years
of work, I'll not go back to the old sources, they litteraly make
me angry they are so bad. Compare my html.c with the old one and
you will see what I mean.      
      
      > I have *all* of Joe's improvements incorporated in my src except one
      > very small one that I didn't like.

      Then how come that not everything in your version works like in Joe's
      version? You claim that yours is better, but it did not work for me.

Well, as I said, I think you should try again and let me know if you
have troubles. My latest distro should start up right out of the box,
however connection to the internet is rather different and we'll have
to talk through it. Shouldn't you get it running and then decide if
it has posibilities??      
      
      > Why patch? Why not simply abandon the old code? My work is a *total*
      > rewrite, there is not one in a thousand lines the same. My src
      > (working code only) is over 400K shorter than the old due to 
optimization.

      Because that is not the team spirit. If you had wanted to contribute to
      the team's efforts, you would not have forked the code. Also, you have
      stated yourself that your new code also has new bugs.

It seems to me the team spirit is for each of us to give what we do best.
For me that's optimization of the sources. I repeat: I have all the
other's contributions included. In fact, I have fixes from Glenn that
are not yet even in the standard core, ironicaly. There are new bugs
because I am always working on some new thing. I have far fewer
'old bugs' than the std. core.
      
      > Sure, but a DPMI version built into my sources will have all the
      > advantages of both. It's up to you to decide if your work should be
      > in clean code or messy, why not make the sensible choice?

      Or the disadvantages of both, you can tell?

It is hard to belive that the cleaned code would be worse than the
old ones with DPMI or anything else.      
      
      > Well no one wants to see their work go to waste, but that's a chance

      Actually, that is just what you are telling us: Throw away your old
      messy code and use mine instead.

Hmmm, interesting ... I presume that all the others are concerned with
keeping the *function* of what they have written, not the actual
litteral code. If someone is attached to the litteral code, then, yes,
they would be giving that up. But if they are attached to the 
*function* of what they have written -- that's still there.  For example,
I optimized Joe's cookies code. It still functions as Joe wrote it,
it's just much more compact and faster.      
      
      Well, to answer this question, you would only need to look at the
      changes I did for the DPMI support. Like Glenn, I usually keep the old
      code and just comment it out, so I can see what I have changed and why.
      Your "clean" code would not suit my programming style, and so it would
      be counter-productive.

Have you looked at it yet? When I am working on some change, I usualy keep 
the old code too until there is no chance of needing to go back
(perhaps a year or two). If I imported your work, it would be with
all comments and old code preserved (or perhaps if the 'translation'
was difficult, just with extra comments showing what's changed.)      
      
      Besides, if your code is indeed vastly different, there would probably
      be as much work necessary to get all the changes into your sources than
      vice versa.

No. I import from the main stream all the time, and it's a few hundred
lines at most. How many lines are changed with your DPMI? I'm guessing
it would be a few days work to import it.
      
      Also, like I have mentioned before, I think that since you have forked
      the code, you would also be responsible for reintegrating it. If you do
      not want to do this, then separate shall it stay.

As I keep saying, I *am* integrated.
      
      Again, this fuss is all about how long to keep commented out code in 
      before having a 'purge the comments' release?!  Err, I thought it was 
      accepted best practice that you'd keep them in until it such a time as 
      they got unmanageable and then you'd have a 'purge the comments' of 
      either all the commented out code or all the commented out code past a 
      certain date release and then refer to the archive if need be for the 
      old commented out stuff.  I'm working on a program at work that needs 
      such a purging right now actually.

      But really, if the comments are that bothersome, why are you using an 
      editor that doesn't let you mask them out?  And if not having them is 
      that bothersome, why can't you refer to the archive?

This is not about comments! My code has more comments than the std.
sources. I never remove a comment until it has become totaly irrelevant.      
What this is about is that my sources have been completely rewritten
and optimized.      

      Ray,  is a perfectionist and a risk taker
      so he is constantly trying and trying to
      remove redundancies and reduce core
      size.  Right now in his dreams he is figuring
      out some new scheme to reduce core size
      and thus introduce some new bugs to be
      found and resolved.

      glennmcc,  is a realist and a documenter. He
      helps Ray with the bugs and imports many of
      Ray's concepts to the "standard" core. When
      the two get going on something they are like
      the avalanches they're having in the Rocky
      Mountains right now,   un-stopable.

      But.......as I said.....Ray, being a perfectionist,
      has a hard time accepting a compromise.

      Thus,   he has created, a fine core which is not
      compatible with the "standard" core and setup.

Eric is very accurate here. I am a perfectionist. However,
I do not reduce core size for it's own sake (tho smaller
.exe's are nice) no, it's because a smaller .exe is the
result of more optimized code. The funny thing is that
although Eric seems to not like what I am doing, the fact is
that he has been running my distro for years, and gives me
many many hours of testing and feedback! What do you 
think of that?
      

      From your discussion, I understand that there are multiple 
      reasons to participate in Arachne development, too. Some 
      of them seem to be very personal. I would like to encourage
      mainly the 'feature guys' among you. Please, it would be great, 
      if at least one of you could fork towards Unicode or better 
      CSS support. In return, I would reconsider my masochism on the 
      user's side. 

Ironic you should mention CSS -- Bernie was working on that in my
sources when he quit, he had several additions to CSS roughed in.
But Bernie won't work in the old sources. He's not that much
of a masochist ;-)      

      Ray, this really does beg the question, "If you just like to make things 
      more efficient, why not patch the main?"  Enough patches and it'll be 
      your code soon enough!

Quite correct, but then, why do all the work from the beinning all over
again?? It took me four years, I'll not do it twice. As I've said,
my sources are *completely* rewritten -- that's a lot of patching.

At the end of the day we can agree with Glenn that nothing should
be changed or removed (just patches added) or we can agree with the
man who wrote Arachne: "It needs a complete rewrite".

Bernie, Vladimir, MHT and I agree with Michael.
Udo, Werner, and Joe agree with Glenn.

BTW one more comment: Igor ran a program called 'sloc' on my
sources and the J3 sources, it's an estimate of programmer hours
that it looks like would be needed for each. 

J3: 41,050
mine: 22,711

... which is to say that my sources are 18 thousand programmer-hours
more simple. Put another way, someone starting out could understand
my sources in about 1/2 the time as the old ones.

Regards,


Ray Andrews
-- Arachne:A1b:x9

                  Arachne at FreeLists                  
-- Arachne, The Premier GPL Web Browser/Suite for DOS --