Motivating Your Co-Developers?

3flp asks: "We've heard all about those coding projects where 90% of the code is done by one person. Unfortunately, on my current project it's me :-(. It's a comms DSP project with a lot of C & some assembly. My team of 4 will hopefully produce about 20k lines of code. Now comes the problem: we just got to our first small integration stage (we do try to do them early & often), and it turns out the other guys have got nothing. No code. I want to ask Slashdotters, people who have the experience with small software projects, how would you go about it? How to bring other less experienced coders up to your level and beyond? Or at least how to make them suck less, and if they get stuck on something, to just come and bloody ask for help?" This is something almost every developer has had to deal with. For those of you who have experienced this, what did you do about it and how did things turn out?

"Deadlines are super-tight (what else is new)... but all 'my' parts are ready on time, and I enjoy what I'm doing. After about a month of design and two weeks of coding, I've got about 50% of my software features. The others definitely do understand the requirements and the design, because we had plenty of discussions. 'All right, lets get what you've got so far, we'll just try the interfaces, even if your code doesn't do anything much yet.' 'I haven't tried to compile it yet.' Then I looked at the little code they've produced, and it's a disaster (abhorent coding style, serious logical mistakes, etc). Obviously, these guys understand the 'domain' problem (I would think that's the hard part), but suck at coding (which is apparently the really hard part for them).

Hiring new people this late in the project won't work, as anyone who has read 'The Mythical Man Month' knows. On this project, I have a de-facto role of a software team leader. Before, I've always been just a coder, not responsible for others. So okay, I'm doing fine with my part of coding, but that's no use. If others don't catch up quickly, we'll have serious problems delivering on time. I need to stop hacking on 'my' part of code, and help elsewhere. They definitely do understand the requirements and the design, because we had plenty of discussions. 'All right, lets get what you've got so far, we'll just try the interfaces, even if your code doesn't do anything much yet.' 'I haven't tried to compile it yet.' Then I looked at the little code they've produced, and it's a disaster (abhorent coding style, serious logical mistakes, etc). Obviously, these guys understand the 'domain' problem (I would think that's the hard part), but suck at coding (which is apparently the really hard part for them).

Obviously, I need to look into some way of helping or motivating, but without putting them off. I could just take over someone else's module and code it in no time. But if anyone did that to me... well that's out of the question."

Comments

How to motivate your codevelopers:

[johnthorensen]

Block "http://www.slashdot.org" at the firewall :)

-JT

Re:How to motivate your codevelopers:

[Polo]

Or maybe redirect all slashdot requests to just this article... ;)

Re:How to motivate your codevelopers:

[scotch]

Plus sex with interns is usually better and easier!!!

Writing Code isn't the big deal

[Anonymous Coward]

Do you know why you make code readable and add nice comments?

Because MOST of the time of a project is dedicated to Maintainence and Debugging. Writing the code is the smallest part. As long as your team UNDERSTANDS the code written, you should be better off during the debugging phase. Just say "Hey I spent all my effort writing it, you guys need to debug more than me to balance it out!" ;-)

Bad programmers don't change.

[sllort]

My experience is that while some new programmers are destined to become good programmers, experienced programmers who don't write code rarely improve. My advice is to make sure there is tons of visibility and documentation early as to who is actually doing the work - and make sure management has access to this visibility. From that point, it's the responsibility of management to do their job and manage the resources they have. Taking this role upon yourself is usually a mistake.

Re:Bad programmers don't change.

[ergo98]

Whoever the project manager is should have recognized different skill sets or motivations very early on and pursued actions to rectify it. While about 90% of the postings to this thread have been "Boohoo, I'm out of work so fire them all!", the reality is that no business sustains with a "fire them all" mentality (which is why those posts are all by people working for someone else), and the reality is that almost every talented employee has periods of low productivity, sometimes lasting for months. Again, these are just basics of human nature that one has to recognize and plan around.

