|
Somehow I was thinking that Number of Programmers and Code Quality would be inversely proportional.
|
|
|
|
|
They are. If you re-write it a little, you get: Q = c·t/N
Thus quality is proportional to time, and inversely proportional to the number of programmers.
"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer
|
|
|
|
|
Seems a bit incomplete to me, you need to add the number of managers, and the level of customer involvement AKA feature creep.
|
|
|
|
|
If your actions inspire others to dream more, learn more, do more and become more, you are a leader.-John Q. Adams You must accept one of two basic premises: Either we are alone in the universe, or we are not alone in the universe. And either way, the implications are staggering.-Wernher von Braun Only two things are infinite, the universe and human stupidity, and I'm not sure about the former.-Albert Einstein
|
|
|
|
|
I'll buy that. Change "programmers" to "people". LOL!
|
|
|
|
|
I was thinking more in the lines of:
NQM(2f+1)/t=c, where:
- N is the number of programmers on the project;
- Q is the quality of the final product;
- M is the number of managers on the project;
- f is feature creep (in percents of the original number of features);
- t is the time taken to develop the product;
- c is a constant
|
|
|
|
|
|
Doubling the number of features doesn't just double the time needed as it's also adding complexity.
Hmm, it's probably more like (f+1)2 when I think about it.
|
|
|
|
|
learner'sbug wrote: not f+1 ?
Because f+1 is a race with no passing.
This space intentionally left blank.
|
|
|
|
|
Brilliant! Although... since you don't want to affect N inversely with M, then I suggest:
(N^(M(2f+1)))Q/t=c
...which, since M implies 2f+1, could theoretically be shortened to:
(N^M)Q/t=c
(or else, we could include a constant to state the probability of someone posting a thread like this...)
|
|
|
|
|
It makes sense. When M=1 then everything works fine, but when M=2 or more, then a quality drops exponentially.
Also, instead of t we could take some Chi squared distribution, as from a certain point of time, giving more time brings more bad code.
|
|
|
|
|
I think we are getting somewhere, but you also need to account for "New Technology" with a heavier factor than feature creep (e.g. "We are going to change our platform to be all in the Cloud").
Soren Madsen
"When you don't know what you're doing it's best to do it quickly" - Jase #DuckDynasty
|
|
|
|
|
Nah, a new technology is a whole load of features in one go, you just need to break them apart and the formula will still work.
|
|
|
|
|
NQ/t=c
is incorrect.
It is:
NQ/t=C^2
Where "C" = Change; as in "_________ in my pocket" from all of the "_________ requests"
|
|
|
|
|
|
Not so sure about that.
If either N or Q are 0, then c = 0.
Knowing this and assuming c is a constant, then t = lim(x->inf), or lim(x->-inf).
.
|
|
|
|
|
Well, it almost makes sense: if you have no programmers, it's not really supposed to mean anything...
|
|
|
|
|
Yes, no programmers means zero enthropy. It also means that either everything is working fine and the visible problem space is zero... or total economic collapse.
.
|
|
|
|
|
I moved to a new job a couple of months ago. I'm working on extending existing product. It's quite mature as it's been developed for the past decade, so the code base is rather large.
Many times often I need to dig into existing code. I find some strange things there, just a moment ago I found:
public override void ReverseProcess()
{
List<AutomatedActionEO> actionsList;
var actionsEnumerator = actionsList.GetEnumerator();
actionsEnumerator.Reset();
ReverseActions(actionsEnumerator);
}
private void ReverseActions(IEnumerator actionsEnumerator)
{
while (actionsEnumerator.MoveNext())
{
automatedActionEO = (AutomatedActionEO)actionsEnumerator.Current;
}
}
The code was written in 2013, so either someone is stacked on .NET 1.1 or thought that using GetEnumerator() in that way looks smart in the code, i.e. as if they knew some inner mechanisms of collections
There's a lot of weird things like this one in the inherited code. Most of them not harmful, just weird.
|
|
|
|
|
Where exactly is the "reverse" part? For me this looks like the actions are processed in the normal forward order.
The good thing about pessimism is, that you are always either right or pleasently surprised.
|
|
|
|
|
My guess would be that it's "reverse" as in "undo", not "reverse" as in "go backwards".
"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer
|
|
|
|
|
The foreach operator is not an option I guess . Also, if they only wanted to reverse the list, why not use this? That is the forbidden stuff, and the unfaithful will be punished by torturing and banishing for forever.
|
|
|
|
|
There's nothing wrong with that code (other than it being called Reverse rather than Undo), if ReverseActions is called elsewhere with a partially enumerated IEnumerator ... which I'd bet it is.
|
|
|
|
|
Looks like the code will work and is more justification for my signature line.
Just because the code works, it doesn't mean that it is good code.
|
|
|
|
|
Apparently if you buy a Windows phone they'll throw in an old http://en.wikipedia.org/wiki/Ford_Cortina[^]Cortina. Now that would put the 'mobile' in mobile phone.
What's that?
Time for my jab?
But nurse! I'm having fun!
modified 21-Feb-14 3:12am.
|
|
|
|