Re: refcounted buffers / squid-3

Being only a human, my opinions should be taken with a grain of salt.
 
On Tue, 10 Jul 2001, Joe Cooper wrote:

> I just have big reservations about a rewrite of fundamentally
> solid code, and the idea of lots of work going into already
> well-implemented features makes me sad.

In my experience, pretty much everything that evolves, including
software code, goes through the following three stages (unless it gets
killed prematurely by external forces or an internal flaw/disease).

Birth: New stuff gets created from old bits and pieces. Squid2 passed
this stage (Harvest got killed at this stage).

Prosperity: The next stage is maintaining a stable code base while
adding new features. I believe Squid2 is in this stage right now.
(Squid1 got killed at this stage). In general, each new set of
features is more and more difficult to add. This has nothing to do
with programmers who wrote/write old/new code. It is just a law of
nature: The systems get more complex; more complex systems show more
resistance to modification.

Finale: The last stage of any code is a persistent vegetation state or
death. In this stage the code is stable, but there is either not
enough demand for new features or it takes too much effort to add
those features. There are either no known serious bugs or it takes too
much effort to fix them. Eventually, users abandon the code (e.g.,
pre-relational databases) or use it as a boring but necessary
application (e.g., telnet). This last stage is unavoidable (if the
code survives that long).

Now, why am I boring you with all this crap? If you think about it,
the conclusion is really simple:

        - If you want [Squid] to prosper in the nearest future,
          no rewrite is necessary and any rewrite is evil.

        - If you want [Squid] to prosper forever, your only
          solution is to start with stage one from time to
          time (because the last stage is unavoidable!)

Is now one of those "from time to time" times? I do not know. There
is a break-even point at which adding new features becomes too
expensive, but it is difficult to find/measure that condition.

Fortunately, you do not have to kill Squid2 to give birth to Squid3.

The author of the article you mentioned is 100% correct if the code in
question is in stage two and limited-term prosperity is the goal. The
author is wrong if you want to see at least one Squid specimen (from a
family of very different Squids: Squid1, Squid2, Squid3...) in the
prosperity stage, for as long as Web intermediaries are needed.

I could also add that the presence of those external forces is very
important: If you stay in stage two for too long, something "outside"
may mature enough to eat your new code alive if/when you decide to
give birth to SquidN+1 again.

Now, the stuff above is not really important. :) The fact that several
current developers want a rewrite _and_ will have fun/paychecks doing
it is what going to drive the short-term decision making, I guess.

Thanks,

Alex.

P.S. Between the two of us, I do not really care about features and
     all those parsing optimization ideas. I am all for/against the
     rewrite if Squid3 is written in C++/C! ;-)
Received on Tue Jul 10 2001 - 22:56:40 MDT