The reality is that people are motivated by varying things (and "fear of being fired" is the #1 worst motivator and is the cyclical spiral to oblivion for any organization), and a good project manager understands how to understand and utilize those motivations (and it very seldomly is $, by the way): The biggest ___KILLER___ to motivation (and it's a killer in the sense that people will write garbage code, if any at all, regardless of their skillz) is a project death march: A project that has no hope in hell of ever being finished, and is absolutely guaranteed to be killed. Any talented coder will have a brain gnawing at them screaming "THIS IS A WASTE OF TIME!", and the truth of the mater is that in the end, sitting around reading Slashdot all day, or dutifully spitting out lines of code, has the same net result: The project is canned and the code is deleted. There are many projects out there like this, pursued by managers with agendas and severe myopia: If your project is like this then good for you, but realize that it won't be long before you too spend your days wishing for 5pm to hit.

Re:Bad programmers don't change.

[msobkow]

After 15 years in the industry, I'd say there are three classes of software developers:

1. The natural coder. This is the person with an intuitive grasp of technology, who sees the similarities in software architectures and reuses concepts across disparate technologies. Alas they are rare, maybe 1/10 qualify.
2. The "steady Eddie" programmer. The vast majority of support staff, documenters, etc. are "steady Eddie" types. They do the job, they follow instructions and designs, but are not necessarily creative or intuitive about it. They're the people who form the corporate infrastructure, and about 7/10 fall in this category. They are much slower than the natural coder, but do get the job done.
3. The clueless wannabe. Fortunately there aren't too many of these on projects I've worked on, but there are still more of them than natural coders -- I'd say about 2/10.

The original poster's commentary indicates that it's a relatively young/naive developer who is either a natural coder or a steady Eddie with an overblown ego doing the writing. Either way, I am guessing that he is quick to grasp concepts and ideas, and gets easily frustrated with people who don't -- and it shows. Even if such people try to be understanding or are "open" to questions, the way they phrase their answers is often intimidating to their peers.

You need to make sure people understand the project is truly a team effort, not a blame game, and encourage questions. If no one is asking questions, check with them daily to see how they are doing, but handle it as an offer to help out or clarify specs rather than just getting their status.

Learn the skills of your people. Those who can't code are often good at other things -- debugging, screen layouts, build management, etc. Very few people are actually useless, they just aren't necessarily good at what has been assigned.

When working with a team of juniors, start out by creating the outline of the code -- makefiles, interface headers, and stub code. Don't get into the details of your code -- make sure the overall project has been outlined. It helps juniors a lot to have a solid interface they are expected to implement, and it helps to modularize the system code.

When people ask questions, don't give them the answer, even if you know. I'm serious! Guide them with questions that lead to the answer, but let them come up with the solution if at all possible. This helps them to learn how to think (your questions show what they should be asking and thinking about), and they gain confidence by coming up with solutions "by themselves."

Ignore all the postings you've seen about beer, pizza parties, and threats of layoff or termination. You'll never succeed with a project if you are wasting your time and budget on frills and turning your staff into nervous wrecks.

If you do encounter a truly useless clueless "developer" who just doesn't "get it", make sure they're working on something non-critical and that their access is restricted. If you have to keep them on the project, try to use them as testers or for "grunt work" like build management. Even the most clueless person can follow a checklist to test software or compile code, and sometimes they can actually become quite good at it. Believe it or not, you need people who will be happy doing the mindless work -- most of the work on a large project is mindless.

Don't create your schedule on the assumption that everyone is going to code as fast as you. Be realistic, and then double the time allotted. Sad to say, I've often found that still doesn't allow enough time for some people.

If you find anyone on the team playing the blame game, snuff that thread. If someone complains about weak specs, redirect the discussion to suggestions about how to improve the specs. If someone is blaming other people for being late with interfaces they "need", redirect to a discussion of modular programming and how the interfaces can be designed without a full implementation. Whatever you do, don't let people get away with blaming others for their own shortcomings.

Perhaps most important, don't use the "big stick" of layoffs and termination to encourage people to work. If they are any good, you'll just scare them into finding another project, leaving you without resources. If they really are useless, no threats will improve their skills and you're going to turn the team into quivering, terrified blobs who would rather chew their own arms off than ask you for help or guidance.

Failing all of the above, make sure that management is aware of delivery issues and potential schedule changes early on. Even if you think you can recover lost time, make sure management knows the time has been lost so that it isn't a surprise if things don't turn out as you hope. Ensure that you've got a feature prioritization so that you know which features to sacrifice if it's critical to get "something" out for a given date.

Finally, keep smiling and keep it light. When all is said and done, it's just another project, not your life, and you'll only get ulcers by stressing excessively. More often than not things don't work out as you'd like, so learn how to manage them in the direction you need when they take a turn.

Being an arrogant SOB myself, it took me years to learn to be more gentle with my coworkers. Rather than bluntly stating my disappointments, I find it's much better to provide them with the interface headers (potentially with stubs), and let them code from there.

Re:Bad programmers don't change.

[FlatEarther]

make sure management has access to this visibility

You've got it made. Management will surely know that you've been doing all the work - because right now you're working with your future management team. So try not to piss them off too much !

The Earth is truly flat - it's only space that's curved

Re:Bad programmers don't change.

[0WaitState]

Best Post! This guy gets it. Only thing I would add is the use of code reviews, first as a teaching tool (review the better coders' work first), then to improve the lesser coders quality after they've gotten accustomed to the review process.

Don't be an ass.

[joshamania]

Number one, don't be an ass. I've been on projects where I've been treated as something less than human for asking questions. That is not very conducive to productivity.

If you truly want to bring the "lesser" coders up to speed, you're going to have to make an investment of time. You may even want to consider pair programming for a period of time. Not only will it make the other coders familiar with your style, but it may make them aware of many "tricks" that aren't documented in your standard learn-to-program-in-21-days piece of garbage college course.

Re:Don't be an ass.

[Manitcor]

Your method sometimes works however is not fool-proof. I had a similar situation a couple of years back and tried to work every possible angle. When it came down to it he was a nice guy but was dumb as rocks when it came to coding.

Turns out he was just really good at getting hired and then talking others into doing the work for him.

Of course people like him ended up getting fired every 2-3 months and moving onto some other company to leech off of.

Fact of the matter is becasue of the boom, everybody and thier dog decided it would be a great idea to get into tech (coding, networking, whatever)

Companies were so starved for labor that they would hire anyone who even sounded like they knew what they were talking about.

now that we are bottoming out and IT budgets are getting slashed only the best techs and the best of the bullshitters will get through.

My advice: dont let these bullshitters continue on, send them packing and hopefully they won't sucker some other company (if they do hope its your competitor).

I would like to feel sorry for all the people who have been laid off and fired during these times but from what I've seen many of those (there are of course exceptions) who have were worthless anyway and the teams I'm beginning to see now are more focused, better trained, more expierenced and know what its like to deal with the real world.

Of course there are still many fakers out there and I only hope that we can weed even more out over time.

And before you go off ranting about people who are just starting to learn: I have no problem if you are new and just learning, what I have a problem with are those who know the buzzwords and can code some scripts then talk a big game. However when it comes down to the wire and you have to go live in 3 weeks and still have a week and a half of Q&A and you still havent learned the API of the application youve been coding for the last 6 months then I have a problem.

Do I sound bitter??

and yes my spieling and grammer sucks.

Re:Don't be an ass.

[ivan256]

Telling them that they need to get their skills up to par won't do much good. When I've run into this problem with people, I try to make them feel at ease. Try holding after hour gatherings the local bar. Then don't talk about work. Once they feel you're not an ass, then start bring up the concepts of work. When I've treated by co-developers with respect, I generally get respect back.

Yep, that works great. Unfortunatly, after you have respect you still get to do all the work yourself. People who don't work will never work unless their job is on the line. People who can't figure out how to do their job after years will never figure it out. Unfortunatly a sizeable percentage of professional programmers fall into one of those two categories because the jobs paid well, and there weren't as many good programmers as there were jobs. It's also hard to tell if somebody is a good programmer or not when you hire them. You typically can't look at their previous work like you can with somebody from almost any other profession. Also, people who can't tell and hire bad programmers, tend to hire lots of bad programmers. Anyway, back to the point: Respectful coworkers are not necissarily competent, hard-working coworkers.

Of course for some of us that's not an issue, because the rest of the development staff on your project gets laid off and you have to write and test the whole 20k line product yourself anyway. I'm not bitter though. I didn't have to stay, and at least I like all the code now, and when something is broken I don't have to count on somebody else to fix it. Unfortunatly, the long hours aren't scoring big points with the S.O.

Re:Don't be an ass.

[tongue]

I'd recommend pair programming in this case. Ordinarily, I think it isn't terribly conducive to getting a lot of work done, enough to justify two bodies at one keyboard. But in this case, it seems that two bodies at two keyboards is the functional equivalent of nobody at any keyboards.

Pair programming will probably make them stay on task better, since they'll sort of "guilt-trip" themselves into it. When one of them has a problem, chances are the other will know how to solve it.

Also institute daily builds using ant or somethign of that nature. That way there's no excuse for not having compiled the code--and when it doesn't compile, everyone gets a report. Another way to push the guilty parties a little harder to get their ass into gear.

I think most of the concepts of extreme programming apply to your situation. Programming methodologies in general hold back great programmers, but their reason for being is to help mediocre programmers become good (and productive) ones. I'd say this is a textbook case.

Also, having been both the 90%'er and the lazy fuckoff at various points in my career, i can tell you that motivation is everything. Pool tables and perks won't get the work out of them--they truly have to feel like a team, and feel like they're letting the team down when they slack. From your post, it would seem that you don't really feel the team effort either. I think that the most important change you can make would be to help foster that atmosphere. You also mentioned being the defacto lead on the project; don't assume that position unless its given to you by someone with authority to do so. It pisses off your coworkers.

Re:Don't be an ass.

[joshamania]

Exactly. A good bunch of idears there...

I wasn't specifically thinking of eXtreme programming, but pairing two of your lessers will certainly add motivation. It's much harder to play freecell if you have another person sitting there watching you be a dipshit.

frequent feedback and monitoring

[cifey]

Well assuming you can't fire somebody, I guess you have to pick the people you think are actually capable of performing and monitor them frequently, via emails and daily face to face discussions, the rest, just make sure they aren't on your next project team.

A few suggestions...

[Yoda2]

When starting a new programmer, I find it helpful to find some similar code to let them have a look at. Starting at zero can be intimidating. Changing someone else's code is a good way to learn until you know what you are doing. Daily reviews until they get going is unpleasant, but probaby necessary at this point. Make sure your team has access to good reference books. Reduce their modules to very simple components. Newsgroups, newsgroups, newsgroups.

Here's your decision tree

[geophile]

Speaking from experience: If it's feasible, finish the project yourself. Don't count on people who have proven incompetent.

If this isn't feasible: Either your product is vital to your company's survival, or it isn't. If it is, then it is your responsibility to let your boss know about your project's troubles, and his boss, and keep going until you reach the CEO, if necessary. If this doesn't work, then the next thing I'd design, if I were you, would be my escape.

If your product is not vital to your company's survival, then either it will get done, slowly, and you'll have no life until you're done; or it will just fall apart.

Meetings

[Tall Rob Mc]

If you are capable of producing their work in a short amount of time, clearly you have an idea of how it can be implemented. Sit down with each one individually and get to finer details of their roles. Help write pseudocode, if necessary, and then let them actually bang it out. I'm suggesting, in a way, that you do it all yourself without quite doing it all yourself.

Move up the food chain

[gosand]

Yeah, it sucks that you are the lead of people who can't do the work, but all you can do is lead. You can't make them work. I would go to the project lead, or your manager, and say what you said here: "If others don't catch up quickly, we'll have serious problems delivering on time. " Yeah, it might not be the nicest thing to do, but you aren't there to grab each other's asses, you are there to do a job. I assume you have already given them time to do the work. If you haven't spoken to them personally yet, do so. Tell them their code sucks, ask them why they don't have anything done yet. It is your ass on the line as the lead.

Here's what I'd do

[Bilestoad]

You bear some responsibility for allowing this to happen. Planning for an early integration is right, but you can't ignore everything up until that point. However, now it's happened...

you have to seriously assess whether the people you are involved with are competent. If you're absolutely stuck with them (assigned class group, nobody else available) then you have to do two things. These are to plan on doing all the work yourself and to come up with a new schedule based on you having to do the whole project. If they contribute anything, it's a bonus.

If you can get someone else who is competent, get them. Brooks was right but like most authors he is only 100% right when the situation exactly matches the one he experienced. If it just can't be done with only you then what choice do you have but to add someone else? I believe Brooks showed that you definitely experience gains when you go from one to two programmers, even from two to four. You just don't gain much at all when you go from one hundred to two hundred.

Whatever you do make it clear to your manager/professor that you did the whole damn thing. Make sure each module is owned by the person who actually completed it. And if every module has your name on it, perhaps you'll take some credit away from an otherwise bad situation and the others will be assigned tasks better suited to their abilities in future.

Re:Here's what I'd do

[ErikZ]

I find this whole situation suspicious. What are the odds that EVERYONE on his teams sucks, but his shit smells like roses?

If he's in charge, then maybe they're waiting for him to take charge.

a real answer

[Jucius Maximus]

Have a manager call a meeting with all of you for the purpose of demonstrating what you have so far. This will get your group into gear. Just have the manager send everyone an e-mail that the meeting will be in room number [...] at time [...]. Don't have the manager come and ask, "what time would be good for a meeting ... ?"

I know from personal experience that this is a good motivator.

Its a tough job and a somewhat dangerous one..

[cOdEgUru]

(1) People hate other people tell them that they suck at something. Whether they tell you that they are open to constructive criticism or not, they still would hate you.

(2) Sometimes its just easy to laterally move developers from one project to another if they are not being productive, than bringing the whole team and the motivation down. This could be done without raising any suspicions and with diplomacy.

(3) Sometimes constant probing helps, sometimes it doesnt. Reminds me of the dibert cartoon today where the guy wont do a thing without some sort of threat. He may not need to be threatened but send the PM to him every couple of hours anyway. Sometimes this could be detrimental to his position, but atleast he might realize somethings wrong.

(4) Theres shit happening everywhere and in every other company. This guy could just be freakin out about his job, his family, his wife, his parents and everyone he has to support if he loses his job. And hence instead of working hard to sustain his job, he might do the other, by wasting time getting more tense day by day. Its better to have the PMs or someone else from the team he confides in, to talk to him. But then again, that just might shoot his stress level through the roof.

(5) There are some people who just suck at certain stuff, it could be coding, communication or inability to gather requirements from the right people, and in turn building stuff that theres no need for. You will have to address these issues from the team leader level, keeping your team focussed towards the common goal

(6) These are people we are talking about here. Sometimes nothing works. Thats the way it is.

Pair Programming

[HisMother]

Two words: pair programming. Two people writing code together at one computer. One typing, one kibitzing.

See www.pairprogramming.com . If you haven't tried it (and many people haven't) your reaction will be "that would never work, and I'd hate doing it." The truth is that it works very, very well, and people like it when they try it.

By pairing with the newbies, you can mentor and monitor them Change pairs several time a day, insist that all code is written in pairs, and before long, you'll have a team of clueful people. Total team productivity will quickly rise.

As I said, if you haven't tried it, you're almost certainly going to think it's a bad idea; turns out it's not. Anyone tempted to follow up with "that would never work, PP sucks" please go off and try it for a week, first.

Re:Pair Programming

[IamSorrow]

This is part of Extreme Programming, if all you do is implement paired programming you will fail, in order for pair programming to be sucessful you should use as much of the extreme programming Philosophy as possible:

Customer Team Member - Teams have someone (or a group of people) representing the interests of the customer. They decide what is in the product and what is not in the product.

Planning Game - XP is an iterative development process. In the planning game, the customer and the programmers determine the scope of the next release. Programmers estimating the feature costs. Customers select features and package the development of those features into small iterations (typically 2 weeks). Iterations are combined into meaningful end user releases.

User Story - A User Story represents a feature of the system. The customer writes the story on a note card. Stories are small. The estimate to complete a story is limited to no greater than what one person could complete within a single iteration.

Small Releases - Programmers build the system in small releases defined. An iteration is typically two weeks. A release is a group of iterations that provide valuable features to the users of the system.

Acceptance Testing - The customer writes acceptance tests. The tests demonstrate that the story is complete. The programmers and the customer automate acceptance tests. Programmers run the tests multiple times per day.

Open Workspace - To facilitate communications the team works in an open workspace with all the people and equipment easily accessible.

Test Driven Design - Programmers write software in very small verifiable steps. First, we write a small test. Then we write enough code to satisfy the test. Then another test is written, and so on.

Metaphor - The system metaphor provides an idea or a model for the system. It provides a context for naming things in the software, making the software communicate to the programmers.

Simple Design - The design in XP is kept as simple as possible for the current set of implemented stories. Programmers don't build frameworks and infrastructure for the features that might be coming.

Refactoring - As programmers add new features to the project, the design may start to get messy. If this continues, the design will deteriorate. Refactoring is the process of keeping the design clean incrementally.

Continuous Integration - Programmers integrate and test the software many times a day. Big code branches and merges are avoided.

Collective Ownership - The team owns the code. Programmer pairs modify any piece of code they need to. Extensive unit tests help protect the team from coding mistakes.

Coding Standards - The code needs to have a common style to facilitate communication between programmers. The team owns the code; the team owns the coding style.

Pair Programming - Two programmers collaborate to solve one problem. Programming is not a spectator sport.

Sustainable Pace -The team needs to stay fresh to effectively produce software. One way to make sure the team makes many mistakes is to have them work a lot of overtime.

Re:Pair Programming

[HisMother]

> if all you do is implement paired programming you will fail

Well, no. That's not true at all. In fact, XP advocates universally recommend what Kent Beck attributes to Don Wells in the first XP book:

1. Pick your worst problem.

2. Solve it the XP way.

3. When it's no longer your worst problem, repeat.

You shouldn't and actually can't adopt XP all at once; you have to start somewhere. And for this guy, pairing is the place to start. You certainly can't recommend that these folks who can't squeeze out any code at all by themselves be encouraged to styart refactoring his code, can you?

Re:Pair Programming

[st. augustine]

come on....do real companies use this horsecrap?

Yes. It works great, so long as your developers understand that software engineering is more than just writing code.

Re:Pair Programming

[st. augustine]

Except in the Real World where you don't have enough developers for people to work in pairs all the time

This is a common fallacy, and a lot of us at the company where I work believed it until we'd had a few weeks of exposure to pair programming. Over the long term, two developers working in a pair will be at least as productive as they would be working alone -- first, the code they produce has fewer bugs; second, there are now two people who can maintain that code, so you've lowered your truck factor; and third, while they're pairing they can't be reading Slashdot.

and the project is too big for everyone to understand every part of it.

We thought that, too. But you don't need everyone to understand every part of the project. What you do need is for more than one person to understand each part of the project. I'd estimate that with most areas of our software, there's one person who knows it inside and out, one person who's at about 70%, and two people who are at 20-30% and could get up to speed quickly if they had to. (For reference, this is in a development team of ten, with a large multi-tiered cross-platform Java/C++ project containing about 1200 classes.)

Also, when I'm deep in "the zone", I don't want to be bothered by someone leaning over my shoulder.

No offense, but I hate trying to debug really tight code written by someone else who was deep in the zone. Unless we happen to think a lot alike, it's often a real bastard to try to understand what in hell they were doing. Pity your fellow developers and allow them some insight into your thought process. :)

And when I'm following a very careful train of thought while trying to debug a once-in-a-while seg fault, I definitely don't want to be interrupted.

If your pairing partner was with you when you started the train of thought, they wouldn't be interrupting you.

If I want help, I'll go ask for it.

Yes, but will you ask for it when you need it, or only several hours later when you've given up on figuring it out on your own?

Fire them.

[Spud the Ninja]

I could just take over someone else's module and code it in no time. But if anyone did that to me... well that's out of the question.

It's not out of the question, it's the answer. Not doing the job you were hired for is a fireable offense.

Show them the coding standards that are to be followed. Show them the requirements. Show them the deliverable date. If they can't make those 3 things come together to the degree neccesary, show them the door.

Well....

[tomblackwell]

The fact that "The Mythical Man-Month" says something doesn't make it automatically applicable in all situations. I mean, replacing people who haven't done anything? I don't know if you're losing much, there. If they'd come up with something that a replacement might have to get their head around, I'd tend to agree. But they've apparently done dick.

Your boss should recognize the efforts.

[Real World Stuff]

I have seen this happen before. The project manager, or the Department Head will eventually recognize who have not pulled their weight. This is what we managers cover in "milestone overviews". These are Pre-planned development gauges to ensure that collaborative efforts synchronize. Additionally, they provide hard data at review sessions and for salary matrixing. Motivating your co-developers is not your job, leave that to the manager. That is what s/he gets paid for. Do your part, collect your pay, and just gut it out. Eventually the less apt and inconsistent performers will be out the door. Hell, in this market there are 10 COMPETENT developers waiting for a shot.

Mentoring...

[CommieLib]

I've mentored a number of number of programmers, successfully, at least in our collective opinion. I think the key lies in the idea that "a question well-asked is half answered."

Most new programmers tend to come to me with nothing more than a vague sensation of "it doesn't do what I want it to." The proper reply for this is "come back to me with a good question." Until they can do that, they cannot be helped.

Once they have a good question, don't give them an answer; give them the other good questions that lead to / issue from that question.

Once someone knows how to ask good questions, they're halfway to becoming a good programmer.

Have a good talk to them.

[theolein]

Organise an informal meeting. Point out to them that the success of the project is dependant on them. Point out to them that if the project fails they might lose their jobs. Ask them why they haven't done anything. If they have no real reason tell them that you cannot work like this and will have to report this to management.

I wouldn't go gung ho on them but you have to get some clarity on why they didn't do their work and you have to draw a line somewhere. Just make it clear to them.

Re:Use XP

[ultima]

My suggestion as well; in particular because extreme programming encourages one practice that improves productivity. Check out the website here - and pay attention to the concept of "pair programming" where programmers work in a team. Putting a good programmer with a bad programmer for a moderate period of time will often raise the bad programmer's productivity (though obviously, it kills the good programmers productivity and maybe his attitude). So keep rotating the programmers around until things have become suitably efficient.

The whole concept of XP is a bit awkward and works best in either a teacher/student model, or using expert programmers who know eachother well. Nowhere close to panacea.

Not to mention the acronym sounds evil and M$-ish :)

