Custom fields schema

[Daniel Berlin]

>> Way to foster major
>> contributions!
>> 
> Way to foster quality! Nobody worked together with the core team in order to 
> perform the analysis stage of the development.I think it's unfair to skip 
> this stage and to try to make the core team accept a suboptimal code without 
> having either review or basic design stages.


I'm a usually silent observer here, but i've watched what is happening now 
happen time and time again, and it's always the same arguments on both 
sides.
I'll also note that one of the reasons i don't work with the core team 
before i implement gcc features is because i have the distinct impression 
(from watching the bugzilla bug reports and mailing lists for years 
now) that some members of the core team believe it is their way, or the 
highway, and i don't have time to theoretically masturbate over bug system 
design.  Unless some  other design for one of my gcc bugzilla patches is 
going to be wildly easier to maintain, it's just not worth the time.  This 
is not the same as saying i believe i should be able to contribute a bunch 
of complete hacks.  However, too often people here seem to delve into 
design issues that are way too picky for a system of the complexity of 
bugzilla.

Effectively claiming that we can't get to some good place starting 
with sean's design and code, and incrementally improving it (IE 
making the rest of it acceptable, committing it, and improving it as we go 
along) is just not a good argument to me.
I've seen it done in every open source project i've ever worked 
on[1].
You know what?
Unless the design just plain can't work, you can do this, and you know 
what, it makes the users and developers a *lot* happier, because they have 
*something*, instead of *nothing*.

Sean's design meets the requirements of being a sane custom fields 
implementation.  He is willing to conform his *code* in order to meet the 
other design requirements of a custom fields implementation for bugzilla.

His existing design may not be the most performant, or whatever, but it 
works, and it is a starting point.

These are just fields and tables in a database.
We can always migrate.

Or do you want to wait a few years for the next guy to try to make a 
custom fields patch, and then we can beat him down too for it not being 
theoretically perfect, when we could have spent the time turning something 
we've got *now*, into what we wanted, by then.


--Dan
[1] Hell,we just, over the course of 2 years, added a new SSA based middle 
end to GCC (which had no middle end, and for that matter, no well-defined 
interface between the frontends and the backend).
The starting design was incrementally improved into something wildly
different. Yes it required some coding changes on the part of people
working on new optimizers. I was one of these people.
You know what?
It was better to have to change large amounts of my code because diego 
decided some abstraction wasn't giving us the information or performance 
we needed, than it would have been to sit there and do nothing while he 
sat around for 3 years trying to design the perfect interfaces and 
abstraction level.  It never would have been completed had we done it that 
way.