Related
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 3 years ago.
Improve this question
I know this may not be exactly a coder question, but I feel it is still related to programming because I'm sure many developers have come across this before and might have some insight on how to resolve this or have advice. There is an actually programming question though.
My issue as a developer.
I work in a small company, roughly 15 people, 5 of which are developers include myself, the rest are tech support and management. Problem I'm having is, when we get a SOW (Statement of Work), our clients give us a rough description of the project they are requesting, which usually is a 1-3 page brief description, usually including a Visio document, now as a programming, I'm responsible for going over the document and relaying a time-line on how long it should take me to complete the project.
Unfortunately, there have been times, not only me, where we under-estimate the project because we didn't fully get into it till we actually developed it, which ends up slapping ourselves in the face, because my boss is upset because he is being hounded by the client, who is now upset because we missed our promised deadline.
My question is, how do you guys handle organizing basic project description when you need to give deadlines on more concept, and do you have any ideas on how to organize it.
I'm thinking of going to my boss and suggesting, instead of always pushing a estimated deadline to our clients which expect us to hit that, we should write up a detailed document that is more step-by-step (more like what to do) on how to develop the application they want, it may take a lot more time, but least if the project is moved to someone else it is laid out for them, and when I usually get back to it 4 months later, I don't have to refresh up again, I can just follow the steps I wrote.
What do you guys think? Ideas? Or better ways to handle this?
If you switch your development to using an iterative methodology (Agile, XP, Scrum, etc), then the customer will see results much earlier than any deadline you feel you have to promise - usually every 1 or 2 weeks.
The moment they see what you've developed, I can pretty much guarantee that they'll make changes to their initial requirements as they now have a visual representation of the product and it may not be quite what they were thinking of. Some of their changes might be quite radical, so best to get the feedback as early as possible.
In all the projects where i've insisted we do this, the customer was delighted - they saw the results early, could influence the project outcome, and we hit their end deadline. Unexpectedly, a whole load of features got left behind and - guess what - the customer did not mind at all as they got the top features they wanted and put the project/product straight into production as they'd had lots of time to refine it to suit their business, so they were already familiar with it.
It takes a lot of effort to get management, sales, creative, etc, to all buy-in to an iterative style, so you may need to implement a hybrid solution int he mean time, but in my experience, it is well worth it.
If a complete shift to iterative is not possible, split your project into tangible milestones and deliver on those milestones. As others have said, inflate your estimates. My previous manager doubled my estimates and the sales team doubled his too.
Inflate your project deadlines. It's something that most programmers should do (and I quote the VP of Freeverse, the company that I work at):
It is a well-known fact among people
who work in the software industry that
the last 5% of development always takes the longest.
If possible try to divide the higher level tasks as much as possible so that you can get a better approximation of how many man hours that sub-task would take.
Also, adding hidden buffers to your task execution helps in covering some of the unseen contingencies.
cheers
If you mock up (balsamiq or whatever) with your customer, you will get more details. Armed with those details and some experience, your estimates will be more accurate. And then double it and add 4 (hours,days,weeks,months)
First, unless you systematically under-estimate, your boss should not get upset. It's his job to answer to the client, and he should know that by definition, an estimate is NOT the future. Statistically, sometimes you should deliver earlier, sometimes later.
Personally, I think that the frame of "how long will it take" is not exactly the right discussion to have. Software development is a risky business, and change/surprises happen all the time. One approach which helps is to focus less on the "right" number, and more on the volatility. Look at the project, and consider the places where you are pretty clear on how long it will take (you have done it before and understand it well), and look at the places where you have uncertainty (unclear requirements, new technology), and for these, think about how bad it could go, and why. That will help you get not one number, but rather boundaries: what you think is reasonable, a worst-case scenario, maybe a best case scenario (which the client should never see :) ) - and convey that information to your boss, so that he can manage accordingly.
Additionally, this will allow you to identify the danger points of the project, and you can then prototype accordingly - look into the uncertainty points as early as possible, so that you can tighten up the timeline fast, and have early warnings for your boss and the client.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 3 years ago.
Improve this question
I would like to set up a ROWE for my dev team: Result Only Work Environment.
Basically, people work how they want, when they want, as long as the work gets done.
This environment has been a huge success for Best Buy: increasing productivity and reducing turnover.
Does anyone have any advice for making this work for a dev team?
Edit:
More details: I will be leading a team of 3 other fairly experienced developers. I plan on standardizing the basic processes, such as version control, bug tracking, code review, planning, testing, etc. "How they want to work" more refers to how they manage their time: i.e. scheduling meetings, pair programming.
If you have other departments in your org., consider managing their expectations as well. It will be difficult to convince them that their project is going to take longer (throw in all the technical jargon you can think of) than you thought when they notice your team is never around (in their eyes).
You'll still have to have realistic expectations in your planning. Are you really allowing for flex time when they have 10 hrs of work to do that is due in 10 hours? How are you going to handle trouble-shooting issues that get escalated to the dev team?
One developer could be consistently better than the rest/take less time, but the team may feel this person has a lighter workload. Get ready to crush some egos.
I guess pair-programming is out?
The answer to this question is going to vary depending on the size and culture of the organization. Some would also argue that the process can matter, and you don't want your people taking any approach to achieve a result at the expense of something which they do not feel as as important.
Can you provide more info on the size of the organization and what working there is like today?
Make sure you hire the right people, you might find they work more than they WANT to admit X-).
Programming is more than a job, its a passion, and if you find the right person to fit your environment, performance measures go out the door, as the do it for the love of it.
WHEN they want will be easiear than HOW they want. I wouldn't give that much freedom to devs. IMHO, this would lead to a total mess of code.
There's very few very good developers out there today and those that are good enough should be made development leads and make the global decisions. Others should just follow the instructions or all hell can break loose.
You need to define what the results they're meant to achieve are clearly and completely unambiguously so they understand what they can control (essentially how they work, the order they develop things in and so on) and what they can't (usually what they're expected to deliver - both in terms of actual product and supporting materials such as progress reports - and when it's all meant to be delivered). You also need to let them know what resources they have - can they order high spec machines or order new software for instance or is that all decided?
I'd also ensure that one of their early deliverables was a schedule of completed milestones against which you could measure progress and agree with them what happens if they start missing milestones.
But I am slightly dubious about the idea that you're going to define version control, bug tracking and so on. Surely these are things you should let them decide? After all they're part of the process. Personally I'd state that they must have version control, centralised defect logging and so on but the mechanisms, tools and processes should be up to them.
It feels a little like you say you want to create a results only work environment but you don't quite trust them. If you're saying what you're going to do is create a ROWE then you need to make sure it's just that otherwise you're really only doing half the process and those situations rarely deliver the benefits people are hoping for.
After all, either you trust them or you don't but if you can't trust them to work out how to do version control which is frankly second nature to developers, you probably shouldn't be trusting them with the schedule which is normally a far less straightforward matter.
Results oriented means that you must trust your developers to make the best decisions. Some people love this freedom. They cheer when they have the freedom to use a wrench as a hammer if it meant quicker results, rather than switching tools just to nail a picture on the wall.
But sometimes it could be damaging. Processes are designed for maximum productivity, efficiency, and effectiveness, with all kinds of safety measures. With the wrong subversion tool, a developer could easily slip and delete all history of all work done by the team, thus eliminating the magical "undo" feature.
In another case, most fresh grads (that I know) don't have the knowledge or capacity to make decisions on their own. They may not produce as fast as they would be able to with someone barking orders at him/her. One of the most distinguishable characteristics of a fresh grad is when he is stumped or doesn't know what's going on, he doesn't ask for help.
Your developers must have the right set of mind in order to achieve goals. Freedom is good, but monitor and make sure it's the correct way to go.
Closed. This question is off-topic. It is not currently accepting answers.
Want to improve this question? Update the question so it's on-topic for Stack Overflow.
Closed 11 years ago.
Improve this question
Being relatively new to the software industry I have come across a question of deadline enforcement:
Back in the idyllic age of academia, the deadline was the end of the semester and the penalty was a well defined 'F' (or local equivalent). Out here in the real world we need to make code our current and future peers can work with, I face the situation where deadline comes, deadline goes, and the project is still not finished.
Now what? On one extreme we could fire everyone involved, on the other we could richly reward everyone involved.
What actions have you seen applied as 'penalty' for missed deadline, and which of these eventually resulted in more-good-code?
What project-management responses caused the project to fail outright,
What responses restored working order and resulted in code that could be maintained afterward?
What responses resulted in more-bad-code?
Deadlines are part of a fundamentally wrong idea about how to do software development. People new to, or outside of, the software development industry do not understand this:
Software is done when it is done, no sooner and no later.
If a developer has a task and a week to do it, and it looks like it will take more than a week, nothing can be done to change that. No matter how much harder the developer works, no matter how many people are added to the task, it will still take as long as it takes (in fact adding people usually makes it take longer).
Instead, read up on the agile development process. Software should be developed iteratively, and each iteration should be based on the results of the previous iteration, not on external requirements imposed.
Edit based on the extensive comments below:
I would never argue that developers cannot be held to some kind of delivery expectation. My point is in response to the specific hypothesis which the asker posed - that the nature of software development in business is somehow analogous to schoolwork, or any other kind of work for that matter. I contend that it absolutely is not. "Deadline" implies much more than a simple delivery date. It is a fixed point by which a fixed amount of work must be completed. Software simply does not work that way. I wrote a few more paragraphs explaining why, but honestly if you don't already believe that, nothing I say is going to convince you.
If you are working on a software project and it is clear you will not be able to reach your deadline, what can you do to rectify that? The answer is well-known by now: practically nothing. You can't add more people. You can't "work faster". It's just not going to get done on time. You tell the stakeholders, everyone adjusts, and keep working (or not). What, then, did the original date mean?
Anyone who claims software development is analogous to bridge-building or homework or that impending deadlines can still be met if the developers would just get their shit together and work their asses off, are deeply confused about their own profession.
Your first reaction should not be what to do in response to the missed deadline, but to analyse why you missed the deadline. The response to missing the deadline would then follow naturally from that as a consequence of the reason.
For instance, if everyone involved didn't do their job, fire them.
But if they did their job, and more, then why was it still missed? Too much other activities done by the same people? Too big a scope for the deadline (ie. unrealistic deadline). Or ... etc.
The top reason for missing a deadline in my experience is that people aren't allowed to work 100% on the project at hand, and thus any estimates you might have, although accurate on their own, aren't really useful at all. That, plus unrealistic estimates and deadlines.
Developers should never be penalized for Management's mistakes.
It's like a parent punishing a child because the parent had a bad day.
Reasoning:
Deadlines are a fact of life. People want to know how long something will take. The best we can do is estimate/guess. It is the role of management to try to figure this magical, never correct guess. When they create a deadline, they need to use the right tools (experience, ASKING FOR HELP FROM DEVELOPERS, lawyers, hr, etc)
However....
The penalty for missing a deadline should not fall back on the workers. It is the management's fault for missing deadlines. They should have said no, should have scaled back the project or should have motivated the workers better.
In a construction crew, if you piss of the workers, you start a fight. In my company, if we miss deadlines, the management gets in trouble. Not the workers. It's the manager's job to control the project and what is done. The workers are only doing what they can. The manager's are in charge of assigning roles and tasks.
I'm not saying the quality of workers isn't a factor, but the management should KNOW that! It doesn't take a genius to know that a project isn't well thought through or nicely controlled. Ask anybody if their manager has any idea what's going on and you'll find the problem.
We stopped missing as many deadlines when the managers realized it was their fault for setting/agreeing to the deadlines.
</rant>
Re: The questions:
1.What actions have you seen applied as 'penalty' for missed deadline, and which of these actually made things 'better'?
Manager has less responsibility. This person does not get promoted or publicly thanked. Most likely this person will be moved to a "less-critical' project.
2.What project-management responses caused the project to fail outright, and what responses restored working order and resulted in code that could be maintained afterward?
feature creep: manager keeps adding more stuff in the list. <- fight this off with a List of tasks ordered by priority. When you add things to the list, compare their priority with the things around it. Make new things harder to be set as "top priority."
too many bugs in the code: Manager need to require tests (atleast critical) and automation. Builds need to be standard and automatic. Real users need to see the code before it is "finished."
un-readable code: Institute peer code reviews. If someone has dirty code, ask someone to "help" them with a project.
If you have the salesman problem, where the salesman promises features that doesn't exist/work: Management needs to step in and explain the problem to that salesman. Also, not giving that salesman public affirmation for a job well done sometimes helps this.
Rather than a penalty, how about realistic estimates and rewarding on-time releases?
Inspired by the comments to my response
Maybe the question should be "How do I make realistic estimates?" For me, I use FogBugz estimation history and completion date plots. These give me data points of how long I estimated a task to take and how long it actually took. This has helped guide me to give realistic release dates in the long-run (it didn't happen overnight). I find estimating timelines to be an interative process: I
design
estimate
develop
find an shortfall in the design & iterate.
Death. Clean and simple.
Depends on whether developers set deadlines on each modification request, or whether these are set for them by management.
In the latter case, unless all your developers are sitting and playing Halo 3 all day, a missed deadline is often an indication of a mistake on the side of management or the team leads. So firing everyone wouldn't solve the problem. It might make sense to introduce better indicators into your software process so you could see that the deadline would be missed long before it happens.
If your developers do give time estimates, then I would be very careful about rewarding and penalizing developers for meeting deadlines or missing them. The result of doing this could be that they would adjust their "fudge factor" in time estimation. They would give themselves too much extra time (to reap the rewards), which messes things up if they are good at estimation. Your goal should be to get them to give good and reliable estimates, not to change the way they work to meet these estimates.
It depends on if the deadline was possible in the first place, maybe it was a fault with the planning and estimation of how long it would have taken. Make sure you know why the deadline was missed before deciding punishment
Oh, man...
First of all, there are external deadlines and internal deadlines, and they should be different.
What happens with an internal deadline is the frequency of activity increases as the deadline approaches, reaches a peak at the deadline, and then falls off as the deadline recedes. So plan the external deadline to follow the internal deadline by a couple weeks at least.
Then, make sure the deadlines are realistic. Partly you do that by involving the developers in setting them, and in deciding what will be accomplished.
Finally, I've mostly been a developer, but once when I took a stab at management, I would never want to take the latest-and-greatest version into a conference or presentation. I would want to take a version that was at least a few weeks old and that I knew where the problems were and that I could be sure would not contain unpleasant surprises.
In his wonderful book about project management - "Deadline" - Tom DeMarco tells us a story, about project manager from a western-world is managing a project in some fictional post-communist eastern European wild country (wild is a really good term, because the citizens are a bit.. uncivilized).
One day PM discovers, that something went wrong, some part of his project dramatically missed the unrealistic schedule. Previous PM established penalty for missing deadline simply by hanging responsible person on a butcher’s hook, but as schedules were unrealistic, one man already missed deadline.
So the story tells us about a day, when western-style PM is presented with a responsible person, and he should send him to be hanged on butcher’s hook. PM, as most people do, is terrified of vision of sentencing someone to cruel death simply because some was never able to finish his project in time. And – by all means – hanging this poor man does not advance the project. Since this is a fiction novel about project management, and not about tortures, our hero cancels the penalty.
But there is some big issue behind this story about hanging someone: if you set a deadline, and establish some kind of penalty for missing this deadline, the day will come, you will probably have to actually punish someone. And will you do it? No matter what the punishment will be: hanging, bonus loss, firing, breaking the deal or some fee – you may have to punish someone. Will this penalty do some good to your project? You have to answer it by yourself.
So: do not establish a penalty for missing the deadline, you will not want to execute…
As others have mentioned, before talking about penalties, start with "how do we determine whether these deadlines are realistic"?
Or as my boss once said, "We'll be happy to work a plan when you give us a plan that works".
I still think that should be on a t-shirt.
Once you've reached the point at which people have blown the deadline, you have to ask yourself (A) what the natural consequences of that are and (B) how you can best complete the task and maintain some kind of movement towards the business objectives (even if you're not running a business).
Explicitly penalizing people for blowing the deadline is unlikely to help unless they believe that they've earned it. This will not happen if the deadline was unrealistic, if there were elements of the team that were the primary points of failure, if there were serious problems with requirements, or if the majority of the team involved believes that the above factors are true.
In one case I was on a team that blew a deadline on a small deliverable by over three months - and the original deliverable due date was three months from start! We misunderstood the requirements, didn't sufficiently talk to the customer, and underestimated the time involved. Management was not at all interested in assigning blame. This was partially because it would have been counterproductive to finishing the deliverable, partially because none of us were "problem employees", and partially because management knew that we were all highly-motivated to fix the problem and satisfy the customer. So we got it done, the customer was as happy as could be expected, and we moved on with our lives, with some valuable lessons on how to avoid the situation in the future.
So far in my career I haven't seen any real penalties for missing a deadline (and I've missed plenty). I imagine it's different for companies building software or games to be sold in stores where the company has made promises to the public.
But in the custom software development realm, it's so hard to accurately estimate how long a project is going to take. And often times this fact is reluctantly accepted by companies everywhere.
No penalty. "Deadlines" and estimating have been and continue to be one of the hardest and most challenging parts of software development.
It is ridiculous to impose penalties on developers for this issue.
While I have never seen any disciplinary action or firings I have seen lots of "mandatory" overtime and peer pressure to work longer hours.
I almost got fired as a manager for telling the team that reported to me NOT to come in on weekends and work late. I know those things are detrimental to the project and to morale.
Generally the "punishment" is in the form of making people feel guilty or anxious, but I am sure there are places that do more "official" things.
The world is full of idiots. Management is no exception.
I think the question it self demonstrates a misunderstanding of the role of management and project management.
There is, unfortunately, a common perception in the minds of many with the word Manager in their title that management means putting the heal to/kicking the butts of lazy workers. It fits with those that believe in Parkinson's Law as well.
It's not. It's about making it possible for works to do their jobs - be it being the communication channel between them and some other part of the organisation, getting them resources, or running interference (moving the furniture out of the way).
To wit, the PM should already know the project/task is going to miss it's deadline. They should be asking questions, and know what's going on. They have the power to either cut tasks or increase/rebalance the resources to get the job done (or say to the sponsor, if you don't give the resources, it ain't getting done on time). And as such, the penalty goes to the PM, whether it is nothing, tongue lashing, demotion, or termination.
Sometimes the delay is unavoidable. This is why we build in contingency time. Sometimes, it's a known risk; and so long as you have a backup plan - you are OK.
As for the responses, you have four parameters: Scope, Time, Money, and Quality
Scope - you can cut to make the deadline.
Time - is fixed. You might be able to get your staff pull a week or two at 60hrs, but your productivity will begin to suffer after that. And it also costs more money if you are paying them fairly.
Money - You can buy pieces from someone else to speed up the process. You could even hire more people, if the work is disjointed enough that you don't have to have a lot of communication with the existing staff - see Brook's Law
Quality - Idealistic fools claim you can never skimp on quality. But you can. You don't have add bugs (one form of anti-quality); but you can put less quality in. Do you code your function so it can handle unlimited length strings, or is 100 characters good enough for this version? Do you make it easy for the next upgrade to bolt on a new module, or do you weld it shut and worry about adding a plug-in module when you do the next version.
Not doing these things aggressively enough (when required) will surely lead you to a failure.
It's certainly not a cut-and-dry answer. Here are some things which I weigh and things I do/encourage in order to make sure things get done on time.
1.) Set priorities properly. Projects will always have various degrees of completion. It's not a binary "done"/"not done" switch. If the highest priority things are done first, it's easier to swallow. Ideally, you should quickly get to the point where it works, but it doesn't do everything we need it to do and it doesn't look pretty. Once there, it can be released if it absolutely needs to.
2.) I've found that the best way to handle it is to make the releases as small as possible. This makes the estimates more accurate. If your boss or "the market" dictates that your estimate is unacceptable, consider assigning more developers to this task if possible. Sometimes a task can't really be divided up easily, or there's only one person familiar with the code. If it's not a high priority just tell the powers that be that it's going to take longer. Setting reasonable goals and managing expectations is key.
3.) As for motivation, rewards, and punishment... there are many doctors who have written entire books on these subjects. In my experience, giving programmers something which is challenging and letting them have some freedom to do it their way is a good start. Listening is something managers need to do well in order to succeed. If the developer is seasoned, you should be able to just explain the problem and let the developer come up with the solution. If their solution isn't as good as what you had in mind, you can suggest it and go from there. Just dictating how to do something, even for new programmers, is seldom effective. Making the developers think about things will help them be able to solve problems on their own. This is related to delegating, as that only works if the developers can do the work on their own.
4.) Reduce turnover by paying people well if they're doing well. It usually costs much more to find good people. It takes time to get familiar with a large code base and the hiring process can also help avoid spending time on people who can't cut the mustard.
5.) Ask (don't demand) if a developer can stay late/work weekends. Only do this when it's something very critical (for example a security flaw which gives user access to data they ought not be able to access; a new law/regulation passes which you must comply; etc.). If they say no, don't hold it against them. It's likely not their fault that things didn't get done; and even if it is, it's reasonable that they made plans for time when they aren't expected to be at work. If they are willing to come in, make sure they know your sincere appreciation. Compensate them well for helping out when they aren't obligated to, buying lunch doesn't cost much and it's a very nice gesture. Don't make a habit of expecting people to work late/weekends unless it's part of their contact/agreement (or if they like doing so).
6.) Understand why things are running behind schedule. Did you promise something which wasn't possible (given the people available, quality expected and time allotted)? Did some other project come up and take up resources and the deadline wasn't adjusted? Was the code just harder to do than expected? Giving time estimates is difficult. You need to plan everything out, have experience and know how long each developer will take for the task. Compensate for unexpected problems which will likely arise and give the programmer a sooner deadline than your boss or the client. It's always OK to be done early. And if you're almost always done early or on time, that one time that you missed your deadline will be more understandable if you have an explanation of some sort.
7.) Remember, it usually boils down to time, quality and money. You can generally pick any two, but the third one will need to balance the equation. So if it needs to be done quickly and on a shoestring budget, you can expect the quality to suffer. If you need it done quickly and of high quality, expect to pay a lot of money, and so on.
8.) I'd say the #1 thing which works for me is listening. If your too busy barking orders then you might not even know about problems with the company. Now just because a developer says "the code sucks, the design is terrible and we need to re-write everything if we want to get anything done in a timely manner" doesn't mean that it'll happen. But if you hear comments like that and explain that we can't afford to do this or we'll get killed in the marketplace, it'd be way too expensive. And ask what can be done to make sure things don't get much/any worse. Ask if there's a way we can clean it up over time. Can we just (re-)write one class and build new stuff based on that? Can we slowly migrate to a new design one feature/segment/module at a time? You understand where they are coming from and vice versa, you can probably solve at least some of the issues. Just remember that compromising works both ways.
9.) Negative re-enforcement seems to result in higher turnover, which is costly. Having a bunch of people who aren't familiar with your code doesn't help deadlines either. Money is one motivator, but I've quit a higher paying job to go to one where I'm happier before, and I know I'm not alone there. Free food when the team does a good job isn't really that expensive. I'm not too keen on group activities since they're either cutting into an employees time, or taking away from work time. It works sometimes, but cutting into an employees personal time so they can hang out with co-workers instead of being with their friends isn't that great of a reward. Having everyone stop working is also expensive... so it just depends on the company size, culture, etc.
Hopefully that helps answer your question. The other answers in this thread are also good suggestions... design plays a big part in how quickly code will be written.
Once a project is late, there is not much 'management' (good, bad, well meaning or malicious) can do, that will not result in the project being even later
... the only exception possibly being the removal/avoidance of exterior distractions.
If you're missing your deadlines, fix your estimates.
Taken from a corporate development standpoint...
If the deadline came from someone other than the person performing the work, review the situation to determine the cause of the overrun. In these cases, it is often related to incomplete requirements, scope creep, poor management, etc. No punishment should be given for missing a deadline that the person never provided in the first place.
If the deadline was provided or agreed upon by the individual performing the work, then that person needs to explain the factors that led to the delay. In addition, this person should be reminded to notify their supervisor, project manager, or other responsible party as soon as they are aware that a deadline may be missed. This information should not come to light after the deadline has passed. If this occurs repeatedly, your company's disciplinary process should be followed. This may involve write-ups, suspensions, or termination.
People tend to take real ownership of deadlines when they are the ones setting them. When deadlines are placed on them without their input, deadlines tend to become meaningless to the person performing the work.
Your question is inherently flawed: it assumes that punishment is the best way to manage people. In general, that people don't respond well to punishment or threats of punishment; it brings out the worst behaviors, make the motivation external, and distracts from internal motivation. Rewards and bribes (threats of reward) are the other side of the same coin, and do no better.
These forces are built in to work for hire, however, so you'll never get the best creative work out of your programmers, but you don't have to make it worse by punishing them when they miss a deadline.
Instead, meditate on the creative process, the chaos of multiple people doing creative work, and what tools are effective in managing chaos.
To manage any chaotic system, do lots of measurement and be ready to change course quickly. In the case of programming:
Take the smallest steps possible. Don't "break the task in to small steps", as you'll waste a lot time planning steps that won't work out like you planned. Chaos, remember?
Pick the smallest steps that deliver the most value.
after a short period, reevaluate your plan based on what you've learned
deliver working software to actual, real customers as soon as possible, so they can tell you what you should really be doing.
You may recognize this as the thinking behind SCRUM.
Flogging
There are two possibilities:
The deadline was missed because someone didn't do their job.
The deadline was unrealistic.
Rather than thinking in terms of penalties, I would suggest doing a post-mortem to determine what went wrong and finding ways to improve the next deadline estimate.
You ask "what should the penalty be...". It would appear you are asking from the perspective of "inside the company".
In real life, the penalties are often swift and severe - loss of business, lawsuits, bad reputation in the industry. These are the REAL penalties imposed by clients who were promised something by a certain date that was not fulfilled.
Internally, you can often do whatever you like. But once you start involving paying clients, then managing those clients becomes a critical part of the overall job.
Penalties such as I described can often be avoided (or lessened) by "on top" communication with the client. If the client wants something added (so-called feature creep), then this should immediately be answered with the impact these changes will have on the project (costs more, delivered later, whatever). The client should be encouraged to triage all such requests against their deadlines and projected costs (i.e. let the client manage feature creep, not you).
If other things change the delivery time, then as soon as you know there will be slippage, you must inform the client. If done early, clients are remarkably willing to work with you. But if you don't say anything until it's too late, they are less likely to forgive... especially should they discover you knew a significant time earlier and didn't tell them.
Cheers,
-Richard
I've seen executives leave a company shortly after some deadlines were missed. This changed everything but didn't necessarily make things better or worse. I've seen some contractual obligations like clawbacks as a way to penalize someone for missing a deadline that I'm not sure how well they work.
When one completely changes what a project is supposed to do midway through the alloted time for the project that tends to cause the initial trajectory to no longer be valid and thus the project will fail because it likely will not meet the initial deadlines within budgets. Replanning the project into short increments of at most a few months is a response that I believe is a logical direction to take a project to get good results as a lot of project may have to accomodate changing requirements which can easily change deadlines, head count or time worked.
What should the penalty be for setting an unrealistically short development timeframe against all of the advice of the developers and their leads?
Coincidentally, this seems to happen almost as often as development teams missing ship dates.
This is not really a programming question, but more of the management question.
Missed deadlines are rarely developer's fault. As a developer you should try your best to do as good work as you can, but in the end everyone is capable of only so much. If developers put in honest effort and despite this the deadline was missed, it means that the deadline was unrealistic to begin with.
Dealing with deadlines is responsibility of managers. There are different approaches but none of them include "penalizing" developers for doing their job. An important thing to understand here is the so-called project management triangle. What it means is that software project can be good (i.e. meeting requirements, good quality), fast (meeting deadlines) and cheap (headcounts, tools). The trouble is that only 2 out of these 3 properties can be chosen.
So if management want something good and fast - it is not going to be cheap.
If management want something good and cheap - it won't be fast.
And finally if management want cheap and fast - guess what, it won't be any good.
So the correct response to missed deadline depends on the chosen scenario. Good and fast requires adding some extra help, better tools, investment in above-average developers and more.
Good and cheap by definition assumes that deadlines are going to be missed (Blizzard, makers of World Of Warcraft are good example of this approach)
And finally cheap and fast usually means cutting features and releasing with bugs.
The main goal of project management is to plan how an application is going to be built, in time. You should not start your project development if you don't have a schedule showing what you're going to be doing every single day the project will last.
This way, you can detect that you're going to be late, as long as you follow the project's evolution on a regular (weekly if not daily) basis. And the earlier you know it, the sooner you can act accordingly.
You usually have two options :
Catch up (by hiring additionnal workers, working more, or removing features).
Tell your customer that something went wrong (even better : what went wrong) and you're gonna need more time.
For the second option, I'm not meaning there won't ever be penalties. But from my personal experience, as long as the customer is informed in advance and offered solutions (preferably three : give more money for additional workers/remove features to save some time/accept the project being late), they'll be open to negociation. Which is always better than conflicts :)
Perhaps the better question is if deadlines are meaningful in the face of inaccurate estimates? Businesses do a lousy job of estimating software--that is a fact. Both management and developers play a part in this and neither one seems willing to own-up to their responsibility in this problem.
But to answer your specific questions:
1.What actions have you seen applied as 'penalty' for missed deadline, and
which of these eventually resulted in
more-good-code?
The 'penalty' I've seen for missed deadlines for managers and developers range from nothing, to promotion, to simple transfer. The most severe penalties I've personally witnessed was a manager "transferred" to a less important project and for the business-unit to lose a financial bonus.
The only time I have ever seen someone fired over a missed deadline was when the employee was already going to be fired--the deadline gave the business a legal reason to fire the employee.
2.What project-management responses caused the project to fail outright?
This is a whole separate discussion on its own... but there is some inherent bias in this question--project management is at fault.
The three top things I have personally seen PM's do that sabotage a project are (in order of severity):
Ignore data/recommendations/warnings from their technical staff.
Ask for estimates early in the development process. This results in estimates with an error-bar of 10x (it'll take one month, give or take ten months).
Reject/modify/demand software estimates so that they fit an arbitrary budget and schedule. This is not to say Developers should ignore business demands--but rather the business demands need to be set equally by Developers and non-Developers.
3.What responses restored working order and resulted in code that could
be maintained afterward?
I have yet to see a functional software development organization. So the fix is usually a lot of blood, sweat, and tears from a couple of heroic developers working with a highly-capable PM who knows how to defend against politics within the company (i.e. deflect BS from their staff).
4.What responses resulted in more-bad-code?
Yelling. Cursing. Insults. (Sadly, this still happens in some workplaces)
More "project management"--either by way of people, meetings, status reports.
Getting software estimates earlier in the process so "we can plan better." Estimates need to come later when your staff has more data and a better understanding of the problem.
Coddling the developers (it's not your fault, the manager screwed up).
Coddling the project managers (it's not your fault, the developers screwed up).
Adding additional, unqualified staff to the project.
I got fired for missing a deadline, I was 98% finished with the product, external forces and deadlines that are that firm don't allow software to be developed properly. Even I can admit I wrote some poor code under the circumstances, but I also wrote some good maintainable code as well. No consideration was given for feature creep, infact no technical specifications were detailed upfront and adaptation of functionality was required as limited and buggy versions of the software became available for managements review. I could have communicated better, but when I did communicate it was emphasized that deadlines are non-negotiable.
Two obvious questions come to mind when a deadline was missed:
Was the deadline feasible?
Did external factors impact performance?
Obviously, if someone presents you with a deadline that doesn't make sense then there shouldn't be any penalty for missing the deadline. Also, if someone misses a deadline because they were called up for jury duty that also shouldn't be held against them as well.
In the event those questions don't apply then the next thing to do is to figure out what went wrong. If you based your estimate for how long something would take, and thus the deadline, on the developers estimation of how long it would take them to write the code then perhaps they were too optimistic in their responses.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 9 years ago.
Improve this question
What do you do when you get assigned a project that is just way too hard to do:
Say it's a mammoth project and your boss thinks you alone can handle it
You have knowledge to do somethings, but some other things are a little beyond your expertise at this point in time
Your boss probably thinks it's something that can be done by one person in probably one month
SO users, I would love realistic answers here. This is a real world situation and I am trying to figure out my response to my boss tomorrow on how to approach him delicately.
I just wanted to add an update to my note here. The app in question that my boss is targeting is a "NING like" web app. My hesitation is mostly being the only person being assigned to it for such a complicated app in such a short time period.
This is a situation that everyone has to deal with on a regular basis simply due to the nature of work. (Typically, if you know everything you need to know to complete a job, you've already completed the job and don't need to do it again. :) )
Be honest with your boss about your anxiety. Your manager needs to understand your assessment of the project's risk profile. Odds are good that you'll be doing it anyway. That's OK! This is your chance to shine! :)
Break the problem down into tasks you understand and tasks you don't understand, then start tackling issues one at a time. I, personally, like to alternate between easy tasks and hard tasks. Completing easy tasks helps me feel like I'm making real progress on a gut level, which is important for my personal motivation. Completing hard tasks addresses potential problem areas earlier in the schedule. This mitigates the tail-end risk of the project by evaluating unknowns earlier, rather than letting them fester and explode when you've got 2 days left and no more planning/wiggle room. It also helps your stress level because you know you've gotten the ball rolling on the project's scary bits. Remember-- your unknown areas are where you don't understand the problem domain, so that's where the real risk of schedule/budget slips lie. You need to mitigate those risks early and often. Get the ball rolling with colleagues that you can consult to learn how to do these things.
The one month goal is probably a target. I don't believe it's reasonable to expect person A to realistically estimate person B's scheduled completion of a task in the general case. To track your progress against the target, set up milestones, none longer than 16 hours/2 days, and track your completion rate against them. This goes hand-in-hand with your list of easy/hard tasks.
The simple fact is that, sometimes, you'll just get dumped in over your head. In that case, you may have to make the best of an overwhelming situation. My very first task at my first job out of college was to design a reliable, transaction-oriented, peer-to-peer n-way server synchronization system for high-volume, high-rate data. I told my boss up front that I did not have the expertise for this, and at the time I didn't have enough experience to understand that I needed to push back on the requirements. (In retrospect, given the political environment, I don't know if pushing back on the requirements would really have helped anyway). That was simply a case of a poorly managed project that took about 18 months to ultimately collapse under its own weight. I still leveraged the opportunity to learn a lot and take some knowledge about the way my particular organization worked, though, and that can be very valuable no matter what. :)
Good luck! :)
Edit after question update
Ok, if I understand your update correctly, we're definitely in #4 territory here. There's nothing realistic about creating a competitor for Ning in one man-month. I assumed in my prior answer that you were dealing with someone who had a base understanding of software development. Based on that:
Ask your boss to clarify the requirements more. Perhaps (cross your fingers!) you simply misunderstood what you were being asked to do, or the scope of the project. Always assume competence until absolutely proven otherwise for social reasons. Maybe you were only being asked to come up with an overall design and some very simple proof of concept?
If your boss is truly this out of touch with reality, put together a sensible, 15-minute back-of-the-envelope estimate with him/her on a whiteboard or a shared piece of paper. It shouldn't be hard at all to blow all kinds of holes in this one month to completion. Perhaps your boss thinks you'll be able to reuse some internal code that you're not aware of? This will bring any faulty assumptions your manager is making re: project scope to light.
If your boss is absolutely unreasonable (this doesn't happen often, but it occasionally does-- perhaps the company needs a killer app by the end of the month to sell to avoid going under), prep your resume for an intra- or extra-organizational move (depending on how big the place you work is). Unrealistic expectations on that order can be a sign of organizational desperation or malfunction, and your position may simply not exist 3 months from now.
Don't panic. You may have misinterpreted the goal your boss has. It sounds like he was not very clear if he said only "Ning-like."
Research Ning. What are all the things Ning can do? On Ning's Resources link, they list at least 21 major social network features.
Write up a high-level statement of the goal for this project. Include all the features Ning lists. Also include an objective for how many users this app should serve. Don't try to think about how to solve these goals objectives, or how many programmers it'll take or how long it'll take. Just list them. Keep this write-up to one or two pages.
Present the list to your boss. Ask him, "does this sound like what you had in mind?" Ask a few direct questions to ensure he has looked at your write-up:
"Who are the target users for this application?"
"How many new users per month do you expect to sign up?"
"What level of uptime do we need to support?"
"What's our budget for hosting this service?"
"Do you need this application to support international users?"
"What is the end-user license agreement (EULA) for this application?"
It may become clear at this point that your boss has more modest goals than you assumed. Perhaps he does not intend to duplicate all the capabilities and scale of Ning. So then it becomes a task of getting your boss to articulate more clearly what subset of Ning features or capacity he needs.
Install Drupal, Joomla, or Wordpress, download some plugins, and design a custom site for your boss. That'll probably give him 99% of what he wants, and it's the only way you'll be able to do it in one month.
Don't start by saying "No" or "It can't be done" or "Its too hard" or any of the other things you said in your post. Most managers in a company do not even begin to understand the effort level involved in a programming project and need a little education with their software planning estimates.
I would suggest a conversation which includes the following steps.
Estimates: review the effort level you believe is required for this project to be a success. Make sure that you have thought out tasks in enough detail so that you can answer questions.
Education: if your boss doesn't understand why something will take a certain amount of time, explain as clearly as you can (good analogies tend to help, bad ones can be devastating).
Alternatives: if you believe there is some middle ground or some set of sub features which will fulfill the project needs discuss these alternatives. Managers hate when an employee says something is hard or difficult, they want workable options.
Alignment: are you sure that you and your boss are on the same page about this project? Perhaps you see it as a piece of mission critical software and your boss sees it as a minor enhancement to your existing tools. Be sure that you both have the same expectations; otherwise, you may be planning more complex software than what is being requested.
The most important thing I ever learned in software was how to "push back."
It doesn't always mean saying no. What it means is providing your best estimate of what the impact of new work is. Whether you're saying "yes" or "no", you say, "we can do that, but it will require (x, y and z resource). I think it will take (n days for me, n*a for person b) to understand problem b), but I know how to handle (c, d and e). I've never had to solve problem b before, so I don't know if my estimate for that is realistic."
The difference between "yes" and "no" is whether the cost equation is acceptable.
Any good manager will respect your analysis, question some of your assumptions, expect a round of rethinking, and then, either accept the risks, find additional resources, or abandon the project.
If they say "I see what you're saying, but you're going to have to accomplish the impossible anyway," start looking for another job.
Would your boss not understand the truth? Just talk to him about the requirements of the project, and mention what can and can't be done.
Here's how I would plan it out:
Don't panic and to react - tell your boss that you would like to review the request and will get back to him shortly with questions and concerns
Go through the spec (or if there is no spec, the email or write down the request somewhere) and create a work breakdown structure for each delivery. This should be done to a level where each item is understandable (User Login, Message Entry, etc.)
For each item, est. the amount of work and +/- % amt. based on your knowledge, questions, risks, etc.
Create a list as you're going through the spec of any major/important questions (how many people is this targeted for? does this include the ability for users to IM, etc.)
You now have a rough timeline, risk assessment and list of questions to review with your boss. He'll see that you put some effort into it, may open his eyes to the complexity and provide him with confidence that you are not knee-jerking reacting. He might demand you do it in the timeframe he provided anyway....look for another job, you have at least a month.
What you say is that your perception of the task scope and complexity differs greatly from the perception your boss has. Great.
Most likely you're both wrong: you have misunderstood the requirements and the boss underestimated the task or fell into the trap of wishful thinking.
It's best to go through the requirements with your boss once again, work out together that deliverables are required, try to guestimate amount of time and resource needed to deliver these. If there are blind spots in implementation that you feel you lack skills or expirience for, make this clear and work on the assumption that you'll have spend cash to source these externally (that will at least give you an idea of a market price).
I am sure, the longer you and your boss spend discussing and researching the project, the more detailed the dissussions will become and the better idea of what is feasible will emerge.
The worst thing you can do is to keep quiet. Any good boss relies on developers to give some assessment of a project: either affirmative or hear more questions.
You don't have to say "no", that's not your job to decide whether to go ahead, but you have to be asking good questions.
It really depends on the relationship you have with your boss. If you can, I would just be open and honest with them. Tell them a few things are beyond your level of expertise and you would have to do some research, lengthening the project time. And stress the point that you don't believe you can get it done in a month and you're requesting a team to help.
It's possible your boss doesn't really understand the full scope of the project. If you can break it down into a list of tasks or sections to show how much work really has to go into it, they might see where you're coming from.
In the end, if your boss still wants you to go through with it, just keep stressing that you will do your best but you cannot make any promises about the deadline.
You need to be realistic with your boss. You will come out much better having over-delivered on the project rather than under-delivering on an aggressive timeline.
You have to be honest and tell the boss that there's a problem. However you need to show how much exactly of a problem it is so that you don't sound like an incompetent person waiting for a pink slip.
You need to carefully analyze what is to be done and break it into small parts and see which of them you can do and which you can't. It's normal to have parts in the project which look possible but hard to do - every normal boss usderstands that.
This way you show that the problem is not imaginary and it's not your desire to get nice salary for trivial job.
The truth of course is always the right answer, which your boss will find out eventually, better to fail early.
But with that said, is it something you just don't want to be involved in. Make sure you explain to your boss that you don't want to commit to something that you're sure to fail at but let him know that it could be a learning experience and at least be involved at some level, even if it's to look at the solution after it's done.
Create a realistic schedule and present it to your boss. Ask your boss for his input regarding the schedule. Maintain a positive attitude and let him know that you are both working toward the same end goal. Tell him that this is your best professional estimation of the amount of effort needed to meet all the requirements. Point out where the complexities are if challenged. Be firm and clear and above all else give him an opportunity to speak his concerns. Demonstrate good listening skills and address each of the issues he presents in a language that he feels comfortable with. I wish you all possible success in your project.
If estimations are not yet there then your first task is to do a realistic project estimation. Second task would be to check what technologies are required for the project and check if the knowledge is already available. If not then estimate for the training and gaining the knowledge. I understand boss is boss but you do your part and rest is up-to him. If the boss appreciate others opinion then he will understand but if he is like "I am always right" then you do whatever you can(work as best you can and also look for a new job).
Its a bit on the side of all the good advice I've seen here, but I'll say it anyway: most managers are actually quite smart. Senior managers I've met have all been very smart. The problem is that, as Eric Raymond puts it, they are "differently optimised". So they may need some education. If you assume that they will be reasonable once they know all the facts then you will almost always be correct.
Of course you do occasionally get people who behave unreasonably, or think that saying "make it so" like Captain Picard is Leadership. But they are rare, and do not last long.
Go fight club on him? Get free monies and airfare!
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 5 years ago.
Improve this question
Our project manager usually consult developers how many hours they need to implement some functionality asked by client. Is this consistent with the principles of management? Do you or your project managers do the same?
There's no other way to know how long something will take. You should be thankful, really, that your PM is even consulting you -- too many managers get together with the customer and promise impossible timelines, then expect the devs to live up to their outrageous promises.
Certainly. Without getting estimates for development time no-one has a clue what is going on. You need to be able manage stakeholders expectations, in this case your clients. And better the estimate comes from the horses mouth (in this case the developer) rather than the PM promising impossible time-frames!
Developers sometimes get funny about doing estimates of this nature (I know I do), but it is critical to running a business. The easiest way to approach it is to understand that the PM just wants information. Be open and honest - don't say things will be done when they won't, and explain when and why things might be unknown, or why there might be an element of risk around your estimate.
Yes, you can't get away from PMs wanting an exact figure of how long something will take.
My approach has been to give estimates with +/- values. I'm 60% sure I'll finish this in a week, there's 30% chance it will be longer, and 10% chance it'll be 2 days. Takes a while for a PM to get used to that idea, but it's the reality of the situation. As someone wise once said, only [insert deity here] can change reality, regardless of how much the PM would like it to be different.
We know that Dev is an in-exact science, the tension of traditional project management, meeting creativity and best guess estimation is probably the single biggest headache of professional development. A really good learning from Agile is just how bad we are at estimating, most Dev's will underestimate 80% of time - that's my estimate anyway.
Yes, it's his job, because time = money
If you consider the fact that
you are part of a business
that the purpose of the business is
to make money
Time = money
Then it is makes perfect sense that your manager asks you "How much time will this take" because it translates perfecty into "How much will this cost".
Someone must pay that cost, it will either be a customer, or your company.
The PM will use your estimates to ensure the project comes in on time and with in budget. If you say something will take 10 days, and thats 5 days more than he'd like, then it's up to him to either a) cut some other functionality to get this in or b) extend the deadline.
So thats the PMs job, to get estimates from you, and juggle the balance between deliver times and functionality delivered.
YOUR JOB is to provide the best, most honest estimates you can. Like someone else said, always give a confidence prcentage. "2 days, 30% confident" "Possibly 1 day, could be 3 worst case" etc.
It can be annoying to be constantly asked, but it's his job.
P.S. Sometimes the answer "I don't know" is perfectly acceptable, however you should phrase it as "I don't know, I need to look at it a little more and I'll have a better idea then".
Hope this helps.
You have obviously never worked for a manager that does not ask for an estimate from you. Otherwise you would know better than to question whether they should do it. :-)
Seriously, very few managers can make realistic estimates on the time needed to provide particular feature, mostly because it's not their job to really undersand all the technical intricacies. A good manager will realize this and will always involve the developers to get good estimates of the work that can be fit in when creating the schedule.
I think it's sounds pretty good. It seems better that he asks for an estimate by the people that are going to do it than just promise something to the client that can turn up to be unrealistic.
On the condition that he accepts your answer.
If a PM has a number in mind when he asks you the question he shouldn't be surprised by his results.
A project manager should always ask developers how long something will take. What the project manager does with those estimates will vary considerably depending on their own experience and skill.
If the PM has lots of development experience, they should be able to assist more junior developers in determining whether or not the developers estimate is valid - and hopefully point out why they think there estimate is wrong. Also, a PM should be able to add in other factors that the developers tend to forget - meeting time, sickness, time on SO etc, that all impact on their time.
If the PM has little development experience then the most accurate estimate will come from the developers.
One of the main advantages of this is that it helps you to find out early in the game that you are overwhelmed by a task: If you can't time it, you probably don't know how to tackle it.
Also, if your estimate more than a week, then it is probably off by 100-1'000'000% (a.k.a "pure speculation"). If you come up with "several weeks", I suggest that start breaking up the task and estimate the pieces. This will help you notice danger zones (where you really have no idea how long it is going to take).
This process will allow your manager to get you the help/tools you need to complete your assignments in time (instead of noticing something important missing two days before the deadline).
If you're interested more in these things, I suggest the book "Death March" and the Extreme Programming site (especially this page). Take XP with a grain of salt: Rules are never going to solve your problems; they just tell you what worked for other people. You will always use them judiciously.
Asking is much better than assuming.
We had a business manager recently mention in a all-hands staff meeting that a bunch of new features were on the way and they shouldn't take too much effort to implement. This was news to the development team!!
Yes. It is better the manager consults the team on the time required. And the team has to come up with the actual time line taking into considerations all the factors. The onus is on the team to justify the time required for giving quality output. If the Manager is good enough, he/she would appreciate it and agree with the team.
Its a fair question, just don't ever reply with an off the cuff estimate. Always derive estimates from some sort of specification, that way your both on level ground, thats my advice anyway.