Re:The perfect motivator

[Budgreen]

know where I can get a hammock?

Different working styles

[Nomad7674]

One point many of the posts so far have ignored is the fact that some of these programmers may not really be so bad, they may just have a different working style from you. My own personal style for creativity is to absorb information en masse for a period of time and then output a mass of stuff in a very short period of time. For my coworkers who spec, diagram, and plan out each microstep of their work, it can sometimes seem like I am doing nothing. They feel they have pages 1 thru 7 of their spec complete and I have nothing. Then suddenly three days later I am done and they are only on page 10.

The critical thing to manage different working styles is to clearly communicate your expectations. If your coders see a general project plan, they may well assume that the milestones you have set are "guidelines" and not requirements. If so, they will instead be aiming at whatever they consider to be the drop-dead milestones. But if you clearly get across that every milestone must be met then each person can manage his/her own working style appropriately... even if they may have to come to you and explain that the deadlines you have set will not work for them.

That is my 2 cents. It is also possible you just have an unmotivated, unskilled team and all of this "work style" stuff I am saying is irrelevant. But I find too many managers (both newbies and veterans) assume people are identical plug-in replacements which work the same way they do. Humans just don't work that way.

Find your (their) niche

[datastew]

In the past, I have been the less-productive person on the team. Back before I started programming, I was working as a Mechanical Engineer. I was a perfectionist doing custom engineering work where, in the words of the engineering manager:

