Better Development Through Competition?
theodp writes "Among the tips Derek Sivers offers for how to hire a programmer to make your ideas happen is an intriguing one: hire more than one person to complete your first programming milestone, with the expectation that one will go bad, one will be so-so, and one will be great. 'Yes it means you're paying multiple times for this first milestone,' says Sivers, 'but it's worth it to find a good one.' It's not a new idea — the practice of pitting two different programmers against each other on the same task was noted three decades ago in Tracy Kidder's Soul of a New Machine — but one that never gained widespread acceptance. Should the programming code-off be adopted as a software development best practice?"
My first employment was handled that way.
If builders built buildings the way programmers wrote programs, then the first woodpecker would destroy civilization.
With some seriously exact metrics this can work.
Not just speed but code quality, test coverage etc. it is viable
unfortunately measuring this impartially can be a pain
The fact is companies like to treat most jobs, excluding management positions, as unskilled labor. Not unskilled as in 7-11 but as one programmer is the same as any other programmer. This does not apply just to programmers but a large range of positions.
So even though you maybe the best of the group in your company, they will not care because they are not willing to expend the energy to find out. You are all the same as far as they are concerned.
Usually a stunt like that lacks lots of real world practicality. Software development is a delicate craft, and it requires patience and attention to detail. It's difficult to attain that by pitting two programmers against each other. You can be certain of bugs, memory leaks and security vulnerabilities for example. Besides, won't it damage cooperation and teamwork? Your competition should be with the competing companies in the market, not a civil war within.
I'd say that when you hire three programmers, it is more appropriate to expect that one of them will be bad, the second one will be bad, and the third one will be the worst of all.
Unfortunately, with all the kiddies getting a trophy for just showing up, I see a lawsuit in the future of this approach, with cries of "It's not fair!" Thank you 1960's!
You ask, "Was this software developed by Indians?"
If the answer is "yes", then it is shitty software.
I think that there are two major groups of problems out there. Yes, some problems are in both categories and I'm sure there's problems in neither category but the majority of problems out there are either a restricted closed space or an open space. In the former, you have a problem with a facet that dictates there is a best way to do things. For example, say you are building a database meant to create millions of records daily with a demand for instant querying. You're not going to want three people to tackle that three different ways. There's just a more simpler way of analyzing existing products and comparing strategies like federated search versus directory storage. Or sharded versus RDB. Or a number of other things that can be planned out on paper ahead of time and should be.
In the open scenario -- like designing the UI or mashup of many different pre-existing services -- then I think the proposed idea is a great idea. Because a human interface is more open with many different variables that are related in some unknown way to each other. UI isn't the only place this is applicable but we have used this strategy to develop several UIs before milestone one and then all discuss, come to a collective agreement and kill two.
My work here is dung.
And has been doing large contracts like that for quite some time. Military, especially. Then, again, the Fed. Govt. is moving away from hiring contractors and is looking to hire permanent employees these days.
Not best, but first will win. That's my guess based on how most industries work.
I find the idea intriguing, and I'm just prideful enough to think that -my- work would be the one chosen, but...
What if it isn't? I will have spent days, weeks or months working for a company that doesn't want me around any more. I won't have any other job prospects lined up, and I'm just back where I am, but now with either a big hole in my employment or a -very- short job on my employment list. It seems to me that this is a massive gamble.
Also, how does the company judge which is best? There are so many factors involved in such a determination, and many of them aren't something that a non-programmer can even understand, let alone quantify.
Code Readability
Comment usefulness
Self-documenting code
Documenation usefulness
Speed
Unit Testing Coverage
Unit Testing Usefulness
Those are just right off the top of my head on how I'd judge the work, but non-programmers couldn't judge most of them. So you have to already -have- an excellent programmer to do the judging, and you have to get one who isn't afraid of the new guy taking his job.
So on top of the gamble on whether you are the best programmer, you also have to gamble that the company can judge the work properly as well.
No thanks.
On the other hand, if you are outsourcing, this makes a lot more sense. Give the project to 3 companies and let them fight it out, and have an in-house developer (the one who is going to liaison for the project anyhow) do the judging. The outsource companies are better off because they had some work and they aren't screwed out of their next job by this one.
Pitching two developers, teams or even companies against each other maximizes your change of success.
That is:
1. As management, you dont have a clue about what you are doing in the first place (go happy lucky)
2. You dont mind spending the cost two times over
3. To stay in power, You have learned to divide an conquer
But your cost will double
Your employees will start fighting and sabotaging each other
But who gives a $#!7 as long as your happy :)
In the vast majority of businesses, especially small ones, getting to market has a lot more value than building great tech. It doesn't matter how good the tech is as long as it meets the business requirements from a black-box prospective. You don't need three independent projects to do that. The resources are almost always going to better spent on sales and marketing.
Competitive programming, if not done right, can actually make matters worse rather than better. My GUI always looks like crap until near the end of the project, after I get all the infrastructure in place, working, and stable. I don't like focusing on the GUI up front because their are usually many requirement changes and what not and would have to be redone anyway. Better to wait until a later stage when everyone has had a chance to think about what they really want.
Alas, other departments, project managers, and what not only see the GUI and have no clue about what it takes to support the GUI underneath. The GUI is just the tip of the iceberg. It's the least important as far as overall functionality, but it's what everyone sees and reacts to. The database schema, the middleware, the messaging protocols, stuff you have to design in to make it scalable, robust, and secure -- all of that is "under the hood". Neglect it to your own peril.
Ruby Neural Evolution of Augmenting Topologies
If someone isn't skilled enough to compare the quality of two programmers and select the best one for their project, what makes them think they are skilled enough to compare/judge the quality of two programmer's work?
This seems to be a recipe for premature optimisation and poorly maintainable code. It might get you a good first milestone, but it might be screw you in the long run.
Just worked on a project using LEAN. What we would do is let all developers deliver the same prototype. At the end we evaluate each one, pick the best and move on. In diverse projects, different developers will excel in different areas. This was one way we could quickly see who is strong in which areas making later task assignments easier - especially when you are done with prototyping and now need to add all the other functional requirements. This sounds very similar...
Need an ISP in South Africa?
Before they fired me, we would hire people for a week or 2 week contract. I think this is much easier for both sides to manage than a milestone. I agree with some of the comments above. Having only the first win selects for the wrong sorts of traits. If you did the least amount of tasks because you were helping the other programmers, or adding documentation to the wiki, or identified and fixed one of the many core design flaws in the code, I'd still hire you.
And also like free market economics, it will never work in reality and will probably actually end up sending everyone's computer back to the 1970s
It's not enough to take into account quality of the finished product as such. You also have to take into account how maintainable it is and how easily it can be modified for future requirements. That's one of the thoughest parts of software development and that takes years to learn and is easily overseen by clueless management.
Fucking dick smoking queers.
if there is not much research or serious architecting involved, but mostly design, than the most experienced will win...
if it is a difficult poblem, than there is no win in developers hiding information from eachother...
As an employer I'd like the idea a lot. As a programmer, though, this would quickly lead to intolerable working conditions. Are the other "candidates" willing to work 16-hour days in order to win the job permanently? Then, unless I'm a lot more efficient than the best of them, so will I. Then, once the initial milestone has been reached, I will have created expectations that would be impossible to satisfy in the long run. I'd have to be fairly desperate to put myself in a situation like that.
There are multiple problems with this approach. One is that you cannot easily evaluate code quality. The important characteristics will show only over time or if you have somebody very experienced invest a lot of time into the evaluation. A second one is that you cannot know whether the best person until the first milestone does actually know how to pace him/herself. It is well possible to have somebody come in best that later burns out. At the same time it is well possible to have somebody that actually would do reasonably well for the whole project duration, not do best until the first milestone. This could be prevented bu allocation generous resources for the first step, but it seems very likely that nobody is going to do that, and even more likely that resources will be far too low to save some of the triple effort.
My take is that this is another stupidity by people that do not understand software creation. This is doomed to fail. Personally I would refuse to participate.
Most ACs are not even worth the keystrokes to insult them. Be generically insulted by this and ignored otherwise.
What happns when one is fast with rushed / buggy code and the other one is slower with better code?
Does the PHB pick the fast guy over the guy how is slower but has better code?
Doesn't this guy sound like every drunk imbecile who, upon finding out you write software, wants to sell you on how he's got this great idea for the next Facebook or Apple or eBay? For the percent of a percent of them who act on their delusions, they are the ones you see ridiculed on the Internet for ridiculous job postings.
These people have a conception of software development derived from 24, and have the intelligence necessary to remain that ignorant.
But do you know what's most funny? He betrays the shibboleth of every incompetent business person, and assumes the same of his audience: he thinks he is an expert in user interface design. "Write a detailed walk-through of every click." When you see any spec like that, withhold your laughter, and decline whatever they are offering.
And who is to decide which programmers work is better? Hey wait..
Next you'll have to have another competition between two managerial candidates to see who does a better job of judging the programmers' work.
Gimmickry is not going to solve the issues that we have in software development. You can probably only count on two hands the number of true 'one size fits all' solutions and this isn't one of them.
The story in TSNM: one programmer was asked to build something quick and dirty in 6 weeks, the other one was asked to build something much more detailed. the quick and dirty version was used until the detailed version came out 5 months after the first one. There was friendly competition, but this does not match at all the "one will fail, one will be so-so and one will be great."
No. Now get back to work.
This method of selection is based entirely on the false assumption that competition brings out the best of people.
If one of the hired development teams hacks an app together in short time doing strictly what is required by milestone one, it can still be of poor quality because it can lack a grand design which can haunt the dev-team for the rest of all the milestones, in terms of scalability, documentation, neatness etc.
In short, milestone 1 in a fixed time setting, is a bad indicator of good code.
However if the hirer can look through these hacked up apps, He could make a better educated guess, but we all know the 'boss' never knows something about those "damned computers" and he loves shiny short reports and a working program developed by yesterday.
--then a task which rewards those who game the system is certainly a sound approach. :) ---Irony, note smiley.
Seriously, what message does this sort of thing send you employees.
1) We are willing to have people work on things that will never get used.
2) We like to fire people, two out of three in this case.
3) We do not trust any of you.
4) We enjoy imposing pressure that is not intrinsic within the task itself.
5) We do not trust our ability to recognize good programmers. Something to keep in mind at review time.
6) We judge by "results," meaning we do not judge the fundamental underpinnings of those results.
"How to Do Nothing," kids activities, back in print!
A "competition" like that tells the prospect far more about the hirer than vice versa. It tells the prospect to run.
A competition only tells you who has the most superficial knowledge. Because of the time limitation inherent in the competiton, you never learn who has the most forward potential.
Also, what does the loser tell in interviews for his next job? "Well, I worked there for six weeks, but the other guy got to stay on survivor island and I didn't." In other words, both sides invested 6 weeks of inculturation and learning about a program knowing that fifty percent of that investment would be wasted. Sounds like they're both idiots to me.
If you're so incompetent at picking talent that a "Survivor Island" process will waste less effort than traditional hiring with probation, you're to incompetent to be involved in the hiring process, and have so little respect for your direct reports that only someone with no self-esteem will work for you.
I have been involved in this sort of competition twice. In one case my group won the competition, in the other we lost.
In the first case our group was developing the software for the DN60-series of communication processors for the DECSYSTEM-10. Another group was developing equivalent software for the DECsystem-20. I whispered in the ear of the product manager, telling him that if the other group failed to deliver, we could port our product to the DECsystem-20 in three weeks. As it turned out, the other product was not satisfactory, so he told us to do the port, and we completed it on time. (Of course, we had started preliminary work on the port weeks earlier, but that work would have been wasted if we had not gotten the go-ahead.)
The second time this happened to me was on the software for the PrintSystem40, a large-scale printer built out of a high-speed copier, similar to a fully-expanded HP LaserJet 9000. Our group was in competition with another group for the on-board software and the print spooler. The other group's software was chosen, I think because our on-board software required a floppy disk drive for error logging and theirs didn't. We offered to send them our spooler, but I don't recall if they used it.
Projects I've worked on include specifying requirements as a first step. That usually involves a huge investment on the part of the employer. They're going to have to spend even more time bringing three developers along. By the time the system is fully specified, it is likely that the weakest developer will have benefited greatly from the work of the strongest developer. That is likely to provide an overall improvement in the spec, but it won't make the decision making process any easier. At worst, the employer may get tired of answering similar questions and the last developer will suffer as a result.
Of course if there is a fully defined spec to work with, then the designer or programmer can start w/out a lot of employer involvement. I've never actually worked on a project like that but I suppose they do exist.
How will the company know which of the three programmers was actually best? Will they just look at how many features they managed to stuff in, no matter how badly hacked it is. I hope not.
No, they should also hire a code reviewer. Better still, they should hire three code reviewers in case the other two aren't any good at their job.
But how do you know which one is actually any good.
Better hire a code reviewer reviewer as well. Or three.
Sounds like this wasn't such a good idea in the first place ey? Guess whichever manager thought of this wasn't so smart. The company should have just hired three managers and let the board of directors decide how well he's doing.
Better make that three boards of directors and have three sets of stockholders decide which board is least incompetent.
And on and on until you come to the inverse of "atomic"; a point where it is no longer physically possible to have three separate larger units.
Slashdot social media options: AIM, ICQ, Yahoo, Jabber and Mobile Text. Why no MySpace?
Not always. The ones who Were There are the ones I respect. But there really is a serious problem first nationally trumpted by Dilbert, that "managers" DO "spring forth from nowhere" because they're good at the old high school Let's Make a Clique games. Getting rid of those guys is a pain because they outrank you, and usually too savvy to do anything truly stupid. Rather, they specialize in doing Vague Nothings.
My first Journal Entry ever, in 8 years! http://slashdot.org/journal/365947/aphelion-scifi-fantasy-horror-poetry-webzine
Holy Crapolie...
Welcome to 1900
When budgets were tightened, they went back to a more traditional approach. I wonder if anyone did a study on those days... Might make a good thesis.
Anyone from those days care to comment?
See, there's real demand in the market for great programmers -- it's people that are not that good that are a dime a dozen.
So the natural result of making programmers artificially compete for a job is... either:
1. pay more to entice great talent who could get a job without the stupid competition elsewhere, or
2. resign yourself to seeing such talent disregard your offer and directly go elsewhere.
In the end, you'd end up paying more and getting less.
Competition is great when you don't have to talk to your competitors. When you chose a vendor or a product, competition rules.
If the "competitors" have to sit down and have lunch every day it's a different story.
I can see two possible things happening. If a particular team consistantly wins, this might initially seem like a good thing--you can just lay off and/or reassign the losers. Now, how good is that for morale? Even if the winners really are superior, will the knowledge that they are out the door if they lose a competition help them perform? Is that the kind of challenge that motivates people, or will they just decide to switch jobs to another company where this doesn't happen?
Are the best and the brightest really going to like this kind of environment?
Also, the "not the best" programmers might turn out to be more useful than you think. We may discover that having people who work at different levels of proficiency is actually valuable. Maybe those people are better able to explain the system to non-programmers. Maybe they are more patient explaining things. You might be taking the meat and potatoes off your plate with this strategy.
The other possible outcome is that people might collude to produce similar work. This kind of stuff happens at factory jobs all the time (don't work too fast, they'll speed up the line on us).
For all intensive purposes, "whom" is no longer a word. That begs the question, "who cares"?
There are 2 types of people who would accept this kind of condition: those who suck and those who are desperate. The desperate will leave as soon as their crises are over with, leaving only those who suck and can't find decent employment elsewhere.
The most high profile example of this approach that I can think of occured recently in Iran. They needed to build bigger balistic missile, capabable of carrying warheads that were, um, just a little bit heavier than a conventional warhead, and they also wanted to be sure it would be delivered on schedule. So they kicked off not one but two completely separate project teams with the same goal. This would cost more than double the price, given that rocket scientists were already in short supply, and there would be some obvious contention for human resources between the projects. Thats military thinking for you, and it this case I think it panned out quite well in the end.
Except... not : http://www.youtube.com/watch?v=u6XAPnuFjJc
The video is good but the tl;dr is : give monetary incentive for an intellectual work, the more you pay people the LESS they work. That is the result of a few sociological studies. Give programmers a good enough pay so that he doesn't worry about money, give him autonomy and challenging objectives and you'll get better result than with a promise of a 20k$ bonus.
The Wise adapts himself to the world. The Fool adapts the world to himself. Therefore, all progress depends on the Fool.
t's not a new idea — the practice of pitting two different programmers against each other on the same task was noted three decades ago in Tracy Kidder's Soul of a New Machine — but one that never gained widespread acceptance. Should the programming code-off be adopted as a software development best practice?"
Fine, they shouldn't mind us taking two jobs and siding with the one we like in a few months.
Has the same problem; identifying the best is another problem, and even identifying metrics for determining the best is far from obvious. As fortune keeps reminding me: "Any sufficiently advanced technology is indistinguishable from a rigged demo".
The idea of competing software development teams is one of the central themes in Tom DeMarco's book "The Deadline: A Novel About Project Management".
Good programmers have options. Pull this BS and they'll exercise them.
I currently work at a place that does this. About 60% leave in less then 6 months. The rest stay for years and years.
The only problem is that the people leaving are the ones you'd want to stay. They can't get rid of the sub par people because they're the only ones who have any institutional knowledge.
The "hire and see who works out" approach leads to a real shitty office environment. You get people desperately trying to scramble to the top and take other people down. It is toxic, and the only people who put up with it are those with no other options.
If you have to uncooperative programmers that can't work in a team, then this programming competition could work, but be ready for increased chance of burn out. In general though getting these two programmers working together is probably the best of action. There is a lot to be said for bouncing ideas off each other and motivating each other.
Jumpstart the tartan drive.
I think I would rather get hit by a car and then build a "jump to conclusions" mat.
ft
The book mentioned in the summary is about a project at Data General. I think it is interesting that they aren't in business anymore.
At my company, every one knows who the best programmers are, even management. We don't need this kind of nonsense.
The development competition is nice when the project is very short, and no quality is needed, so most of the consultants projects are in this category.
However, it's the most terrible approach for long time projects.
One of my colleagues explained me that in his previous job, there were 2 software architects who competed this way when a new extension in their project was needed.
The winner was never chosen by the code quality, but by the first delivery, so I can only imagine how terrible is the code to maintain, since most of the code has been written in a few minutes.
There is a known rule that states that the most time is spent on writing the first code, the least time is spent on maintaining it.
Such an approach might at best be adopted in companies like Google or perhaps during competitions,
The rest of the corporate companies are filled with managements who would never admit
to the individual superiority of one of their employee over others.
Others have noted that the GUI is actually the more important part. The underlying systems should be subservient to the needs of the GUI, to make what is required possible.
That said, maintenance of something once built is usually pretty important too.. If I were running something like the competition you were imn, I'd actually evaluate who did the best GUI, and who built the best backend (based on code review and a description from each team on how the infrastructure was laid out). Then I'd have that backend team re-write the blackened to make the GUI performant, and then I think you'd really have something (and not necessarily have to fire anyone).
"There is more worth loving than we have strength to love." - Brian Jay Stanley
Gene left the company and took much of his team with him. He got funding from several investors, including Fujitsu and built an IBM 370 clone that ran circles around the IBM machine. IBM's response was to redesign the architecture, which forced Amdahl to focus on keeping up with the changes instead of improving performance. Still, the company gave IBM some serious competition which was good for customers.
I doubt that this could happen in today's 'IP hoarding' world.
Later . . . Jim
...you know, the now-defunct Linux certification startup. Take two "technical writers" (read: college students), assign them to write the same chapter in the upcoming certification manual, and pick the best one. Unfortunately for those sad saps who shelled out for the original SAIR linux cert, I think my chapter on UDP was picked.
Hire two programmers to work independently on the project while reviewing each others code. That way everything thats even slightly hacked will be corrected by the other guy because he needs it to continue his work, that way you can often get more then a doubling of the development speed, and you get information sharing free in the process since each coder has to document properly along the way.
If put in the context of how to work with "talent" found on sites like elance.com, guru.com, etc. it's actually pretty good advice. In short, build a solid requirements doc, break it down into simple milestones, (since you are already scraping the bottom of the barrel of commoditized software development "talent") pick three providers and see which one actually delivers something for your first milestone.
When you're working with dirt cheap developers that are most likely off shore, all of this sounds like pretty good advice to me.
I HATE people who generalise ... it's always fat bald middle-class suburban under-achieving married white people who do that!
Written quickly or bullet-proof? Easily maintainable? With accompanying documentation or free-standing? Open and extensible?
"The greatest lesson in life is to know that even fools are right sometimes" - Winston Churchill
A large mail-order company had decided to open retail stores, their Point-of-Sale software wasn't working right, the software vendor seemed to be unable to fix the major problems with the system, and they were opening in two weeks, ready or not. Since the company I worked for at the time used the same programming system (Progress DBMS), we were called in to see if we could help. I was sent out of town on an hour's notice to do whatever I could to get the system working.
When I arrived, the project manager told me that their biggest problem was an inventory report that took over 24 hours to run. The software vendor had a programmer on-site, but he had been unable to make it run faster. The project manager told the vendor's programmer and me that whoever fixed that problem would get all future work.
I couldn't believe that the inventory program needed to take that long, and my first thought was that it was an index problem of some sort (missing index, corrupt index, or program that wasn't using the best index for the job). It took me a few minutes to determine that the existing routine wasn't using the indexes at all, meaning that the software was doing several sequential searches through much of the database for each inventory item. I rewrote about four lines of code, and the runtime for the report went from over 24 hours to under 30 seconds. The next day, I was told that the original software vendor had been "fired" and that I should plan on staying there for awhile.
The original vendor did something I've seen over and over: They sold the system based on senior, experienced and competent staff, and then once they had a signed contract, replaced the competent people with unqualified junior people who didn't know enough to, for example, check for proper index usage when a database query was running too slowly. They assumed that once they had the contract, they didn't have to worry about keeping the customer happy. In this case, they met a customer who wasn't willing to put up with that kind of abuse.
It was one of the more reasonable experience I've had in this career.
Given that, in the majority of cases, solution #1 will be no better than 10% better than solution #2, is paying 200% worth it? What guarantee do you have that the succeeding project (of a slightly differing nature) would be better executed by the team winning the first? Life is fraught with such complications, rendering generalizations of this sort moot.
- The Kessel run is for nerf herders. I can circumnavigate the entire Central Finite Curve in a lot less than 12 parse
I remember reading an article at MacWorld Magazine about how they create two teams at Apple, one went to a complete rewrite of the MacOS to Power with no backwards compatibility (that was the primary team that the company bet tu succeed) and a second one that was the plan B. This plan B team was requested to write an emulator to reuse as much as possible of MacOS software.
When finally the B team end his job the A team was call out to try to brake the B team implementation. They even tried using 360Kb 3.5inch floppies. But finally the B team won, and it was a good migration from 680x0 to PowerPC.
Nice history, if someone can find an URL about this it is welcome.
If they're in management, I think a CS degree (at least one less than 10 years old one) is often a detriment to a manager in corporate America. Managers should manage. The common desire for managers to be "Working managers" is a recipe for disaster. People do what they like and are good at. If you have a manager who's a good programmer, he'll program instead of doing what a manager should actually do, which is to constantly work to remove obstacles from the path of his or her team.
Furthermore, a CS degree can lead the manager to start making decisions that the team lead(s) should really be making, which is another recipe for waste, gotchas and unhappy workers.
I'm not saying a degree is a bad thing, but it shouldn't be a classical CS degree. The "lines of code" metric mentioned above is a good example of the problem. The manager needs to know about metrics that actually work. He or she needs to be able to judge software quality by speed, usefulness, buglessnes, user comfort, etc. These can be metrics. But most managers don't know (and aren't interested in knowing) how to measure them.
Borland tried this and look where it got them. Almost all of their products were developed this way and it did allow them to come up with some great tools. Delphi and the original 2-way design tools (which came out the dBASE group surprisingly).
The downside is that it created a lot of animosity amongst team members making getting past that first milestone more difficult. Good developer would balk on working on the successful implementation and often quit.
No silver bullet here.
Unfortunately, there's a lot more to that first milestone than sitting down to hash out some code. In just about any size business, a project will require the programmer to work with a multitude of other professionals around the company. Imagine you're one of those people and for every project you have to deal with two or more people not only for the initial briefings, but for ongoing support where they're likely to ask similar follow-up questions and require at least some maintenance. It's not so simple that you brief and follow-up with the programmers simultaneously either; doing so would misrepresent their skill sets and unfairly level the playing field, thus mitigating the initial intent to discover the best and brightest at that particular project. I imagine the cost in this paradigm actually exceeds the simple salary of the extra programmers, but also includes the time, energy and frustration of the other employees who must deal with the redundancy.
If you don't hire that second team and have them compete internally, your competition might just hire those other programmers, compete with your company, and potentially take all your business away. There will be competition, whether from within or without. You choose.
- including user stories, storyboards etc. I sure wouldn't want to see any code other than technical risk-reduction / tech evaluation spikes included in the first milestone.
If you're talking about code-monkeys incapable of requirements & design specification, maybe it would have been more determinative of your project's success to have tested 3 architects / senior team leads against each other.
Great coders under lousy architect / project engineer will still fail, because their good ideas will be vetoed, and they'll be ordered to charge down the valley like the 600.
Where are we going and why are we in a handbasket?
I've been in this situation where a manager tries to get you to do something by assigning someone else to do the same thing and let you compete.
I had been asking for additional developers and the ones I got were tasked with a competing design it completely demotivated me
Set Based design is something that could work. Where you have multiple teams working on different complexities of a component that don't compete but supercede each other.
I am a programmer. There are different skilled level of programmer. Let me break it down, then you can think of a way to identify them during interview. 1. Programmer who can solve simple problems. 2. Programmer who can solve hard problems. 3. Programmer who can solve very hard problems. 4. Programmer who can solve hard problems and recognize the root of the problem. 5. Programmer who acknowledge the root of the problem and brave enough to determine that the root problem must be solved. 6. Programmer who acknowledge the root of the problem, brave enough to determine that the root problem must be solved, and smart enough to know what the solution is. 7. Programmer who acknowledge the root of the problem, brave enough to determine that the root problem must be solved, smart enough to know what the solution is, and hard work enough to actually solve the problem for the good of the company. You just need to find a way to identify these different type of programmer.
“So Paul let me see what you’ve done for the first milestone”
“Nothing Bill”
“Nothing?”
“Not a thing at all ”
*A crash is heard outside*
“Oh, I did reprogram the elevator to plummet 40 floors when the other two were in it.”
It is just a "promotional driven developement" company now. They have 5 versions of windows mobile?
Nobody gives a fuck about the company's product anymore, we (I work there) just care about our promotions that are MANDATORY based on CSP's (Career Stage Profiles).
Do you want to end up with product code like that? I don't think so.
Yes, yes, yes. Most employers do understand what makes a good programmer. So, they often end up hiring the longest resume. If they had a little competition to see who's output was the most satisfactory a lot of bad developers would quickly become good or leave the market place.
No sigs in BETA. Beta SUCKS.
This is the sort of solution I see proposed by business stakeholders who've been burned by out-sourcing or consulting.
I say, if you can't build it yourself then you shouldn't be directly involved in managing it. Too often I find that business stakeholders tend to stick their noses where it doesn't belong. Inolving themselves in this way does more harm than good.
Who wants to work longer hours, invest in more training, and constantly feel like you could lose your job?
Nobody. Not even the managers and CEOs. So why is it okay to think programmers would just love to work this way?
If you don't know what the bowels of the application should be doing, how do you design the GUI? How do you design a GUI if you don't know whether it's for a spreadsheet or a media player?
Well, I have one answer: "Customer focus groups say they want a call block list and a call forwarding feature."
An understanding of what your users want and what you're trying to help them achieve decides what features your application should have.
The desired feature set shapes the back end as well as the way the features are presented to the user for him or her to call upon.
Else, I think you get into nonsensical situations.
Compare these two statements:
(1) Because modern computers are equipped with a control key and a Z key and our user interface designer created a menu item labeled "Undo" with C-z as the shortcut, our editor supports undo.
(2) When humans write things on a computer, they make mistakes from time to time, but the notice soon after. To help them correct their mistakes easily, our editor supports undo.
Which one sounds most sensible? In which one does the GUI design drive the feature set? In which one does the feature set drive the GUI design?
I think you're confusing "this program should support Undo" with "there should be a rectangle with the word 'Undo' in it". You're confusing things, processes and properties with their visual representation; probably as a reaction against someone confusing them with their implementation.
Good design chooses "Should support Undo" before "Edit/Undo and Control-Z" and also before "maintain a 'vector of state_t', containing all the previous states of the document".
(Oh, and by the way, if you write some code to find out what's possible, you might get good ideas as to what the user wants; you've probably experienced the "Hey, that's cool! I didn't even know I wanted that!". That's what I'm on about here.)
They aren't gonna come bitching to you about how your databases lack some index, but they might complain that your list of videos isn't dropping stop words like "The" or "A".
How is sort order a property of a GUI? Bonus question: same question, but assume the application in question was a command-line one; no curses, just argv and stdin to stdout. How is sort order not completely orthogonal to graphics and interaction?
Henry Ford did this in the development of the flathead V8. He had teams, which he micro-managed to death, and put strange engineering requirements on each team. One team was supposed to design the water cooled engine that used no water pump, another without an oil pump, etc. Ford apparently had an aversion to pumping fluids. He also isolated the teams to make sure no ideas could be shared. This necessitated completely separate shops with all of their own machinery. The teams didn't know of each other's existence until later on. If you are willing to work for one of the many 'idea guys' out there, make sure they are really smart, not just bipolar psychopaths. If they have a long string of failures, they're probably not going to tell you about them.
Yeah... I worked for a company who handled employment this way. It may have made for better individual skills (Though this was by no means clear), but it *killed* any team skills because it reduced collaboration to competition. It was perhaps one tenth as effective in terms of overall productivity when compared to the next worst team I ever have worked on.
...the speaker made an analogy regarding an individual's role in the organization. He asked them to think of putting their hand in a bucket of water, and then withdrawing it, then asked "how fast does the water replace your hand when you take it out?" Instantly. "That's how quickly you can be replaced."
"Think of your boss putting his fist up your rectum.
How fast does your colon replace it with shit once they take it out? Instantly - that's how much I'll miss your crappy job.
Oh, and remember to wash your hands before returning to work . . ."
Please accept my apologies if that is a little graphic, but it is important to consider both points of view.
As Charles de Gaulle said, “The cemeteries of the world are full of indispensable men.” Most of those were HR managers.
Ask Me About... The 80's!