Some of you might feel that this is for the heap, but since this is about optimizations (though not direct code involved) i posted it here. If any of the mods feel that this should be in the heap instead, by all means, please move it.

Anyway, i'd like to take a whole new look at optimizing code in the work place. I have a few methods of going about optimizing code that is made in a programming team. This is alot more difficult since team projects are split up into completely different algorithams using the same problem. Perhaps we could sit and debate which we feel would be "the best" or "most efficient" way of dealing with making the best code in a team situation, assuming that money will also be involved to hire each member of the team.

I've always saw that the typical programmer situation was that there was a lead programmer (usually the one in charge of the whole project and dosn't do much actual coding alone) that hired sub-programmers and assumed that they alone could optimize their code. I have theorized that there might be a way to impliment an algoritham for the structure of the programming team as well, to maybe make a more efficient method than this.

My first algoritham is to hire 1 optimization programmer for every so many programmers (10 for example) and each programmer at the end of the day would present their code and their algoritham (while coding and just drop it off into, maybe, a folder for him) to this programmer, and the next day he would evaluate their code based on the algoritham and that specialized programmer would either work nightshifts or 1 day behind everyone else.

My second algoritham is a little more complex (and expensive). We would have 2 lead programmers, before the project starts, who would debate over what sections (or functions) should be used to handle the problem. Once this is sorted out, they would hire pairs of programmers to handle the sections based on how they see fit. In situations where they have more than 1 section handed to each programmer, they could have teams of sub-lead (if you'll excuse the paradox) programmers who'll be in co-charge of each section (paradoxally [if that's a word] with the next group of people, the sub-sub programmers). You would then have sub-sub programmers who will switch between each person for each section of code, that way there is "fresh eyes" looking over each others' code. This should prevent people from getting used to each others' code and algortham's so much that they start seeing the same answers and always agree with each other. And since some sectons will be smaller than others, those who finish early would be required to assist the ones with larger sections.

Can anyone come up with more algorithams and/or perhaps debating between these three? Perhaps after this thread dies (assuming that it will come alive) we could come up with a fasm project later that will test the method by making a game or something.

bad. this would take:
- 2 times the money for wage
- less time worked (the explaination takes long)
- and mainly, majority of code doesn't need to be optimized

I didn't get attatched to algoritham 1, either. I posted it anyway, incase it could help be a basis for a better algoritham. Maybe some one could come up with an answer for those problems.

are you gonna be team manager?

Maybe some day, or perhaps i could help some one set up their own team. Plus, this is an interesting topic which could benefit other people who want to setup their own team. I'm considering on setting up a volunteer team for making my project kim cross platform after a few years of it's release (the wait is for personal resons).

you are gonna have really hard time finding volunteers. In fact, if you don't have tremedous work done yourself, you will probably find no one

#1 is bad - it's better to do 'code reviews' every so often, that way you don't waste a developer "just" doing optimizations that might not even be necessary. A code review has the benefit that you sit down with the programmer that originally wrote the code, and there's mutual feedback.

In real-world situations, you don't optimize until there's a bottleneck anyway (there's pre-planning of course, which can be seen as an optimization, but that's a different issue).

#2 seems like administrative hell and pretty wasteful.

If it flies the way i want to, it might even have voulunteers before i even ask for them. Anyway, the only real voulunteer work would actually be porting the code, since project kim is quite simple, but the actual work is done to make a standardized something. It's actually an instant messaging project, which i hope to export symbols and some documentation (on the code not the format so no one takes this project and claim it as their own which would cause some problems with keeping on the aim of standardization) so people could impliment it in their own games or other applications. It'll also have a sub-mode of binary data transfer, so it reduces the need for reading on winsocks for that as well. It's basically supposed to simplify winsocks more than it already is so people don't have to go out of their way to figure out the NBO and such.



From what i've seen, chances are that most of the code in any project will be need in (or for a thread in) a loop. I considere that bottleneckish enough.



How do you figure?

The optimazation programmer is YOU. The lead programmer. We will talk further about it when you have 30 programmers :)


Time wasted at blah-blah. The boss takes his decisions, others follow and there's
no debate. If he wants to stay more than one day.

yeah.. be george washington, and you got yourself an army of optimizator.