"The design is 80% done when it goes out to the machine shop to be created. The machinists and other production people fill in the other 10% and the final 10% is luck."

I was always behind and had to deal with the frustrations of my co-workers and managers. I found myself looking for work, and decided that since I had always liked computers, maybe I should look for a computer job. I am doing much better now as a programmer, where the ultimate product has to be 100% correct or it does not work properly.

It sounds like these people may just need to find their "thing," which could mean removing them from the programming dept. Regarding your current dilemna, they probably won't mind if you take over coding their parts of the project. I experienceed being removed from the engineering dept, and people taking over the parts of my project that I was behind on, and I understood why and was OK with it.

Re:Don't motivate...

[TeknoDragon]

I unfortunately have become jaded enough to agree. (heh, your initials aren't JP and you don't work for HP right?)

If you have sufficient weight in the group, then, you need to take over the project, fire the other developers, and start interviewing.

There may be an option...

You do all or most of the thinking, they do all the monkey work. First-year comp-sci stuff... build them up slowly when they show insight or improvement. If they can do some of the assembly parts (IMO also monkey work) then have them do that.

If they understand the project domain then make them write the test cases. Have them write the test divers. It's obvious these people need daily supervision, chat with them about what problems & challenges they're having on a daily basis. Review each other's code. Peer review is a great educational process.

