3 ms·
It's ultimately about making them make the right decisions, and building up a non-broken mental model of how to do things. Lots of their actions are likely just
by bane 12y ago
It's ultimately about making them make the right decisions, and building up a non-broken mental model of how to do things. Lots of their actions are likely just from ignorance of alternatives, but it could also just be a broken decision making process.
The idea is to make them part of their own reformation:
- Don't set deadlines, make them set deadlines, document it, then hold them to it. Make the penalty for missing their own deadline big. Because you've documented it, if they make a pattern of missing their deadlines, work with them on learning to better gauge and estimate their level of effort. Review the cases where they miss the deadline, find out why, build up a pattern. It could be they just don't understand how some library works, or how the build tools work etc. It could be an external dependency they have no control over. Either data-point gives you tools to help them learn how to do this most basic of tasks.
- If you tell them something once, and they come back again, the second time make them write it down in a binder of notes, if they come back again, make them refer to their own notes. If they come back yet again, make them do a full report on the topic, put it on an internal wiki, and treat it like a High School writing assignment. It sucks for them so they'll never want to do that again, but it produces useful information for other people.
- Don't tell them what to do. But make them describe their strategy to tackle the task. When it sounds like they're doing something wrongheaded, ask them why they're doing it that way instead of the obviously better way. Maybe they have a good reason, maybe it's out of ignorance. Take it as an opportunity to make better ways available to them. But the decision for which way to go is up to them, so long as they hit their self-imposed deadline.
- jnbiche 12y ago> Don't set deadlines, make them set deadlines, document it, then hold them to it. Make the penalty for missing their own deadline big. Software time estimates are a legendarily hard problem. Experienced developers get better at it, but still frequently miss deadlines, often by large margins. And you're somehow not only expecting beginner-intermediate programmers to be able to set accurate estimates, but enact "big" penalties if they miss them? And if your argument is that these are small tasks, and they should be able to figure out estimates for them, then I'd point you to the all the studies on software estimations that suggest that major project overruns are usually not due to lots of little tasks being 20% or 30% late, but rather on 1 or 2 tasks on the critical path being 1000% late. We're all familiar with this problem. If you've been programming long enough you've run into quite a few of these "gotcha" tasks, not matter how good you are. I think your other ideas are very good. Actually, I'd take some of the ideas from your last two points, and apply to the first. Instead of penalizing the developer for overruns, have them write up brief case studies that outline why there was an overrun, and put it on the company wiki. I think having to write up a case study is probably an appropriate "penalty" for something that may have been out of their control (although I really wouldn't suggest portraying this activity as punishment, but rather as a critical response to overruns). But "big" penalties for missed deadlines is just pointy-hair boss territory. Given the quality of your other advice, I have to believe you weren't referring to an actual big penalty, like docking pay or missing a promotion.
- bane 12y agoSorry yeah, I communicated that poorly. "big penalties" is meant to mean exactly what you wrote. Spend some time studying why they went over and do a write-up on it. I've found most developers hate documentation more than anything, and making them do work like this is a "big penalty". I agree that software estimation is hard, but that's usually at the macro-level. Micro-level estimation, within a few percent is usually pretty reliable. What happens at the macro level is that those tiny percent uncertainties compound up and interact in all sorts of horrible ways. But "do you think you can build the database connector and load the data by next Friday?" is not too hard of a problem, even at the junior level. I think more importantly, if they come back and it's not done, but it's not their fault, they'll get comfortable coming to give you bad news, which is super-critical for macro-planning.