Re: Requirement ordering (was Agile developement ... more than just extreme programming ???)

From: CTips (ctips_at_bestweb.net)
Date: 11/19/03 

Date: Tue, 18 Nov 2003 19:55:24 -0500

Ron Jeffries wrote:
> On Sun, 16 Nov 2003 18:43:16 GMT, "Shayne Wissler" <thalesNOSPAM000@yahoo.com>
> wrote:
>
>
>>>Your model, please?
>>
>>OK. I hope you don't mind if I leave off the pretty symbology. You can throw
>>in some A1, A2, etc., and R1, R2, etc. if you like.
>
>
> I'm sorry, but I do mind. Your words weave a pretty picture but they disguise
> your assumptions to the point where they cannot be analyzed.
>
> I /think/ you may just be saying "refactoring is expensive", but that's an
> entirely different question from whether features can be done in more than one
> order.
>
> So I'd really like to see your model.
>

I think what he is saying is knowing where you're going can lead to
picking the right architecture, instead of throwing everything away, and
having to start from scratch.

Consider the following scenario: we're writing a tool that understands
things that look like simple sentences (think early text adventures,
such as Zork).

We start off with a set of simple sentences, and choose to implement it
  using a system built around a context-free grammar.

As the system develops, more and more complex sentences must be
recognized (these, I guess, would correspond to user requirements?).

Pretty quickly, a CFG system is not enough. We can treat it like a CFG,
but with rules to check for the cases which are not quite representable
by a CFG.

Finally, the system breaks, and we have to reimplement using an Early or
Tomita (or some other style) context sensitive parser. This, of course,
means that _all_ the work till this point has to be redone.

On the other hand, if we had known that the eventual goal was to
recognize a heavily non-CFG grammar, then we would have picked a CSG
parser to start with.

Once you get the architecture right, implementing requirements in any
order may not make a difference; however, if the order in which you pick
the requirements leads you to an incorrect or sub-optimal initial choice
  of architecture, then it will cost you - a lot.

Also, another interesting thing - CSG parsers require much more up-front
work compared to CFG parsers. If you choose to implement, e.g., a Tomita
style parser up-front, you will take much longer to recognize your first
  sentence than if you had implemented a CFG parser. So, making the
choice that is optimal for the development of the entire system may be
sub-optimal (i.e. delay) the first deliverable.

Relevant Pages