How's this? Fire the one that sucks the most. If you can hire a (one) ringer. If that doesn't work out or you can't find a really good programmer don't hire. If the other team members continue to not work out then let the others go and report that your project will be done by you... then ask for stock (or options) and early completion bonuses. ;->

Hire me instead

[LordNimon]

Emebedded system, C and assembly? The other developers can't write code fast enough? If youre company is in Austin, TX, may I suggest that you fire one of them and hire me instead? I can assure you, you won't regret it.

Heres what to do.

[Ironpoint]

Your colleagues will never live up to you, so I suggest quitting now. When you say you are the "de-facto" team leader, I'm guessing this means you are not the real team leader. You've got prima donna syndrome written all over you. You can either

1. Quit now
2. Slack off a bit and see if the others pick up. (Your not in charge, what are you worried about?)

But you will probably do

3. Continue doing your own thing and keep telling yourself how crappy your teammates are until your ego explodes and you get fired or quit.

Truthfully, in programming this is the most important thing to overcome. People become so attached to their work. Now imagine you are on a team of professional toilet cleaners. Without the galmour theres no ego involvement. No one ever said, "I'm such a good shit cleaner, my fellow shit cleaners can't keep up. What do I do?" Its just about getting the job done.

By doing most of the work, you are fucking yourself. Your superiors are the only ones who can rectify the problem. But they won't if they expect 90% of the work from you. And you can't just reduce the work you get done because it looks like you are slacking and you take shit for it while in reality you are doing the same amount as everybody else. The only thing you can try at this point is soft delegation. Ask people how things are going, ask them about their code, hound them, not like a boss, but like someone who is interested. You can't tell them what to do but by continuously putting the focus of things in their mind, they will respond.

Probably the best solution is go on a two week vacation.

Re:Don't motivate...

[R2.0]

"One excuse I've heard is that if you don't have enough evidence that someone is not being productive and you fire them, they can sue you (WTF, I highly doubt that). "

Allow me to introduce you to the term "At Will" employment. That means that one is employed at the will of the employer. If the employer loses the wiil to employ someone, they can be let go with no reason whatsoever.

HOWEVER...

Thia only applies if one is male, white, under 40, has no disabilities that fall under the scope of the ADA, and (in some states) straight. If you are not one of these, you fall into a "protected class" and, although one can still be fired, the employer needs to document it REALLY well.

Management

[nuggz]

You have to manage your team better.
You are the leader, take responsibility for the output.

Code less supervise more, that is your new job. Break the job into manageble controllable chunks, have them report how they are doing. Check code for correctness (logical and formatting)

If you have 3 people who aren't as capable as you, you are going ot have to spend a lot of time ensuring the final work is good enough.

Also some people just aren't capable of the work, you'll have to really watch what they do.

Re:Don't motivate...

[MadCow42]

Have a coding contest...

1st place is a new Cadillac
2nd place is a set of steak knives
3rd place is "you're fired"...

It's worked before...

q:]

MadCow.

Sounds like you need some project management...

[st. augustine]

You need someone (not you) riding herd on those developers and making sure they're actually getting work done. The company I'm at uses a lightweight process called SCRUM, where features (or "stories" in XP terms) are divided into small tasks, each developer is responsible for taking on and providing estimates for a fair share of tasks, and every morning there's a (short -- ten minutes, max) meeting where each developer has to go over:

• which tasks they worked on yesterday
• how long they've spent on each task
• how much more time each task will take to complete
• what they're going to be working on today
• any blocking issues they might have

(Any design, problem solving, etc. is deferred till after the meeting, and only the people that need to be involved in those discussions are pulled in.)

The project manager (who is not a developer and not a manager manager) is responsible for keeping track of the tasks and the hours and making that information available. It's always clear who has responsibility for what and who's blocking whom from getting their work done.

This does a great job of keeping developers productive, and since developers get to make their own estimates (and the total amount of work that can get done in a development cycle is based on 40-hour weeks), it also does a good job of keeping them sane.

(It works well with eXtreme Programming practices like pair programming and story-driven design, too.)

I agree!

[John Harrison]

Having played something of a leadership role in large projects involving people of various skills I will share what I have learned.

1. Be open to questions. This will help them respect you as a leader. Make it know to everyone that if they need help then they should ask and you won't bite their head off. You might have to restrict the time if the question asking gets out of hand. Maybe only allow questions before noon. Then you can get your own work done in the afternoon.

2. Spend time sitting down with each member of the group and code with them. Take turns writing the code. Again, do not bite heads off. Don't sit there and simply write their code for them. Explain the concepts that they are missing without belittling them. Have them pair up with each other as well. You will be amazed at what two idiots can teach each other.

3. Dr. Pepper. Lots of it.

4. Stress relief. Allow them to check /. once a day.

5. Have a weekly one hour class. Have someone teach it once a week on some aspect of their code or a programming concept that is useful in what you are doing.

I have seen people that I initially had very little confidence in become pretty proficient at doing their tasks. They didn't themselves in a vacuum, they trained (and motivated) each other.

Typical geek responses

[joshamania]

One of the big problems with geeks is that they can be assholes, as you may witness by some of the replies to my first post.

Did y'all even read the whole original story? This guy has a problem that he needs to fix right now . Firing people for two weeks of uselessness isn't going to solve the problem. If you haven't read The Mythical Man Month, go read it now. Bringing on new programmers half way through a job often makes the job take longer. Firing the old, less effective folks, and bringing on new folks is going to do just that. At the very least, the programmers that are there know the company and know what the project is and know all the other people on the project.

The original poster did not ask "what should I do?", he asked "how do I make these people more effective?". Hiring replacements can sometimes take months, and when you do so, you're not guaranteed that the new programmers are going to be any different than the folks you just fired. So let us focus on how to solve the problem, not make it worse.

Use slashdot to your advantage...

[orius_khan]

Block "http://www.slashdot.org" at the firewall :)

Personally, I just complain about my co-workers on the front page of Slashdot... they all get pissed and quit, and then I can replace them with new people who know what they're doing. Seems to work....

My Nightmare Project... and the saveing grace.

[dallask]

I certenly feel your pain, I am currently the driving force in a 60,000+ code project. We (three of us) have speent a year on this project, and as of today, I have written 52,000 lines of code... and debugged all of it.

Now, I am the project lead, which means that the 5 month late period falls directly on MY head. Looking back on my mistakes, I have enough information to fill one of those "What NOT to do" management books that you have on your shelf... but here is what I have learned...

1) Make short, small, and precice yet reachable goals which every team member of your team must meet. If they cannot meet these deadlines, make it known that their job is on the line if they dont have a damn good reason.

2) Make it a habbit of looking over sholders. NEVER trust that the self touted code guru has what it takes... look at their code ever few hundred lines, or every few days.... it dosent take long to glance at code to know if its good or if its crap.

3) In large groups, impliment a peer review type system. Every week, pick one guy, and pass arround a few hundred line of his code. Pick the code randomly, and you might not want to tell the group whos code it is, there will be no anger direction that way... I found that helps. If the group can follow it, (they dont have to know exactaly what it does, just follow it), then ok... but out of a group of 5, there will be one that gets it just right, 2 that thinks its ok, and 3 that thinks it needs work. Have everyone present constructive criticizem of the code format, codeing methods, commenting, and structure to the group as a whole. The whole group will learn from it, and so will the author.

4) HAVE WELL DEFINED AND DOCUMENTED CODE STRUCTURE PRACTICES!!!! I cant type that in caps enough... if everyones code looks the same, and acts the same, then if you DO have to kick one of them off the team, anyone can pick it up and run with it.

5) If you choose to pick up all the work, then people will let you do it all... the trick is to EXPECT them to do the work! Make them accountable for missing a major deadline.

6) If payment for this project is dependant on meeting deadlines to the client, then make payment to the developer dependant on meeting project deadlines. You have no clue how hard people will work when rent is on the line. :) it is a brutal tactic, but so is the business...

7) Just remember that your not 'Uber Coder... no matter how good you are, your not going to carry the whole project yourself and get it in on time. But if you can make your coders accountable for their own work to the whole group... then you just might make a better group.

Thats my humble advice, now... as for my saveing grace... I have had to carry my project because I learned these lessions the hard way... but the client is pleased with my work, and now, I know.

Pre-Sig : My spelling sucks because Microsoft hasnt implimented a spell checker into IE.

Re:It's been said, but..

[Doomdark]

5. Install Web-tracking software on their PCs and/or the firewall. They are obviously losing the time somewhere, and it's probably due to web browsing.

I agree with some of your points, but I completely disagree with this one. From my POV, people have to be motivated somehow. Usually (or at least usually for me) it's because people have professional pride, somehow they feel what they do is important and/or interesting. Hopefully both.

If they go to Slashdot instead of getting something done, it's not because they can go to Slashdot (or if that really is the problem, they are weak spineless losers who should be fired right away). It's because they prefer that over working. Preventing them access there won't boost motivation or morale. You'll just be plucking small holes in the dam, to no end. On the other hand, if they do deliver and then browse weird web sites, who cares?

Programmers are not factory workers. They don't avoid doing job they like. But if they don't like their job (whatever the reason is -- from jerk boss to boring assignments to incompetent coworkers), they may well do something else. But this something else is usually "anything else", not just specific things you need to block.

In short, motivation is the key. Motivation, skills and experience -- threats can only gain minor temporary motivation ("I can't afford to lose this shitty job"), and never improve their skills (nor constitute useful experience).

Hire....

[_ph1ux_]

.... this motivational speaker for developers:

ballmer

Re:Don't motivate...

[wormbin]

This firing only applies if one is male, white, under 40, has no disabilities that fall under the scope of the ADA, and (in some states) straight. If you are not one of these, you fall into a "protected class" and, although one can still be fired, the employer needs to document it REALLY well.

It's kind of ironic that due to discrimination laws, for the first time in history, young white males actually are superior to all other groups in one way: they can be easily fired.

Re:Use XP

[680x0]

One benefit to pair programming that I haven't seen mentioned in this discussion yet. In addition to letting the bad programmers learn from the good, the project lead can see first-hand whether the bad programmers are lazy (in which case, they'll code just fine with you looking over their shoulder), dumb (in which case they won't get any better no matter how much you kibitz), or just inexperienced (should improve to some degree depending on their partner).

Try the pair programming for a trial period (maybe just a week). With a better idea of where the other programmers stand, the poster will be in a better situation to know what the long-term solution is:

1. Dumb - Fire them
2. Lazy - Motivate them by whatever method you think will work
3. Inexperienced - Continue pair programming if it seems to help, or find another way to train them

Some recommendations from the field...

[Fnkmaster]

I see responses that fall into several categories here: 1) XP/Pair Programming! 2) Push it up the PHB food chain to your boss or his/her boss, etc. 3) Take responsibility, you aren't just a coder, you are a manager now, give them some mentoring and monitor them carefully 4) Get them fired.

These are all not unreasonable suggestions in certain scenarios. A lot of it has to do with the tradeoffs involved in your deadline. I'll tell you this: you undoubtedly need to meet with your manager at some point in time. Lay it out calmly and cooly and explain whether, in your judgement, the team has potential or is beyond hope. Discuss how you can still meet the deadline, or explain that you need to push this deadline a bit because there's going to be ramp-up time associated with getting this team up to speed.

You can be a team leader without being a full-time manager. In fact, you should be, in my opinion. A lead developer for a team needs to be concerned with project design, deadlines/scope clarification (from the technical side at least, though you don't have to spend all your time in MS Project to represent the tech team in this regard). It's better that the lead developer not be directly responsible for HR concerns, schedule reporting, and shouldn't have to be the primary negotiator with the business/requirements side.

That aside, firing people who are continually nonproductive is reasonable - but I'd push that decision up to your manager and let him/her decide that - and generally, unless this is a small startup, people get more than one chance to screw up. Personally, I think they should get two, not five or six. And they should be told that they've been screwing up - ASSUMING that they are supposed to be mid-level or more experienced developers. If these guys are junior, or this is their first job out of school, they need to be cut some slack, and your manager shouldn't have given you a team with four new kids as your first gig as a development lead.

So this leaves pair programming and mentoring. I don't think there's much of a difference, but I'll say this - pair programming is helpful even if two junior/dumb/mediocre programmers are working together. And if you are working with each of them in turn (swapping out) they WILL improve over time, unless they are ROCK stupid. I can't judge whether these fellows are rock stupid, or just inexperienced, or not good at thinking in the logical manner that programming dictates. I have seen people improve in certain ways, but I've never seen a revelation in which a shitty programmer became a key contributer.

If their egos get in the way of effective pair programming (or mentoring - well, hell I think you'll need to be doing rounds and mentoring as well as practicing pair programming as much as possible), then you will need to exercise a bit of leadership skills, and make clear to them that they are partially responsible for the team falling behind and that you all need to work together to get things up to speed. If they still resist, take them aside and explain that they are blocking progress, and you'll have to push that up the management chain.

As for the rest of extreme programming methodology - well, I agree with posters who suggest you might want to try instituting pair programming first, and seeing how that works. If you feel comfortable with that, then instituting the rest of XP for future projects might be a good idea (though I don't know how adaptable some of the methodology is to embedded systems development - it is really geared toward end user app development, IMHO). For other ideas and perspectives check out the book Rapid Development from Microsoft Press (I know, we all hate Microsoft, but there have been some good ideas for software team organization and development methodology to come out of their shop). Plus, it's definitely easier to sell management on organizational ideas from Microsoft than something like XP (though you can certainly find XP success stories out there as well).

Fire them. Now

[wowbagger]

I must respectfully disagree with you - this guy needs to get these guys fired NOW, while at the same time explaining to his bosses that the schedule IS going to suffer in the short run.

I had exactly this situation myself - I had a programmer who was totally incompetent. Unfortunately, his job title put him squarely in my critical path. I had MANY discussions with management about this, and every time it boiled down to "well, something is better than nothing, isn't it?"

Wrong.

We downsized, and he went. Now, I have a competent person filling the role. Guess what? We are having to rip out all the code the moron did, and re-write it. Because we were paying the moron's salary, we couldn't hire a good programmer to replace him. Because we wouldn't admit he wasn't up to snuff, we didn't schedule correctly. Because he didn't identify flaws in purchased code, now we have to live with them, because the service contract has lapsed.

Joshamania is correct in that firing these people will slip your schedule, and that hiring new guys will slip your schedule. However, your schedule is going to slip, period - take a deep breath and get over it now. You can take a single slippage, or you can continue to hemmorage time through these bleeding assholes (now there's a vivid image, if I do say so myself!).

Suck it up, fire the guys who cannot/will not get the job done, and get people who can. You cannot afford to pay someone who isn't pulling their weight.

Two orders of magnitude

[Spazmania]

Back in college, a professor told me that there are up to two orders of magnitude of difference between the the productivity (as measured by debugged lines of code) of the basic "competent" programmer and the guru. Two orders of magnitude. For the math impaired, that means that the genuine guru delivers in a week what it takes the entry-level programmer a year to produce.

I've seen nothing since to suggest that this isn't true. If anything, I've seen proof after proof... Programmers who struck me as bright and experienced, yet time after time they just don't get it. And programmers who do get it. Instantly. In the first two weeks on the job.

You're not going to like the answer, but its this: Hire programmers until you find ones that deliver, and do what it takes to keep them. Fire the rest (which is to say, don't fire them but suggest to them that they should seek alternate employment quickly.)

*Why* aren't they coding? Good/bad?

[billstewart]

What we have here is a failure to communicate. If you're surprised, it's not just a problem with them....

You need to understand why they're not coding. Here are some possible reasons:

• They're still trying to clarify the requirements. Some projects have well-defined requirements, but many real ones don't, and maybe their parts are fuzzier than yours, or maybe they need help understanding them.
• They're still designing interfaces and test plans, and are wisely not writing code until they know what it should do and how to do it right. Maybe your part has more obvious interfaces than theirs, or maybe they need some help defining them, or maybe you're rushing off writing code before you've done your critical design work. Writing code is only the middlish 10% of the job.
• Maybe they're trying to build tools they need to build their real code. This could be forward-thinking planning, or it could be they don't realize the resources they've got available and need help finding / getting them.
• Maybe they're underskilled and over their heads and don't know how to do the job - but apparently you haven't been communicating with them, and also apparently they haven't been communicating with you.

So talk with them first and find out what's going on. If you can't come to an understanding, find a manager to help -- I don't mean a Boss to tell them what to do, I mean a Manager to actually manage the project and people. You probably need one of those anyway, and sometimes programmers can do that but sometimes they don't have the people skills to do it.