Why software projects take longer than you think – a statistical model | Hacker News Reader

Why software projects take longer than you think – a statistical model

erikbern.com

700 pointsmzl317 comments

An important aspect of being a professional software engineer is having the backbone to sometimes say things like:

- “I don’t know yet enough about the problem to give you even a rough estimate. If you’d like, I can take a day to dig into it and then report back.”

- “This first part should take 2-3 days. 5 on the outside. But the second part relies heavily on an API whose documentation and error messages are in Chinese and Google Translate isn’t good enough. I’d need to insist on professional translation in order to even estimate the second part.”

- “The problem is tracking down a bug rather than building something, so I don’t have a good way of estimating this. However, I can timebox my investigation and if I’ve not found the cause at the end of the timebox, can work on a plan to work around the bug.”

You need to be willing to endure the discomfort of looking someone in the face, saying “I don’t know”, and then standing your ground when they pruessure you to lie to them. They probably don’t want you to lie, but there is a small chance that they pruessure you to. If you don’t resist this pruessure, you can end up continually giving estimates that are 10x off-target, blowing past them as you lose credibility, and your running your brain ragged with sleep-deprivation against a problem you haven’t given it the time to break down and understand.

But when you advocate clearly for your needs as a professional, people are generally reasonable.

100% this. It's not your job to say something that will make your client happy. It's your job to tell them your honest assessment of the task.

Imagine a tradie saying it'd take 1week to finish remodelling your kitchen, and then it turns out they couldn't. As a professional, it's your responsibility to educate the client on the issue - most technical problem could be explained to a layman if the context is set up properly.

The problem occurs when the client doesn't want to hear it.

From around here that's everyone's experience of tradespeople in every non-emergency task.

"Sure I can do this in 3 weeks."

Then shows up once every two weeks and finishes around the four month mark.

I guess he was estimating the effort (billable time).

But was not estimating the actual total time until completion which must include all the lead time, waits and dependencies.

This is another part of the whole 'communication with clients' thing. You have to be clear whether you're talking coding time or wall-clock time. To be safe, give both.

I see exactly the same routine in our game.

"Yes we can do that in three weeks. We need the API documentation for _those_ two systems, network access to _those_ resources, and credentials to log in to _those_ services first."

2 months later we're still waiting on critical pieces of those prerequisites, while someone's screaming that the deadline they'd committed to with the customer was 5 weeks ago.

Oh yeah. This is why I'm always very careful about quoting prerequisites for any deliverable. "We can do X in 5 weeks after receipt of Y, Z and W." Then when they say "why don't we have X," I politely inquire after Y, Z and W.

The most important part of this process is getting it in writing so that you can slap them with it later.

> after receipt of Y, Z and W.

the problem comes when you didn't know you need Y, Z or W until the work actually starts.

That's the difference between a research project and an implementation project. Research, you don't know Y, Z, W, or Q. Implementation, you know the full path from spec to deliverable.

Which is part of why I think the most valuable part of an estimate isn’t the number. Its the task breakdown and identification of risks.

1) You improve your foresight so you can get your manager rolling on getting resources early.

2) You have a concise record of what you think you need. If you notice something else mid-project (which does happen even in otherwise-straightforward implementation projects), you have a concrete point at which to raise a flag to stakeholders.

If you have zero confidence in an estimate from the beginning, then there is no point where its natural to realize “oh hey, this is going to overshoot and I need to communicate about it.”

The other thing you can always refer back to is that the accuracy of an estimate increases the closer it is to finishing it - that is, it's very inaccurate at the start. This is one of the pillars of the agile way of working - you and your team can give a fairly accurate estimation for what can be finished within a week or two. Not so much for a year.

The longer estimations are very much due to changing priorities and a developing environment and understanding of what is being built though, hence the inaccuracy.

>But when you advocate clearly for your needs as a professional, people are generally reasonable.

You should do all this but there will still be times when people are unreasonable, it's just human nature.

Right, thats why steeling yourself for the possibility of having to deal with unreasonableness is important. If you run into it, the first step to dealing with it is to get someone to explain what they expect clearly, in relevant detail, and non-hyperbolically. This short-circuits the possibility of mere misinterpretation. They might have just been expressing their emotions but not yet grappling with their desires in concrete terms—doing so might bring them back down to earth. Then you can resume jointly problem-solving.

If that doesn’t work...I’m actually not sure. But I just started reading the book Crucial Conversations and it claims to have a relevant answer.

>> and then standing your ground when they pruessure you to lie to them.

spot on.

I once had a manager/CEO who thought you can negotiate the planning, the same as like a price. "The customer always wants to get it earlier, the engineer later". Me saying that only the developer is able to give a realistic planning, was probably received as "developer wants to push the deadline back in his negotiation".

In the end, his company went bust because he was selling stuff to customers that could never be delivered on time, or even never at all.

There is a type of negotiation that can be done: Negotiation about scope. Work doesn’t get compressed. But stakeholders can identify non-essential business-facing features and cut scope.

Note well: Automated testing is almost certainly essential. If someone says you are “building an MVP”, then make sure it is an actual MVP. Make sure you have a clear market hypothesis to test and check that it couldn’t be built out of duct tape, Google Forms, Zapier, ITTT, manual processes, and excel-wrangling.

Hah! You just described the start of one of our products so accurately it’s scary! And then we built out the parts that were starting to fail as the product scaled. You can get surprisingly far this way!

Testing will happen. The choice you make is who does the testing and when it happens. Internal people testing earlier is generally preferable to external customers testing 'live', but either way, the testing will happen.

“We can’t make those UX improvements to our core open-source product because then we’s have to introduce untested code. The current code is tested because users have used it and reported the bugs and we’ve fixed them.” Is a real thing a project lead said to me at a previous employer.

"Or customers are better at finding the bugs than we are so just give it a quick look over and ship it" - genuine quote from CEO at a company I soon left

Honestly, I'm surprised more companies don't formalize this. There are places that offer customers discounts or feature-request priority in return for being beta testers, which seems like a major improvement in both integrity and efficient feedback.

I suppose it's both slower and more expensive than "just ship bad code at full price and wait", but I'd still expect more companies to choose it as the intermediate option between that and comprehensive in-house testing.

End of the day, this is what agile is. By accepting scope items in small batches, you end up done.

> Negotiation about scope.

I used to work for an online travel site - before every project kicked off, the business analysts would produce requirements documents that always started with a "flexibility matrix". The flexibility matrix had three rows labeled "schedule", "scope", and "resources" and three columns: "flexible", "moderately flexible" and "inflexible" and they were supposed to check one option for each row. So every single requirements document listed "resources" and "flexible", "scope" as "moderately flexible" and schedule, OF COURSE, "inflexible".

You sound like you're complaining, but your complaint may be incomplete. If those bullet points were honored, that is indeed how pretty much every organization doing development will operate, whether it likes it or not. That is not intrinsically a problem.

I take it these requirements documents were not honored by your non-developers? A document labeling scope as "moderately inflexible" does little if it's treated as written in stone.

One basis for complaint that stands out to me is framing "flexible resources" as a full degree of freedom.

The first question is of course whether that's true, since resources don't tend to flex up unless someone outside the project dictates it. But even if it's accurate, it tends to produce the situation The Mythical Man-Month was written to condemn. If the ship date can't move and the scope won't bend on core features, there's a very real risk of finding that extra resources can't fix the timeline problems.

You're right that most organizations have to operate this way, and it's not inherently bad; I've just found that "flexible resources" is often used as a way to avoid admitting that the real third category is "risk of failure".

Actually it started out as a 2x2 matrix (scope/schedule), and all of them were scope = flexible and schedule = inflexible (of course), and they started adding the "resources = flexible" row so that they could walk back their claims of scope being flexible, because of course it wasn't.

Wait, how are resources flexible here? You can’t just scale the number of engineers on a project quickly..

We actually tried asking for more resources when the schedule was in "jeopardy" and were told that there weren't any available. They suggested we try working weekends to make up the shortfall.

Good, fast, & cheap - Pick any 2, at most! https://en.wikipedia.org/wiki/Project_management_triangle

Isn't it the same in price negotiation? Only the producer knows the costs. Perhaps the difference is that money can be shifted around more flexibly. Even if I come out with a negative money balance from a negotiation (costs more than the buyer pays), it might be worth it for long term goals. But you cannot borrow time. You cannot do the 1 week project in -1 weeks and then compensate by doing the next 1 week project in 3 weeks and break even.

A sales negotiation is pretty zero sum. There is little advantage in paying more for the same product.

However, Giving a developer more time will often improve the quality of the output.

Price negotiation is not zero sum. Zero sum means one party’s gain is exactly equal to the other party’s loss. Most deals are positive sum - both parties get benefits. Price negotiation is about the seller getting some the upside of the buyer’s benefits but not so much that it sucks for the buyer and not so low a price that the seller will walk.

Some deals are inherently negative sum - if you bought a lemon.

If I pay a dollar more for the same thing, I, the buyer, lose a dollar, and the seller gains a dollar. Can you explain how that's not zero-sum?

If one thing if you are haggling over a used toaster at a yard sale. It's another when you are negotiating a business relationship where the success of both parties is important. A contract with a supplier doesn't do you any good if the terms are so bad it cripples their ability to execute.

That highlights a beef I have with economics. Failure to understand that business relationships are exactly that. You can't model them using the sorts of time invariant non-network models they use.

If you are "negotiating a business relationship" you aren't necessarily haggling on price, but service. This is why I mentioned "the same product"

'The same product' is fleeting and ethereal over the long term.

Yet in the context given, it's timeless and relevant..

Ok, here goes

First, Not everything is a commodity with perfect substitutes, arguably most things aren’t. Substitutability goes beyond price.

Secondly, benefits are not necessarily equal or a linear function of cost.

Third, whether a game is zero, positive, or negative sum requires a look at the costs/benefits of the whole transaction. Saying that a buyer gains $1 more if the price goes up is obvious, it that doesn’t necessarily make it zero sum when you look at the overall transaction of a $1 price raise. .

Zero sum implies that price, costs and benefits are equal. I spend $20 on a product that cost you $20 to make, and I get $20 of benefits out of it.

Whereas I buy something for $20 , it cost you $5 to make, and I got benefits of $100 out of it, that’s positive sum, as both the buyer and seller got positive gain. If you raise the price, the deal isn’t as great, but it’s not zero sum.

There is such a thing as negotiating too hard on price. The deliverables have lower cost to benefit than if you paid more money. Or worse no deliverables. Worse than that fatal realized liabilities.

I worked with a group that designed telcom IC's. One of our customers developed a new product. Which then failed in the field. The parent company had to issue a recall. Destroyed all remaining inventory and canceled the product. All because someone jacked the microphone supplier down about 5 cents on a part.

In his mind there is one negotiable variable, though - how many hours you work. You want to work 40 hours/week, he figures if he can push you to work 80 hours instead, it'll get done twice as fast. The typical CEO's background as a schoolyard bully gives them plenty of experience in this area.

I'm on a project right now and I am telling people "I don't know how long it will take because nobody here has ever done anything like this. The only thing I can tell you is that nobody is wasting time and we are solving problems as quickly as we can. Look at the JIRA board and see what we have done and what we are planning to do and make your own estimate". So far I haven't been fired. I also refuse to stop work and start long planning meetings like I have seen in previous projects.

I once worked for CEO as a Director of Engineering who was convinced that any product feature could be implemented in 2 days - and this was a non-trivial engineering area.

That was an entertaining job.

curious about this person's reaction to things not being implemented in 2 days. did he/she think that people were just dragging their feet? or not as smart? or sabotaging things to make him/her look bad?

He just edited it out from his version of reality! In fact, in all the time I was there (roughly a year including a major new product launch) I don't think anything was ever done in 2 days.

Another interesting characteristic he had was to get upset if he thought projects were running too smoothly...

We have a manager who seems to think that the only way to get good performance is to set impossible deadlines. There are no consequences for missing but it’s pretty unpleasant and stressful to have to deal with this.

Ha. That sounds like my last job except s/2 days/3 hours/.

> They probably don’t want you to lie, but there is a small chance that they pruessure you to.

In my experience, most of the time there was pressure. I remember a funny conversation between my project manager and a colleague:

PM: "We need to have X as soon as possible, how long will it take you?"

Dev: "Oh that's, easy, I can finish it tomorrow."

PM: "Tomorrow??? That's impossible, because it needs a and b, no?"

Dev: "Yes you are right... I can probably finish it by next week."

PM: "Next week??? That is a long time! It's only a, b, c and d that needs to be done. Does it all take that long?"

Dev: "You are right, I can probably finish it sooner. I can get it ready by this Friday."

PM: "That is perfect! The customer wanted to put in production on Monday, so we can now confirm. Thanks!"

I overheard that story (open office), and it was a real facepalm moment.

> Does it all take that long?

That's just a question. Asking questions is OK. If you have such a high need to please other people and such a low self-confidence that you will change your answer simply if someone asks you twice, that's the problem with you, not them. I say it as someone who have been like that and have changed it through therapy.

I was a nervous mess and always thought that people around me don't like me, pressure me and in general was very nervous around any interaction where I and other person have some disagreement. But turns out, firmly saying "No" is quite OK, people react well to it, respect you for it and nobody is going to fire you for giving good estimates.

This is the core of my point. Therapy was helpful for me learning it as well.

This is gold. Besides, if someone doesn't react well to your honest estimates, this is probably a red flag and you're better off letting them find someone else. After all, this is supposed to be in everyone's best interests.

It actually is a problem with them because when someone asks "Does it really take that long?", they're implying that it shouldn't. Of course, in reality, they have no idea either and if they're asking you how long it should take, they should accept your answer, not try to weasel out less time.

But are they ever going to admit that they have no idea and accept your estimate on face without playing BS mind games? Probably not. But for some reason that doesn't stop them from trying.

I've never seen someone try and do this with a home contractor.

It can also be that they flubbed at communicating and meant to ask, “what are the things that make it take that long?” Underlying that question would be, “are we on the same page about the scope of this?”, “Are you making business assumptions that I can actually provide updated information about?”, and “Are you lacking resources/clarity that I can get delivered to you?”. Thats a charitable interpretation but it’s occasionally the correct one.

It might also be that they’re surprised at the complexity and want to know more. For this reason, the important part of an estimate isn’t the number. Its the task-breakdown and the identification of risk.

Explicit is better than implicit. Asking is better than guessing. If you think that someone is implying something, ask them.

In most cases, people who ask "Does it really take that long?" are giving you their first emotional reaction and haven't actually thought it through deep enough to decide to manipulate you. They're upset and they want to make sure that they understood you right - which is a thing people often do when they get bad news, and I cannot blame them: if you get upset about something, at least make sure you really should be upset.

So, you should react either in a spock-like "stupid rational", giving no thought to what they might be implying whatsoever with a simple "yes", or, even better, in an emotionally-aware rational way: acknowledge their emotions and offer options. There are always options and trade-offs, they just need to be clearly communicated. Not "OK, I'll do it in three days instead of five", but "I'll can do it in three days with prototype quality so we can test it out, but it will be buggy as hell, not fit for production, and you should document it". I've never had a manager who had a problem with that, and I despite how popular horror stories are, I really doubt that there's a lot of them out there.

Your manager cares about the product, he's emotionally invested in it and wants everything to go as fast as possible - it's not a bad thing! It's only bad if you view his disappointment as your fault - but it's not. It's just how things are. As a developer, you're often a messenger bringing bad news. There's no way around it, and you have to learn to deliver bad news for people. And separate these bad news from you and your professional self-confidence.

Your manager cares about the product, he's emotionally invested in it and wants everything to go as fast as possible - it's not a bad thing!

If he was emotionally invested in the product, wanting everything to go as fast as possible is not necessarily a good thing. I can make things go as fast as possible, but then the questions become no unit tests? no integration tests? spaghetti code?

And this isn't a response from a few go around either. This is often the first thing that comes out of their mouth, right at the beginning of the project.

What happens is as follows:

1) Your manager has software development background and uses it as a superiority contest to show how much better they are than you. His lack of awareness regarding variable skill level or lack of knowledge of an existing system seems to factor little into the question. So one could argue the manager could be more empathetic in this case.

2) Your manager knows nothing about software development and really has no business asking such questions in a condescending manner. So they either pretend to know or they promised someone higher up the chain even though they had no idea, but were scarred to say so, thus the cycle has completed.

3) Your manager has a calm, rational head and accepts your estimate, your explanations, and has a good understanding of the product to negotiate with you in terms of requirements without getting emotional. The manager trusts understands that your estimate is, more than likely, not going to be accurate but accepts the changing winds and doesn't hold you to the fire.

I totally agree its better to be explicit. Which is why it matters to avoid overly emotional reactions and accept what people tell you so hand waving can be avoided.

But this is more of a prevailing problem in software requirements in general. It's rare that developers get projects with clear ideas on what needs to be done because of the ignorance or unknowns in questions that need to be asked in order to deliver a product. Often the developer has to decide, and when they do and its wrong, then they have to fix whatever they decided because no one explained, or bothered to explain, how something was supposed to work in the first place.

> I've never seen someone try and do this with a home contractor.

I'm surprised that you haven't. I've certainly seen the same kind of thing happen, though admittedly it is usually based on cost rather than time. Ultimately, though, the discussion was the client disbelieving a high effort estimate.

>Asking questions is OK.

Is it?

Questions have built in assumptions and implications. Most questions don't have enough to be of concern, but some questions definitely imply things beyond the question itself. When asked 'Does it all take that long?', many hear an implied 'Make it not take so long.' command. It is not implied all the time, but it is implied often enough. This does not mean someone has low self-confidence or needs therapy.

If you hear a 'Make it not take so long.' command, thats not an unreasonable interpretation. However, it is also one that should be questioned because it clashes with how software projects work.

If you go from "my boss gave me a command" to "I must execute the command and not question it" without exercising independent judgement, then I would assert that you do have low self-confidence. Whether someone needs therapy is a deeper question that we should be hesitant to answer for another person. But therapy was tremendously helpful for me in realising how my personal and professional life were held back by my reluctance to trust my own judgement or endure the discomfort that can come with honest, respectful, collaborative confrontation.

> reluctance to trust my own judgement

I should make explicit: Part of trusting ones own judgement is also being willing to say, “I don’t have enough knowledge/experience to make a trustworthy judgement here.”

And this conversation is happening in a two hour stand up meeting with a dozen people including upper managers.

Remember - the pressure is to get you to work unpaid overtime under the (mistaken) belief that more hours = more software.

It's about having "passion"!

oh man this hits close to home

to avoid downvotes add sources.

Can you add sources to justify this statement?

I was trying to say, In my experience controversial comments are better received w/ sources to back the items.

At the time I made my comment the Parent comment had a negative score and I was trying to be helpful to commandlinefan .

Just curious, what sort of source would you expect for that? An article from Manager's Monthly about tips on tricking your employees to do free work?

ah. I see now what's gone wrong. I thought I commented on the parent comment about

> under the (mistaken) belief that more hours = more software. reply

I'd delete it if I could.

#1 source of employee stress is deadlines.

https://www.shrm.org/resourcesandtools/hr-topics/employee-re...

"We want only people who are passionate and are risk takers"

Can you explain which part, in your opinion, is facepalm worthy?

In your example conversation, the developer starts off by demonstrating that they are not good at thinking through how long things take them, by giving an impossibly optimistic estimate. Even the PM, whose job is not to figure out how to build stuff or how long building stuff takes, knows the estimate is wrong, and pushes back on it, pointing out dependencies the Dev appears to not have considered.

The dev comes back with another estimate, also provided on the spot, without actually thinking through all the tasks, problems, and potential ways to streamline / accelerate. The PM, having just had the dev's lack of thorough thinking with regards to complexity estimation amply demonstrated, asks the Dev to think more carefully, a third time.

Are we facepalming at the dev who can't be bothered to actually consider what it will take to get the thing done, or the PM who for some reason accepts the 3rd estimate, even though the dev appears to just be randomly generating numbers? Both?

> can't be bothered

or who doesn't know that "I'll need some time to get back to you on that" is an acceptable part of their vocabulary.

It's this part where the estimate becomes a deadline:

> PM: "That is perfect! The customer wanted to put in production on Monday, so we can now confirm. Thanks!"

> pointing out dependencies the Dev appears to not have considered.

I'm not sure if they're dependencies or other priorities in this case. I've had managers before ask for an estimate and and I've given them one (2 days), then they've assumed that I'm dropping everything I'm in the middle of and told clients it would be done in 2 days.

The problem with estimates is that the people asking for them really want promises.

I'm facepalming at both of them:

1. The PM just wanted it done by Friday, because the customer wanted it by Monday. This was clear at the end of the conversation, not at the beginning. So it just could have been a "Can you get this done by Friday? Because the customer wants to use it on Monday"

2. The developer clearly had no backbone, and was just throwing numbers to see what the project manager would like. 1 day? Too short! 5 days? Too long! 3? Perfect! Estimates might be a guessing game, but not a guessing game on how long the PM thinks it should take.

So yeah, facepalm to both of them, and the whole situation. But I must say that they were definitely not incompetent people. The PM was one of the best I worked with, and the dev was a smart passionate coder. It was just that situation that was a bit absurd.

Proper way on how to do this:

PM: Can you give me a deadline (not estimate!) on when you can finish X? The customer needs this ASAP, so it has priority over your other tasks.

DEV: Let me look into it and I'll let you know in half an hour. (Works out estimate, possibly asking input, adds a buffer because deadline != estimate, looks into his own schedule of meetings etc).

DEV: I can get it ready by Tuesday.

PM: I'll notify the customer.

> That is perfect! The customer wanted to put in production on Monday, so we can now confirm.

Here you can see the exact moment when an estimate became a commitment.

I would recommend this talk regarding professionalism:

https://www.youtube.com/watch?v=p0O1VVqRSK0#t=5m20s

EDIT: The part about estimates is here: https://www.youtube.com/watch?v=p0O1VVqRSK0#t=36m56s

I'd replace "they are hired for their knowledge" with "professionals are hired for their judgement". Judgement usually depends upon knowledge, but its the exercise of judgement that is more key to emphasise.

On the other hand, you can only argue about the estimate if there is even a channel to argue about it. I have seen several cases of (1) people being told about a deadline through various proxies, so there was no point in time where they could even question the imposed deadline, (2) people not being told about the deadline at all until it was missed, so they could not argue against it, (3) people not being told about the task that has a deadline until after that deadline was missed.

All involved engineers actually had the backbone to say it was impossible, but no chance to say it. Obviously, projects did not go well at that place.

At least this saved the engineers quite some amount of time.

Well, this is some good advice.

Another nice trick if you're under time pressure is to arrange the project so that you can deliver it in stages that partially meet the requirements, or even deliver something non-functional that people can play with while they wait.

This can keep the sales team rolling or customers happy for a while, buying you some time to write the program properly.

As a bonus, you might get earlier feedback if you're going in the wrong direction, in which case less time wasted.

(Obviously this approach isn't always possible. Many problems won't decompose nicely.)

this is where it becomes crucial to know why you're building the thing you're building. That way, you can often structure the project in phases according to your engineering judgement of the way those phases are built and the business value they enable.

Then you can cut scope by postponing (or not doing) some of the phases. Ideally.

> But when you advocate clearly for your needs as a professional, people are generally reasonable.

This has not been my experience. People want ‘estimates’ at all costs, tell you to not worry about any accuracy, and then a week later tell your manager you committed to x date.

This is a real thing that happens, but its frequency varies from organisation to organisation.

“Let’s just put some number in those boxes”, next thing you know it is signed on blood...

As long as software is a cost center to your company, it will be treated this way. Trying getting a job at a company where software is a core concern. Ideally with a CEO that is not from a marketing/business background.

For more on this sort if thing, Patrick McKenzie’s writing is good:

- https://www.kalzumeus.com/2011/10/28/dont-call-yourself-a-pr...

- https://www.kalzumeus.com/2014/04/09/what-heartbleed-can-tea...

You are right, great posts. Thanks for sharing.

Thanks for the links! I really wish I read these when I was in my undergrad, they are really good!

> In the real world, picking up a new language takes a few weeks of effort and after 6 to 12 months nobody will ever notice you haven’t been doing that one for your entire career.

Spoken as someone who has never taken the time to fully master a programming language and, from the sound of it, has never worked with someone who has either. The difference between someone who has spent 6-12 months with a language compared someone who has spent 6-12 years is night and day. From the general tone of the article, he obviously focuses more on the business value than on the technical side and that is a pretty good approach for making money. But I'll take Peter Norvig's advice (http://norvig.com/21-days.html) over this guys when it comes to mastering a language.

To be fair most of the content of those articles is pretty decent though and it is just a pet peeve of mine when people claim that mastery of your medium doesn't matter.

Thanks for posting that Norvig post. It's fantastic.

In my experience, having mastery over one language translates more or less directly into being at least journeyman in all others.

If you are working with an apprentice, whatever you do, it will seem like you are really experienced.

In my experience, that's not necessarily actionable advice. (the first link)

One thing I've learned working in both kinds of companies is that having software as the core concern of the business isn't automatically a shield from bad project management or bad engineering management.

'Not considering software a cost center' is a necessary but insufficient condition for healthy estimation. A software company often appreciates you more, but is still susceptible to the other myriads of management pitfalls.

I have watched a manager with a master's degree in computer science pull this BS. At an enterprise technology company. He would go as far as repeating a question over and over until he got an answer he liked.

The senior members of his team had a culture of eighty hour work weeks. Draw what conclusions you may.

That's easy. Guess a number. Add some units. Double it. Double it again. Then double it again. Add a zero. Done.

Or, how to make people impressed by the fact that you’re always 10 times faster than your estimates.

> People want ‘estimates’ at all costs, tell you to not worry about any accuracy, and then a week later tell your manager you committed to x date.

I like to handle this problem by providing an estimate RANGE.

Typically when we need something budgetary from a vendor we use the +/- 50% rule. That shouldn't be hard not to screw up.

That doesn’t really matter. In these cases you often have information akin to ‘we want a webshop’, so you estimate something more or less reasonable, then a few weeks later you find out they actually meant ‘we want a duplicate of Amazon’.

The biggest problem is that engineers tend to think in man-hours and managers think in calendar time. If I say a project will take 2 days, it'll probably take 2 days, but it might span 4 calendar days because other things are going on.

The biggest thing that has helped me here is to keep a running list of my tasks, an informal Gantt chart, and show it to the manager whenever they ask me about an estimate. This helps me communicate in a way they understand.

There's a lot of bad to be said about how companies use story points and velocity and all the rest, but I do greatly appreciate the way they delink "amount of work" from "delivery date". It's a nice built-in way of expressing time requirements separately from schedule, which is a lot smoother than constantly reminding people that the difference exists.

I find you have to do this, but it can damage professional relationships.

Recently I've flat out said no, as gently as I could, to doing some work - porting a software stack to run on Windows.

A customer is asking for an estimate to do it, because a project manager who wouldn't be developing or supporting (or even using) the system likes Windows. The sales manager isn't thrilled with me over it.

So he's asked the team as a whole to estimate it because I wouldn't. The rest of the guys are frontend devs. I don't have a clue, they're in a worse position but for some reason they're all up for putting a number to it so I look like a bit of a !

I'm a contractor, so I can and would just turn down the work, but it's difficult politically.

This drives me crazy!

Dev: "It's a really bad idea, will take an indeterminate amount of time, and be a maintenance nightmare" PM: "Can I just get an estimate?"

I'm a big believer in pushing back on small words doing heavy lifting. "Just" is a big red flag in software delivery.

Ok cool but if they have to deliver it, they’ll look like fools in the long run when they can’t, and in the end they’ll see you’re right? So it’s a win for your reputation in the long term I think?

That's naive.

Nobody will revisit the GP's reputation, and after the novice devs fail to do the work people will just scatter into different projects. They may or may not take a reputation hit, while the PM that insists so much on doing the not viable work will take none of it.

My guess is no one will look back and say "Huh, he was right".

The only thing that probably is going to happen is "Huh, why isn't that delivered?" and then they will look everywhere but on the fact that it was, at least partially, just a stupid idea in the first place.

Of course I don't know the exact situation so it's more of a thought on what happens in general in the industry.

At the risk of a totally uncalled-for derail into politics - this is a hilariously apt description of Brexit. It makes me want to reanalyze the entire situation from a project-management perspective. It suggests a possibly illuminating metaphor: party leaders = management + sales, the electorate = the customer, and representatives = developers and engineers.

An alternative to flat out saying no is to point out how expensive and risky what you've been asked would be, in terms of development time, maintenance, and other metrics that the business cares about. Even very rough estimates with a list of risks will usually do.

If somebody else comes out with a much lower estimate, ask them what they think about risk A, B, C... if you've got a point, this will usually work.

That's a bingo! It's never No! It's "Sure, this is what it entails and this is how much it costs". Especially if you're a contractor. If their willing to pay the price, why not take the money and do the work?

Mostly, I'd agree.

I have literally no idea how long it would take though, I couldn't in good faith put a number to it.

I also don't want the work - Windows isn't an environment I have experience in because it's an environment I don't want experience in. They wouldn't allow a rate change to do the work.

If you do this, identify beforehand what you think is non-negotiable. Because it won't be a technical discussion, it will be a negotiation and you're liable to be committed at the end of it.

Of course, once you're holding certain things as non-negotiable... you're saying no.

Jerry Weinberg had the Orange Juice test which always struck me as a practical approach to all requests.

https://medium.com/intercom-inside/the-orange-juice-test-c90...

> ... it's difficult politically.

The thing to understand about politics is you can do everything right and still lose.

Here, the damage was already done by their unrealistic expectations. You were either going to accept the job, fail and make them angry, or reject it and make them angry.

Sometimes your least worst option is to cut your losses.

I agree with you but like others have said, they want a date they can sell to and in the end it will be your fault.

It isn't just software that goes double, look at most custom building projects or government contracts. Most everything takes twice as long and costs twice as much.

I read something once that has stuck with me. "We can never give more than a vague guess because we are literally building something that doesn't exist and has never been built before."

* I do find it annoying that the sales teams generally drive this. I wonder how they would feel about a response of "We'll get you an estimate of when it will be available as soon as you get us an estimate of when this feature will generate the $1M of revenue to cover the costs of building it. Also, please give us a list of customers that are likely to buy it and your expected contract date so we can track it along with development."

> It isn't just software that goes double, look at most custom building projects or government contracts. Most everything takes twice as long and costs twice as much.

There's definitely a correspondence here, but it's a bit indirect.

Government and even private contracts are often knowingly lowballed to secure the deal. Rules like "must choose lowest bid" reward entering an unrealistic bid and then inflating costs after work is going. Or, if overruns come with sufficient penalties, doing work at a loss and then charging a fortune to support a fragile and proprietary result.

In the metaphor to non-contracted software, developers generally don't correspond to the contractors but to the government. Sometimes blown estimates are simply errors, but other times somebody wanted to secure customers, so they pitched an unrealistic scope and arranged to make the inaccuracy land on the programmers. Where the government ends up with late delivery or runaway costs, programmers end up working crunch time or sacrificing quality. And where the government ends up locked into paying for support, programmers end up locked into maintaining rushed, tech-debt-riddled work.

(As for pushing sales for revenue and contract estimates, do it! Some of the most productive teams I've been part of have been ones where sales applied this pressure, but also responded well to the reverse version and kept everyone informed.)

I like to mess with people. "It's 80% done so there's only 80% left to go". "Now' it's 90% done so there's only 90% left to go" etc. Of course my current project is rather higher stakes than usual, so I'm being a little bit more sober than I normally would be. However I am emphasising the need for communication with other stakeholders and identifying and trying to rectify where they are bottlenecks pdq.

I highly recommend the book "Software Estimation: Demystifying the Black Art". I work for an outsourcing company and part of my job is to come up with estimates and it helped me deal with clients and managers.

The book contains a quiz that we used as part of a training exercise with management and the results were hilarious. Here is an online copy: https://scrumandkanban.co.uk/how-accurate-are-your-estimates... please don't look at the answers, I guarantee you will have fun completing it.

For clients, my preferred approach is to show "The Cone of Uncertainty" and ask where they think they are. Since most people have no idea what they want to built I ask if its ok if my estimates are 4x off. That usually gets me a few weeks of peace while a team comes up with a product definition and we start all over again :)

I started reading that book in 2014, but put it down because it really was about project-level estimation on the order of a few weeks to a few months. At the time, I was really looking for guidance on how to estimate tasks—things on the order of a few hours to a couple days.

I’ve gained some experience and confidence at this in the years since, but at the expense of some psychologically painful experiences and a firing. Our industry really calls out for a more basic book aimed at University CS grads (or bootcamp grads or MOOC)-grads on how to estimate tasks.

That quiz has an unintentionally apt question.

> Total length of the coastline of the Pacific Ocean

Coastlines are fractal. If your measuring stick is 1 km long, you'll get one number. If it's 1 m long, you'll get a much larger result. And if it's 1 cm long, you'll get an even larger result.

https://en.wikipedia.org/wiki/Coastline_paradox

The actual length of a coastline is infinite when measured with an infinitesimally small measuring stick.

Software development effort also increases, unbounded, as discovery proceeds and the precision of requirements increases.

>The actual length of a coastline is infinite when measured with an infinitesimally small measuring stick.

>In actuality, the concept of an infinite fractal is not applicable to a coastline; as progressively more accurate measurement devices are used

The notion of the length of the coastline, and why I think the question is apt as well, is that regardless of the fractal paradox, the practical answer is that there is an answer that is accurate enough to satisfy the business's or the customer's needs.

The analog for software projects, from my point of view, is scope, and it's generally one of the biggest problems with projects that take too long. Product and various stakeholders take outline broad, high-level scope requirements that may or may not actually be informed by the realities of building or delivering that piece of software. They generally kick the can down the road and take a "I'll know it when I see it" type approach that winds up drastically changing things at some arbitrary point later on on the project.

A rough measuring stick for scope always means that the answer will be longer, however, small measuring sticks for scope are absolutely impractical. What's needed is the understanding from the business that refining scope increases development time, and the high-level broad scope that is sufficient at the beginning of the project is not sufficient at the end. Many businesses want to run with the assumption that their broad scope and the estimates that go with them are accurate enough to bring a product to market.

The practical answer is that the question is ill posed, and you need to clarify what is actually being asked. A reasonable way to answer the question as asked would be to model the coastline as a fractal, which would give you an estimated length of infinity. What is needed is not a better way of estimating the answer to the question as asked, because the answer to that question is not useful. Instead, what is needed is a better question (which would require knowledge of why the question is being asked).

I just started reading the same book. Seems really nice so far!

link to the book - https://amzn.to/2IpTNw2

Going to read it. thanks.

Thank you for posting this - I took this quiz a few years ago in a team exercise and all of my answers were off. Since then I wanted to find a copy of this test, but didn't know where to look.

I think out of 15 people nobody got more than 1 or 2 right, except for my manager, who somehow got about 8 right. I'm curious how the HN crowd does on this - care to post your scores?

I got 6 right. For another 2 incorrect estimates an edge of my estimated range was very close to the correct answer. I think the key is not to try giving too narrow estimates and think in logarithmic scale. If it was possible I tried to decompose a problem to smaller pieces and calculate my estimate from information known to me (i.e. radius/circumference of the Earth for geographic questions) and make a range out of it by adding/taking couple of zeroes from my original estimate.

A big +1 for this book. I read it with the team of developers I managed (at a consulting company, where estimates directly made the difference between profit and loss on projects) and we found it very useful. It got us to quit using "gut" estimates quite so much and to always keep an eye out for actual data or at least things to count.

> “I don’t know yet enough about the problem to give you even a rough estimate. If you’d like, I can take a day to dig into it and then report back.”

This is my default. Even when I am fairly confident I know what the code does, I want to double check. And it isn't just so I don't short change myself on time. If I tell them X days and deliver on 0.X days several times, they'll start thinking I overestimate everything and cut me off at the knees. It pays to get as accurate as possible.

Its a good default.

I wish school taught me how to do your first point.

People talk about project management, gantt diagrams and all that but you have no idea how to estimate even grossly the complexity of a thing.

The lack of a good “intro to task and small project management” MOOC or book is a serious problem for our industry’s ability to onboard junior engineers. I wish I knew how to write one, but TBH I don’t know any principles myself except one.

Lots of people say “just do it and multiply by 3” without appreciating that The important part of estimating tasks is coming up with the task breakdown and identifying the risks.

The best you can do in most scenarios is to research comparable projects and calibrate against them. "They shipped in six months, therefore we can ship in six months."

Have you ever done this and had it turn out successfully? Because my intuition is screaming at me that this would be disastrous.

For one, it skips the step where you break down the tasks. For another, it seems likely to ignore a bunch of variables in the search for something similar enough.

Both the mentionned idea are natural, but it's ultra sad that we can only live by experiment like craftsmen for previous eras. Not that I mind craftmanship but at least school should write it in bold letters so you're not seeking a mathematical model.

once my CEO asked: "can we add more developers and finish the project faster". I used this famous quote "9 mothers cannot deliver a baby in one month" and we had a big laugh

My somewhat more nunanced retort to such kind is that it depends how much of this work is linear and how much non-linear and how are they naturally occurring. non-linear work may mean things like understanding a complex codebase or developing an algorithm. these dont speedup by adding more people ( what I dont say is these may speedup by adding more quality/unfragmented hours to the individuals doing it). However stuff like refactoring codebase or minor bugfixes may benefit by adding more engineers.

Unfortunately, the problem then becomes defending whatever timeline you have in mind for non-linear work. also doing too much of this can give bully managers an opportunity to nitpick and micromanage the whole thing.

> You need to be willing to endure the discomfort of looking someone in the face, saying “I don’t know”, and then standing your ground when they pruessure you to lie to them.

This. I have PMs who will ask me over and over until I give a number and I've learned to stand my ground. Because if I don't, I end up being responsible for the estimate I've given (as I should).

Now I make it clear that I will not give a number until I know more. Just a few weeks ago I was asked to give an estimate of how long it would take to do an integration with something I've never used before. I said, "I need 1-3 days to learn the product enough to give an estimate". What I get back is "can't you just give WAG". But this time around I said "You have two choices, 1. you give me time to learn what I need and then I'll give an estimate or, 2. Find someone who already knows the product to give you an estimate"

To anyone else that doesn't know what WAG is, it's apparently "Wild Ass Guess".

I find that SWAG sounds better, and let's you add "Scientific" to the front of it.

"Scientific Wild Ass Guess" sounds better? I think I'd just stick with "educated guess". I wouldn't even make an acronym out of it.

"SWAG" sets the expectations much better than "educated guess"- you're saying "I got very little idea, but you really want a number, so here's a number". "Educated guess" sounds much more like you've got a good idea, which using the term "SWAG" is trying to avoid.

> I got very little idea, but you really want a number, so here's a number

Where does the "Scientific" come in? Because I really thought it implied having a good idea, which made SWAG seem like an oxymoron.

I believe it's juxtaposition for comedic effect.

If your guess is a mathematical formula with assumptions for the inputs, those assumptions can be tested and the formula refined ... It's a SWAG.

You use things like Average/95/99, t shirt sizing, how much work can be done in parallel, 3rd party/client dependencies, ramp up time for a new library ... it's still a wild assed guess but at least there's some basis in reality and you can defend your estimate - show me what I'm wrong about or missing and I'll revise my formula.

Negotiating over the assumptions and inputs is 90% of the battle anyway. Without a model you're standing on sand.

>> I end up being responsible for the estimate I've given (as I should)

You're not responsible for an estimate you give, the person who's asking for it is.

This is the key difference between an estimate and a commitment: If you give someone an estimate, they are responsible for steering the project using that information. If you give someone a commitment, you are responsible for meeting that commitment.

This is why very few people actually want estimates. They want commitments, but they will ask for estimates to get an answer and then interpret them as commitments. Most people asked for estimates know this intuitively, thus "doubling and adding 10" and other communication strategies to turn estimates into safe commitments before they are communicated.

> until I give a number

One big insight for me, which you obviously put to use in your story, was learning to give a different number.

"I don't know" is understandably frustrating to people who are trying to plan work and answer requests. They often respond to that by pushing for a delivery date even when it won't be accurate, but a lot of the time what they fundamentally want is a numerical answer. "I'll have it scoped out by Tuesday", "I need at most 3 days to learn enough to estimate", and so on all aid that planning without committing to a project timeline. That rarely ends the conversation, just as it didn't in your example, but it does a lot to show good faith and justify not answering the initial question.

Also clear communication (although you are pretty much describing that too).

I had a friend who had an unusually high frequency of conflicts with various management, project managers (I expect there are always some, but this guy had a lot of bad experiences).

He showed me an instant message conversation:

PM: "Is X done?"

Dude: "Yes, but a, b, c is not done"

A, b, and c were parts of X's requirements.

Now the project manager or such should have been able to read between the lines, but man don't lead with "Yes" and actually describe a situation that is "No".

It's important to realize that the workplace often involves being subjected to what is really a kind of psychological abuse. It is not, I think, a coincidence that we are learning that many "stellar managers" turn out to be abusers, e.g. guilty of sexual harassment. What you're describing is in psychological terms thought of as "maintaining boundaries" against a person who is intent on transgressing those boundaries for their own gain or amusement.

If you validate the invalid assertions of these abusers (e.g. that some unclear task can be estimated with certainty) then you're enabling the abuse.

I think “abuse” is an ill-defined enough term that I’m not sure it adds clarity to this discussion without setting out a definition. Its an important subject and might be a really important lens through which to view this, but as someone who has been searching for a really clear-cut definition of “emotional abuse” since my childhood, and who has seen a lot of acrimonious conversations about it since then...I worry that the framing adds more smoke than light to the discussion. :(

Do you have a good definition? One whereby a scrupulous person can confidently judge “am I acting abusively?” correctly?

I always consider four factors in estimating software cost

- the scope of the task

- the resource/people you have

- the confidence in the resource/people

- and the dependency on both the resource and the task

Estimation goes wrong in many ways. In my experience, I categorize as follow:

- estimated by non-technical PM, unable to gauge technical/business complexity

- estimated too early in development life cycle. Often time someone come up with idea X then ask right away "shouldn't be difficult, how long will it take"

- no view on team member's productivity due to lack of measurement or measuring the wrong thing

- not considering dependency in the development cycle. e.g. The question "whether our only backend engineering available for the task" is often omitted

- not considering testing, documentation, 3rd party integration/procurement, maintenance and deployment cost

The common practise of coming up a number, then double, or maybe triple it up to make the estimation does not address why estimation is off. Mis-estimation is a symptom. The cause and the cure lies in the people

I've been one place that I thought was really good at software estimation. Their system was:

Everything gets a T-shirt size. Roughly, "small" is no more than a couple person-days, "medium" is no more than a couple person-weeks, "large" is no more than a couple person-months.

Anything beyond that, assume the schedule could be unbounded. Figure out how to carve those into a series of no-larger-than-large projects that have independent value. If they form a series of iterations, don't make any assumptions about whether you'll ever even get around to anything but the first one or two. That just compromises your ability to treat them as independent projects, and that creates risk that you find yourself having to worry about sunk costs and writing down effort already expended when it eventually (and inevitably) turns out that you need to be shifting your attention in order to address some unforeseen business development.

At the start of every quarter, the team would commit to what it would get done during that quarter. There were some guidelines on how many small, medium or large projects they can take on, but the overriding principle was that you should under-promise and over-deliver. Lots of slack (1/3 - 1/2) was left in everyone's schedule, in order to ensure ample time for all the small urgent things that inevitably pop up.

There was also a log of technical debt items. If the team finished all their commitments before the end of the quarter, their reward was time to knock things off that list. Best reward ever, IMO.

> Everything gets a T-shirt size. Roughly, "small" is no more than a couple person-days, "medium" is no more than a couple person-weeks, "large" is no more than a couple person-months.

That's pretty much exactly what I've ended up using on past projects - a little more fine grained (start at a half day, went up to months), but that was my approach as well, and if I didn't know everything it went up a size.

Did you find much differentiation between half day and couple of days? Especially because some things that might take a couple days end up taking 30 mins (some efficient package already exists), and some half day things end up taking a couple days, so it comes out in a wash?

Half day items were strictly bound, well know problem, like a label change, or a piece of functionality I knew by heart to be that size. I found that those items usually helps balance out the larger item misses.

The answer to that question depends heavily on the duration and nature of your planning iterations.

If you're doing quarterly planning, the difference between half a day and a couple a days is meaningless, and there's not really any point in distinguishing among them.

If you're doing 1-week sprints, the difference between half a day and a couple days is enormous, and the product planner might get some value out of distinguishing among them.

If you're following a more kanban-y approach, the difference is perhaps meaningful, but not particularly actionable, so I think I (personally) still wouldn't bother to capture the distinction for planning purposes.

The "small", "medium", "large" approach sounds a bit like the one used in Pivotal Tracker.

According to Joel Spolsky¹, programmers are generally bad at estimating, but they are consistently bad, with the exact factor depending on the individual. So by measuring each person’s estimate and comparing it to the actual time takes after the fact, you can determine each person’s estimation factor, and then when they estimate again, you can get a pretty reliable figure.

1. https://www.joelonsoftware.com/2007/10/26/evidence-based-sch...

You know that article was written to sell a feature in their bug tracker. I like Joel's writing but I'd take that piece with a pinch of salt.

If we try to be a bit charitable, we could assume that they implemented the feature in the bug tracker because of this observed property of estimates.

True, but you should always put up estimated effort and real spent time in the task, whichever bug tracker, or issue tracker you're using. I don't know of any other way to improve the estimation "skills".

I tracked this myself for a few months and found that I was fairly consistently estimating around twice the actual required time. That was for fully scoped out and planned work, mind you (and that I was the one who scoped and planned).

"As estimators gain more experience, their estimating skills improve. So throw away any velocities older than, say, six months."

I don't know how Spolsky is (was) as a boss, but it's is way easier to just adjust your time reports according to the estimates and make your boss happy than to actually try for no benefits to either you or the project. As long as the estimation errors are white noise-ish and in linear relation to actual task length, which is the assumption for his model to work, manipulated time reporting and not manipulated make no difference.

I've noticed that when programmers are introduced to Agile they initially are bad at time estimates until they learn that you actually can report time according to the estimates and no-one will ever notice. Extra points for looking on the burndown chart before reporting time to make it smooth.

"Some developers (like Milton in this picture) may be causing problems because their ship dates are so uncertain: they need to work on learning to estimate better. Other developers (like Jane) have very precise ship dates that are just too late: they need to have some of their work taken off their plate."

Milton is probably doing fair estimates. When planning four months into the future you probably can say where you are within 2 months with 50% probability (or what ever boxplot he uses) of where you think you will be at that time. Janes reporting is obviously manipulated to match the estimates.

US navy has developed something similar with beta statistical distribution. You estimate "Optimistic", "Most likely" and "Pessimistic" time estimates for each task in the project and then use beta distribution on it. Some tasks take way longer than estimated.

Here is the link to the time estimation described above with Beta distribution. https://www.isixsigma.com/methodology/project-management/bet...

I've seen a similar model that I've adopted for my own projections which is 30/60/90 - the 30% chance scenario which is highly successful but less likely, 60% chance scenario that is good with a relatively decent chance of success, and the 90% chance scenario that is the lowest outcome but will almost certainly happen.

I do this but only with best and worst case. Any estimate with a worst case of more than 5 days need to be broken down again unless it's a known quantity. Thanks for the link, I had no idea this was part of 6 sigma

You might also know this as PERT (https://de.wikipedia.org/wiki/Program_evaluation_and_review_...)

I used it in the past and I think it is a good framework to discover uncertainty and make it more visible, because it makes you talk about optimistic and pessimistic cases.

The estimates are also good enough to come up with a draft schedule.

I find this approach very interesting, but it hinges on the assumption that project completion times follow a beta distribution. What's the basis for that?

It may reflect the observations in OP kind of well -- with one difference: it assumes we're good at estimating the mode, not the median. But other than that, within the range we're talking about (1 < alpha < beta) it has somewhat similar shape to the lognormal distribution.

The three things that still bother me about that idea are:

1. I haven't tried fitting it to the dataset in OP;

2. It's bounded to the right, which seems unrealistic;

3. I haven't come up with intuitive interpretations for the alpha and beta parameters in this context. If the beta distribution means something, then its parameters must have natural interpretations as well.

As always, my favorite article on this subject: https://www.lesswrong.com/posts/CPm5LTwHrvBJCa9h5/planning-f...

> A clue to the underlying problem with the planning algorithm was uncovered by Newby-Clark et al., who found that

Asking subjects for their predictions based on realistic “best guess” scenarios; and

Asking subjects for their hoped-for “best case” scenarios . . . . . . produced indistinguishable results.

> So there is a fairly reliable way to fix the planning fallacy, if you’re doing something broadly similar to a reference class of previous projects. Just ask how long similar projects have taken in the past, without considering any of the special properties of this project. Better yet, ask an experienced outsider how long similar projects have taken.

Daniel Kahnemann calls this the "inside view" and "outside view", from his book Thinking Fast and Slow.

The relevant excerpt (mostly an anecdote that serves as an introduction to a whole chapter about it) can be found here: https://www.mckinsey.com/business-functions/strategy-and-cor...

The mythical man month ( required reading for most CS programs ) goes into a historical and production aspect of why software projects take longer than what you think and what you expected.

Also, there is a law named after author called the Brooks's law : "adding human resources to a late software project makes it later"

https://en.wikipedia.org/wiki/Brooks's_law

In most industries, if you are running behind schedule, you throw more workers at the problem to catch up. For example, laying railroad tracks, digging ditches, deliverying packages, harvesting crops, etc. By adding more workers, you shorten the time it takes to complete the project. But which software engineering, the reverse tends to happen. If you are falling behind, just throwing more developers at the problem worsens the problem. Most likely because you need the new developers to get "caught up" with the code/project/tools but if you rush that process, then they won't have a full understanding of the project/code/tools and introduce bugs/problems themselves which exacerbates the problem.

It's a fun read if you have the time.

> required reading for most CS programs Really?

Given most software project estimations are off, wonder if a corollary of Brook's law can be - don't add resources in later stages of 'any' software project.

Ah, but how do you know what stage of the software project you're in? Are you 3 months into a 4 month project or are you 3 months into a 5 year project?

Maybe, instead of asking - if I'm x months into a y months project (assuming y months is the initial estimate) - ask if the project is x% feature complete. Based on the remaining features identify how far the project has progressed. Though, this approach has the problem of scope creep. As the requirements are fluid, especially in a long-running project.

My rule of thumb: take your estimate, double it, then add 20%. I'm not joking.

An approach that gives very similar results to yours but is more scientific is to multiply the initial estimates by e (2.718). Or, if you're conservative, then by pi.

The above approach uses the factor 2.2. Why would your factors be any better?

Nitpick: x * 2 * 1.2 == x * 2.4, not 2.2

Extended nitpick: Technically, they only said "then add 20%". They didn't specify of what that 20% is. It's up to interpretation whether they mean 20% of the original value or the doubled value.

Wouldn't it be 2.4 as you are adding 20% of the already doubled estimate?

Yes.

2.2 is just an arbitrary number.

e is also just an arbitrary number, but it looks like someone calculated it using sophisticated math.

Because e is more scientific.

Semi-seriously, e is a number defined by recursive growth.

So if you estimate to Level 1, and then break down to Level 2 sub-tasks, then Level 3, your estimate will be out by the same amount each time. and your total error will be a multiplicative series.

If you have an infinite number of levels - which is reasonable for most real-world projects, although this may not be obvious in the planning stages - e will get you nicely in the ballpark.

Eh. I've been successful adding 20% in. I feel like if you have to double first (meaning your end result is 220% of what you originally estimated) then you aren't learning from previous mistakes. Maybe 220 is appropriate for the first time you do work or work with a certain team tho.

220% also works fine if each one of the projects is "practically unique" to you / the team... this happens >50% of the time in the real world, imo, because some fields have very little transferable skills/experience from project to project... a large percent of stuff is genuinely new every time and never repeats even if it's "basically the same thing as that other project"! (Or team composition changes.)

Problem is the fact that you can only justify with a straight-face 45% (100%/220%) of the estimate you give to the client... Then you need to get clever at "bluffing" your way at "inventing" another extra +35% of work that you can't imagine/explain, but you know for sure that will come out of the blue - you know there's this extra 35% work needed for sure, you just have no idea what this work will be. Then finally you can say with a straight face that 20% of estimated time is for unforseen circumstances. There's two ways to see the same math:

  (1) 45% + 35% + 20% = 100%
  (2) 100% + 100% + 20% = 220%

The world would be a much better place if clients / managers / project owners etc. would just accept that 55% of time & cost for software dev is unknown-unknowns type of unexplainable/unimaginable-at-project-start-stage-work. That's just how it is! If the problem was really clearly defined and understood, there would likely already be an off-the-shelf software solution for it that could be used instead of paying developers to build custom software!

If we could just be honest with people and show them formula (2) instead of a make-up-ladden version of (1). But people don't, so we get to play the damn elegant-bullshitting game over and over again...

>Then finally you can say with a straight face that 20% of estimated time is for unforseen circumstances.

This is how I always have done it across multiple jobs and I always called that extra contingency. Depending on the project I sometimes had to ask for over 50% of the total as contingency. If anyone queried it I would explain that it is very likely we'll need it based on my experience of many other projects.

Then the client would either accept it as is, or they would want to split the proposal into "what we will definitely pay for" and "what we will pay for only when it is actually needed" which is also fine for both sides if proper progress reporting has been agreed in advance.

Someone could think that no client would agree to such a contract as it would open them to be taken advantage of by an unscrupulous supplier, but at the end of the day what matters in business is trust. If a client doesn't trust the supplier they shouldn't hire them. And in all my previous projects I never met an engineer or developer that would deliberately use up the contingency time when it is not needed as everyone knows the availability of this extra time might come very important towards the end of the project.

That's a smart way to do it. I used to put in ranges (basically contingency) of rate but I found myself consistently hitting a similar % of the higher estimate and just started quoting the higher estimate with the expectation that I'm not a God and there may be unknown factors which could add in more cost. Usually people are happy as you say if there's trust and you show progress.

> then you aren't learning from previous mistakes

???

The doubling-it is for when you build the whole component on top of a library, then discover that the library has a fatal bug you can't work around, and you have to rebuild the whole component on top of a different library, then discover that other library has another fatal bug, so now you need to include both libraries with logic around when to use which one, and then that seems to work but you add plenty of tests and documentation to make sure it works that way in prod too and not just on your dev machine.

I don't see what that has to do with learning from previous mistakes. Pretty much all but the most basic programming turns out to be like that -- dealing with unforeseeable and undocumented problems.

(The 20% is because you weren't planning for sick days, an unforeseen emergency bugfix on another project, nobody remembered about the afternoon retreat next week, etc.)

Going through this now and boy is this true. Nothing like rewriting a 1k+ lib the day before a feature is supposed to be ready and then praying you didn't blow up some other lesser documented part of the code.

Yeah and I've been pretty good at estimating what to expect. I mean you'll always find surprises but personally I'm more inclined to quote a lower estimate and come back explaining the situation than to overcharge. But if you know of any clients who are throwing money around like that I'll gladly accept your 220% estimate for a few referrals ;)

Why not just fix the lib?

Wouldn't it be 240%?

It would.

ambiguous grammar

No he said double or (200) then add 20 (220). Unless there's ambiguity I'm not seeing.

Add 20% of the doubled estimate (eg .2 * 200%=40%) surely?

Ah I see your point.

Or you could just multiply by 2.4 ...

I used to do 2.5, I read somewhere 2.5 was fairly common

Triple it. Then triple that if to do it you have to go across team boundaries.

One of my funny-not-funny jokes is "Double it then change up to the next unit of measure" So "I can do that in 3 minutes!" becomes 6 hours. 2 hours become 4 days. 3 days becomes 6 weeks. 2 weeks becomes 4 months...

A professor of mine at university taught us the same thing. It's one of the most valuable things I learned and it is uncannily accurate. Even after 30 years in industry I still fall back on this formula with great results.

Sadly, managers want to believe that you put more effort into estimating deadlines so I'll just whip up a gannt chart retroactively based on the 2/20 rule and they're happy.

> Even after 30 years in industry I still fall back on this formula with great results.

Isn't this Parkinson's law in action, i.e. work expands to fill the time available for its completion? That would mean you overestimate up to 2.4x each time.

Edit: math.

> work expands to fill the time available for its completion

Oh, so if I estimate every task as 1 minute I'll finish really quickly?

The 2.4x is to overcome one's innate overoptimism (even if you see yourself as a pessimist), and to add contingency for unplanned complexity, bugs and general overhead.

It's a rule of thumb, not an immutable law, so if one has completed a similar task many times then less padding is needed.

I know it a little different, where you double it, but then a fixed offset, say 1 week, rather than 20%.

I've worked on twice my gut feel for years. It's generally pretty near the mark.

Humans are optimistic by nature. Even somebody as pessimistic as me.

My number is 5. Maybe my estimates tend to be a little optimistic :-). But in general I can look at something for a few minutes, make a quick estimate (maybe ask somebody else), multiply by 5 and be pretty close to the eventual time it will take.

multiplying by 3 seems to cause the scenario of coming in under deadline and looking like a hero.

I multiply my estimates by the number of people involved.

I close to double mine, but it also depends on the tasks. Some tasks I just know I'll complete in 1X my estimate. I do have a rule that nothing is ever estimated at less than 2 hours; no matter how small the task. Invariably, any time I have broken that rule, someone has checked in code that won't build (or something similar) and I have to spend time dealing with that.

I notice some devs like to underestimate to make them look more productive. Most of those tend to spend a lot of time fixing bugs that QA pushes back to them. They sometimes spend ever more time arguing that it's not their bug.

Your boss just called. They said to tell you to stop padding your estimates...

If that 20% isn't for project management, then add another 10-20% for that, based on experience from previous projects for the same stakeholders. My similar rule of thumb is to multiply my estimate by 2.5, before adding the project management percentage. Of course, if it's something we've done before, it's more along the lines of 1.5 to 2.

Oh, the Scotty Factor approach to estimating?

This is why I like 3 point estimation[1] - if you have optimistic, expected and pessimistic estimates for each task you can pull out which points are high risk. Using a single estimate can't give you that insight.

[1] https://en.wikipedia.org/wiki/Three-point_estimation

manager: "thanks for the optimistic estimate!"

Sure, in the same way a bad manager will say "No, that's too high, I'm going to reduce your estimate" if you use a single number. Bad managers are a thing. Make sure you get a good one.

Yep. I still remember my first manager, who doubled every estimate I gave him. He was great.

Definitely a good manager, but Hofstadter's Law says that's still too low. :)

https://en.wikipedia.org/wiki/Hofstadter%27s_law

I’ve had a lot of success using this method, but it does take having management that understand how software development works. A really good PM will look at an estimate like this as a range, with work complete somewhere between the lower and upper bounds. A bad one will take the optimistic estimate as gospel and build everything else around that.

One strategy for dealing with risk is to order your tasks so the highly variable ones come first. That way, as you progress through the project, you eliminate a lot of unpredictability, and it's smoother sailing toward the end.

However, as the tables in this article show so clearly, one task can dominate others. This serves as a great illustration of a perception problem the above strategy can create. Outside observers watch your progress and will probably evaluate it in terms of number of tasks completed.

You have (say) 10 tasks to complete, and from their point of view, all they know is a really long time has passed and you haven't even completed 1 of them! Since they are further removed from the situation than you are, they are almost guaranteed to not appreciate why the variable task is that way. They're likely to just think your team is performing badly.

So, maybe it's better to order tasks so that risky stuff is spread more evenly across the timeline of the project. It could create less confusion. Putting risk at the beginning is a strategy that requires a whole lot of trust and buy-in.

The interesting thing is that by the central limit theorem, the mean of a mean is normally distributed. This is extremely helpful. Here's what I suggest you do:

Same size your stories to small values. Do 30 stories in a sprint and take the mean. Do 30 sprints and take the mean of the sprint. What you get is the mean amount of time to do a sprint of 30 stories. What's amazing is that this estimate will be normally distributed. You can measure the variance to get error bars.

Of course 900 stories to get good estimates ;-) However, imagine that your stories averaged 2 days each. Imagine as well that you have a team of 10 people. That means that you will finish a "sprint" of 30 stories in 6 days (on average). 30 sprints is 180 days -- the better part of a year, but you probably don't need a 95% confidence interval.

You will find that after a few sprints, you'll be able to predict the sprint length pretty well (or if you set your sprints to be a certain size, then you will predict the number of stories that will fit in it, with error bars).

The other cool thing is that by doing this, you will be able to see when stories are outliers. This is a highly undervalued ability IMHO. Once a story passes the mean plus the variance, you know you've got a problem. Probably time to replan. If you have a group of stories that are exceeding that time, then you may have a systemic estimation problem (often occurs when personnel change or some kind of pressure is being applied to the team). This kind of early warning system allows you to start trying to find potential problems.

This is really the secret behind "velocity" or "load factor" in XP. Now, does it work on a normal team? In my experience, it doesn't because groups of people are crap at calmly using statistics to help them. I've had teams where they were awesome at doing it, but that was the minority, unfortunately.

The central limit theorem is in the limit for the number of variables in the sum approaching infinity. In the finite world, the article explains how it's done. The article is saying, the sum of lognormals is not normal. You are saying: take enough of them and it is normal. The article is still more accurate than your reasoning for 30 stories. From the wikipedia entry for Central limit theorem " As an approximation for a finite number of observations, it provides a reasonable approximation only when close to the peak of the normal distribution; it requires a very large number of observations to stretch into the tails". To prduce a 95% confidence intervals, you have to upper-bound the tails. All methodologies that are based on sum of subtasks estimates are not evidence based. But we knew already sw methodologies are not evidence-based, did we?

    You are saying: take enough of them and it is normal.

This doesn't completely undermine your point, but that isn't what they are saying, I think. I read it as saying by CLT that the estimates of the mean of those distributions is normal and centered on [the mean you are actually interested in]. Tails are perhaps somewhat a red herring here, because you don't really care about them unless you are specifically trying to evaluate worst-case-but-really-unlikely.

Yes, that is correct. It's been a very long time since I studied statistics, so I'm not sure if the variance of a mean has the same confidence interval as the mean. I suspect not. So you would indeed need to have a very large number of samples to get good error bars. It's a good point which I hadn't really considered. However it will never really get that far anyway because hopefully you'll intervene before the long tail hits you.

I think those really long tails are more of a problem when you are working with "features" that are much longer. If you have 1 day stories and you've been working on the story for a whole week, you know you have a massive problem. It's time to back up and see if there is a way to break it up, or to do it differently.

If you have a feature that is a month, by the time you get to 5 months, you have so much capital invested in the original plan that it's very hard (politically) to say, "Nope... this isn't working out. Let's try something else". Of course, it is very hard to get your organisation to plan to a 1 day level of granularity.

Even the language is not correct: We all call it "estimate", but stakeholders behave like it's a "commitment". Passage from uncertainty to certainty happens in the language, and all the responsibility is on the engineering team's shoulders.

Even if you choose the right words, people don't necessarily pay close attention. And if they want a commitment, they may assume that the numbers you give them are a commitment regardless of how you phrase it.

But even if they did listen closely to what you said, "estimate" is not even a great word. If your car is in a wreck, a body shop gives you an estimate to fix it, and they may treat that estimate as a commitment. It's pretty common practice that people are held to an estimate, or to not going over by a certain small percentage. Maybe we need a word like "forecast" or "prediction".

> Maybe we need a word like "forecast" or "prediction".

Scrum (The org behind that flavor of agile) actually changed the language used in their guide back in 2011 from developers making a "spring commitment" to making a "spring forecast" for exactly these reasons.

https://www.scrum.org/resources/commitment-vs-forecast

> stakeholders behave like it's a "commitment".

Many places treat budgets the same way.

> Instead, figure out which tasks have the highest uncertainty – those tasks are basically going to dominate the mean time to completion.

From the technical side of things, uncertainty can mean a few things here:

(A) I've never done this kind of task (or I don't remember or didn't write down how long this task took in the past)

(B) I don't know how to leverage my historic experience (e.g., implementing an XYZWidget in React and implementing the same widget in Vue or Elm for some reason take different amounts of time)

Considering (A)... Rarely does a seasoned developer in the typical business situation encounter technical tasks that are fundamentally different than what has been encountered before. Even your bleeding-edge business idea using modern JS' + GraphQL' is still going to be built from the same fundamental pieces as your 1999 CRUD app using SOAP and the estimates are going to be the same.

If you disagree with this you are in the (B) camp or you haven't done the work to track your estimates over time and see how ridiculously accurate estimates can be for an experienced practitioner. Even "soft tasks" like "design the widget" are estimable/repeatable.

This whole you-can't-estimate-software accuracy position is entirely a position of inexperience. And of course all bets are off there. You are talking about estimating learning in this case, not doing. And the bets are especially off if you aren't modeling that these are two different activities: learning and doing.

> is entirely a position of inexperience

There are a lot of inexperienced software engineers and very little good guidance written for them. What is a new CS grad to do when asked for an estimate? How can a new grad learn to produce accurate estimates within 3 months?

A problem with our industry in this regard is that we don't understand the difference between learning and doing.

A new grad entering industry is going to be doing a lot more learning than doing -- or rather learning while doing.

I know from experience that explicit doing is highly predictable/estimate-able for the experienced software practitioner.

I have a suspicion that the learning side would be predictable, too, if our industry could do a better job of articulating what the practitioner skill set actually is -> then a pedagogy could develop and it could be said that learning X-Y-Z takes on average this long for a set of students. Etc.

But we as an industry do not seem to be near this level of clarity -- in large part because we don't even have the vocabulary to frame it this way... in terms of learning vs doing...

Now what this means for the new CS grad is not the best story. You'll rather have to play the chaotic game a little bit, which includes a mess of things like doubling estimates and working weekends or what-have-you depending on the work culture you find yourself within.

That ^^ in the short term.

In the long term what you should do is practice on your own:

1) ALWAYS privately plan and estimate your tasks to the best of your ability--on your own, you may not get benefit by exposing your "practice" to the higher-ups

1a) hint: your tasks should be as scoped/small as you can make them and they will look pretty simple, like this: "design widget X", "design API interface", "implement API interface", "test API interface", "implement widget Y", "learn how framework X lifecycle works" (yes! even learning tasks can be estimated!), and so on. The key is that you try to keep them under a day and ideally even smaller on the order of hours.

2) RECORD the time it takes and compare to your estimates. --> LEARN from this.

3) REPEAT

If you do this conscientiously you will find that your estimates improve dramatically over time and you'll be able to out-estimate your peers to their own wild confusion.

This skill set will pay off in your ability to deliver AND have weekends and hours with your family. Because you will be able to "see time" and protect yourself. You'll have protection and ammo even in the worst pressure-cooker environments because you will be able to say "No" with confidence. Or rather you will learn how to say "Yes" and what to say "Yes" to. (Ie. you will get really good at priority negotiation etc.) And you'll cultivate delivery trust with superiors and everyone will be happy.

The main reason you get these claims that "business just doesn't understand software" and "they put too much pressure on us" is because "business" side doesn't trust us. Once you get good at estimates and delivering on them, that trust is restored and everyone can be made happy.

BUT -- and here's the rub -- it takes time and conscientious effort and variety of experience to reach this level of confidence. My advice: Ignore all the philistines who say it can't be done....because they'll just try to talk you out of the effort that they weren't or aren't willing to do themself.

> This whole you-can't-estimate-software accuracy position is entirely a position of inexperience.

There are other sources of uncertainty. NASA is probably the only organization that fully specifies product requirements before building stuff - often, even the customer doesn't know. Some problem domains preclude you from knowing in advance! When building the thing, complete understanding of the existing code, frameworks, libraries, and infrastructure is not possible. All of these abstractions eventually leak and break down at scale. Every one of these parts is also continually changing! Even if you could solve all of those problems, you'd still have to deal with people problems - incentives never align, budgets change, and alliances shift.

I don't have a formal proof, but I'm strongly suspicious that the only actual way to know how long something takes to build is to actually build it, which of course, may be impossible.

If the task is to reverse engineer an undocumented binary communication protocol to replace a poorly implemented proprietary file server, building the UI isn't the portion with high levels of uncertainty. I think the advice was good.

With the context you've provided here, this is still an estimate-able task.

The steps to do this task are enumerable and would be similar across similar tasks.

I believe that the conclusion "software estimation can't be reliably done" comes from a standpoint that claims tasks like these ("reverse engineer X-Y-Z...") are somehow completely novel each time we encounter them. In my experience, they are not... even "soft tasks" like "design a Thing" and tasks with unknown details like "reverse engineer X-Y-Z..." -- when you do them more than once -- will be seen for the predictable beasts that they are.

But only if you approach them with the attitude that they aren't these novel beasts. That almost all of the work of the working practitioner is NOT like that of the researcher on the bleeding edge of some novel discovery.

In the UK, bookmakers offer 'accumulator' bets, where a punter can select many outcomes, getting a big prize if 100% correct.

This takes advantage punters' failure to accurately multiply probability - 10 events with 80% probability have joint probability <11%.

Something similar happens with planning, where people fail to compound many possible delay sources accurately.

Dani Khaneman covered this in Thinking Fast and Slow, also showing that people overestimate their ability, thinking they will outperform a reference class of similar projects because they are more competent.

https://en.m.wikipedia.org/wiki/Planning_fallacy

It doesn't take advantage in the way you say because you get paid along the same lines. If you bet an accumulator with 2 selections at evens, you get paid at 3/1. (4.0 decimal odds) so that is "fair".

It's profitable for bookies because they have a house edge, and that edge is increased the more subsequent bets you make. The house has more edge with an accumulator than a single bet.

People like to do accumulators because it's more meaningful to win large amounts occassionally than more regularly win less meaningful amounts.

So it's a "trick" to simply increase gambling.

If you had to pick out 8 evens shots in sequence and intended to roll over your bet each time it would have the same effect / outcome, but starting with a pound by the last bet you're effectively placing a 128 quid bet on an evens money.

It's not that the player thinks that they have a better chance of winning than 1/256 it's that it effectively forces them to gamble a lot larger amount in the situations where only 7 out of 8 of their picks come in.

And that's before considering the edge. If we consider that these are probably events that happen more like only 45% of the time (at best) then instead of a 255/1 shot we're looking at 600/1 shot.

One big factor that I don't THINK the article touches on is how we are using 'space' metaphors (speed and distance) for our work that's very 'time' based (working productivity and duration). And I think when we estimate, we try to estimate distance/duration but we forget that we're really trying to estimate our speed/productivity.

Where that gets painful is, say you estimate you can get something done in two days. In reality, you're twice as fast (there's that speed metaphor), so you actually get it done in one day. Yay, you saved a day! Now assume you're twice as slow as your two day estimate. Boo, you spent TWO days longer. So in terms of duration, getting it incorrect in the painful direction seems like a bigger mistake.

I don't think this is the same phenomenon as the author's mean vs. median dilemma. I'll bet both the mean vs. median and the productivity vs. duration dilemmas are real factors though.

Pet theory: this is entirely explained by unknown systems not behaving as expected. As developers, and unlike e.g. carpenters, we are constantly using new tools with effects we haven't yet experienced. Then we have to yak-shave to get around their heretofore unknown kinks. Then the time blows up.

If and when you're using known features of a known framework, and that's all you're doing, the estimates are accurate and the work is completed quickly.

I disagree. Estimations tend to be just as wrong even when the tools are well known.

There's always that one edge case you haven't considered, that one algorithm that doesn't work as well as you expected, that small change to the requirements the requires a completely different approach.

"Just as" wrong? I don't know what to point to to resolve disagreement here since it's just anecdotal, but if you're just using the same feature you've used hundreds of times before, there is nowhere near the potential for yak-shaving snags.

Okay, sure. Not "just as" wrong since a certain class of pitfalls are eliminated by deep knowledge of your tools.

But I'd argue that that's not where the bulk of the uncertainty comes from. I think that in the software industry as a whole, most of the problems are solved by people with at least a decent understanding of their tools, and estimates still suck.

The problems is that the tasks we deal with are always new, unsolved problems. That's the nature of software. Unsolved problems come with uncertainty. That's the nature of unsolved problems.

Carpenters on the other hand deal mostly with solved problems. They just need to execute.

Here is a story about the woes of interpreting statistical distributions:

I have two habits when I estimate: First, I like to give a range or even better a triple estimate of "optimistic", "expected", "worst case". (And btw, you should expect things to weight toward the pessimistic side, because you always find new requirements/problems, but you rarely discover a supposed requirement is not really one.)

Second: I like to break down a project into tasks of just a few hours and then add everything up. I usually don't share that spreadsheet with the customer, but it helps me a lot. Pretty much always it gives me a number higher than I'd like, but which is almost always very accurate. A couple times I've ignored the result and given a lower estimate because I really wanted some project, and it has always turned out the spreadsheet was right.

Well, one time I combined these two approaches, so that my very finely-chopped estimates all had best/expected/worst values, and I shared that with the customer. Of course they took one look at the worst-case total and said, "How can a little thing like this possibly take 2 years??" I didn't get the work. :-)

EDIT: Btw it feels like there is a "coastline paradox" here, where the more finely you estimate, the higher the max possible, so that you can make your estimate grow without bound as long as you keep splitting items into greater detail. It'd be interesting to see the math for that.

EDIT2: In spite of my personal experience I do think the author makes a strong case for this: "Adding up task estimates is a really misleading picture of how long something will take." Perhaps I've had better results because I try to give myself a little padding in every task, just considering that everything requires not just typing code but getting on some calls, having back-and-forth in emails and the project management tool, testing (automated or manual), fixing a thing or two, etc. So my individual estimates are probably a bit higher than median. When I work with other developers they consistently estimate lower than me. But my numbers are deliberately not "best case", because then you know you'll go over on the total.

The why is typically:

1) The person(s) doing the estimate aren't qualified to do so.

2) There is a disconnect between wishful thinking and reality.

3) There is some arbitrary future milestone (i.e., "We need to ship by ____ because ____ is happening the following week.") that is independent of software development.

4) Most importantly, when the deadline is missed the estimate / estimators are not questioned, the software team is.

I've been at this a long time - too long? - and the narrative that IT is __always__ at fault is a myth that needs to be buried.

I'm sorry to contribute to the dogpile effect (long thread probably says same thing I'm about to say, but I didn't see it..), but..

devs estimate known risks. Ideal path + predictable delays. The further reaches of the long tail are the unknown risks.

known risks are estimated based on knowledge (hence, a question for a dev), unknown risks are just an adjustment parameter on top of that estimate, possibly based on historical evidence (there is no reason a dev could estimate any better).

It should be managements job to adjust a dev estimate. Let's be real here - I've never heard a real life example of management using stats for this kind of thing, or being enthusiastic about devs doing the same.

Perhaps if management is taken seriously as a science, things will change, but I doubt it.

<strong_opinion type="enterprise_software_methodology_cynicism">

Bizness is all about koolaid-methodology-guru management right now, very much the bad old ways - a cutting example of workable analytical management would be needed for things to change, but this is unlikely as all the stats people are getting high pay cool ML jobs, and aren't likely to want to rub shoulders with kool-aider middle managers for middle-management pay..

</strong_opinion>

In my experience software takes longer to build than original estimates because no one will get out of the way of the development team and let them work.

This is an extreme example, but one I now live in daily.

My current full-time-ish gig is working on a pretty enterprisy system for law enforcement. To this date there hasn't been a single feature request, or bug fix that took more than 16 hours of development time. And so I know that I can typically finish something within a few hours to a day of receiving the task. UNLESS my manager wants to discuss ad nauseam what he means when he says "intersect an array". Or get stuck in 2 day long code reviews where my manager makes me sit behind him while he goes over every single line of code that changed, then gets side tracked and starts checking emails, chat messages, text messages, calling other developers in to check on their statuses, and even watching youtube... while I'm stuck in his office waiting on my code review to be done so I can go back to my 5th day of trying to complete a task that would have taken only a couple of uninterrupted hours. /rant

And this is why I pay $120 a week for therapy.

Sorry but why would a manager even do a code review?

He was originally hired as the sole developer 10 years ago, but the project grew too big, and instead of hiring a manager to oversee the project and hire more devs, they moved him into a management position, and put him in charge of hiring new developers.

I give estimates in hours. They're really by days for large projects and half days for smaller projects, but I express them in hours. I then provide a breakdown of the hours the team has been able to spend to date, as well as the hours that each forced interruption took. That way, when my manager asks why he perceives us as being behind on the project, I can tell him exactly how long his pointless meetings and changing priorities have delayed the team. It's also a good CYA technique for when he tries to blame the team when his manager asks why the project is delayed.

I find it useful to point out in situations like this that we have already spent more time discussing the issue, or often "how not do to the thing" than it would take to simply do it.

I used to work for a software company that did projects for clients and charged by the hour (a consultancy) and we frequently had to estimate projects with incomplete information in order to event get the contract in the first place, so they often turned into the actual final budget. Since I was the head of engineering I ended up doing a lot of sales and estimation for new projects. Besides just doing it a lot and gaining experience from many projects, there were a few other things that really helped me:

1) Software Estimation: Demystifying the Black Art by Steve McConnell (already mentioned by others).

2) His short video on "Targets vs. Estimates" was super helpful - we watched it with engineering, sales, and project management all together and had a good discussion afterwards. https://www.youtube.com/watch?v=FY9X21HA02w

3) Keeping a running list of "Things to Remember". Every time a project went astray or we encountered something during a project that I had failed to estimate (but potentially could have) it went on the list. That was useful to share with other too, when they did estimates.

I really like the discussion of standing up to those who ask for estimates. A clear understanding of what an estimate is and what it's for is important, as is a strong sense of professionalism. I would recommend "The Clean Coder" by Robert Martin for this. It's more about professional behavior than software practices. Especially his chapters on "Saying No" and "Saying Yes". I read it and discussed it with my team often. It helped us realize when we had to refuse to give an estimate because we lacked the necessary information to do so, rather than just guess or make something up.

In the world of small medium projects often the major issue is that software engineers give estimates for writing the software but customers take that to mean time to actual delivery in production and a lot of the time have no idea how big a task deployment and integration are...or don't even have a plan for that.

in medical devices it usually takes five times as long to really finish the project vs. finishing development.

To me, software projects take longer than i think because customers don't know what they actually need until there's a runnable version of what they want.

Honestly, after doing this whole data science thing for a while now, I'm going to be blunt: I can estimate quite a lot of tasks with quite a lot of accuracy. including software and IT tasks.

What I can't do is make bad management hear what they don't want to hear. Nor can I stop people from accepting an estimate because its closer to what they want to be true, because they've already made a promise that conflicts with the actual estimate, or because a certain process requires or necessitates inaccurate estimates.

I think the whole "software is hard to estimate" myth stems from 2 fundamental causes:

- not controlling for human biases or referencing actual real world data - processes that don't punish/ reward people who provide inaccurate/accurate estimates respectively.

Vistimo.com, the tool I built and use when I run estimates for my clients, uses log-normals and monte-carlo simulation to conquer this exact problem.

Really exciting to see other people beginning to recognize and use the same statistical tools -- they've served me really well.

I once had a really convoluted metaphor for estimation which involved opening boxes that sometimes contained other boxes which sometimes contained other boxes... I wonder how that models mathematically.

Well, in the most extreme form, you'd wind-up with something like the poisson distribution [1], where your chance of finishing each week would be the same.

This is not entirely implausible but it produces effects even more paradoxical/pathological than log-normal. Here, you could give a correct estimate of the expected time for a project to complete as 50 weeks. You could then reach week fifty and again give a correct estimate of 50 more weeks required. And then you could finish the next week.

[1] https://en.wikipedia.org/wiki/Poisson_distribution

The problem with this analogy is that the boxes do not obey the laws of physics and fit inside eachother...

Did I mention that they were magic boxes?

Wouldn't it be more sensible to give a range instead of a fixed date? I know it's not going to happen, but I think it would be more informative and honest.

That way you could communicate better of how certain you are. There's a difference between telling something will be completed in, for example, 6 month +- 2 weeks. Or something will be finished in 6 months +- 1.5 months. The estimated time is the same but communicates the level of certainty more clearly.

Or just use between, for example, 4-6 months if you don't want to use +- notation.

In my experience, developers understand and appreciate range-based estimates. But when those numbers start moving up the communication chain, some non-developer is going to either not like or not understand the point of the range, and will convert it to a single number: either the first one, the last one, or the average. They might even be honest about it, thinking "I need to know the earliest possible date, so I'll use the low end". But then the next person, who doesn't see the range, thinks that low end is THE committed date and will plan accordingly. Now your deadline is 99% likely to be missed.

Never works. Management will just use your lowest estimate.

So you pad that and realize its the same as your high estimate, so you just give them that instead ... then they complain its too high ... rinse repeat. Unless you stand you ground.

I'm blown away on a regular basis by how long it takes to write software that in my opinion is super easy.

Usually it just comes down to fuzzy/missing/changing requirements. A lot of times people know that they want something, but they don't know exactly what. Or they're absolutely sure they need feature x, but then later they realize they don't, but they missed out on developing other more fundamental features.

I have developed a belief about this: people don't know what they want until you show them what they said they want. Then it's immediately obvious to them what they wanted instead.

This suggests that demos and mock-ups might be a valuable tool. The sooner you can get someone to try something, the sooner they can tell you what direction they really wanted you to go in instead, and the less time you waste.

They want everything but they can't even define a starting point. It's insanity. I've been going back and forth with a customer about this (through my product and sales team) since August of last year. At first the priority was high and it seemed like the scope was reasonable. But no one was making moves or delivering on my requests / asks / concerns. I suggested a phased approach, so that we could _be_ agile and get _something_ in front of the customer for feedback. But before I even got there the requirements changed again and again and again and again and again...

Thankfully all of this specific work is easy to segregate away from the rest of my team. It's proven to be very toxic and morale draining. If my entire team was involved, I've no doubt that we'd have lost people by now.

And the real kicker: It turns out that right now we can't even deliver on the first pass that I had originally suggested, despite me being basically done with my teams piece, because some other team in the company was loose with their language and convinced a bunch of product and sales folks that, yes, of course they had what the customer was asking for. They didn't. They still don't. I'm convinced today that they never will. Bunch of fucking sycophants.

I have no idea how these things happen but recently I've become convinced that this sort of confusion-on-all-fronts is just par for the course in this industry today. The only work that I've been able to do in the past couple of years that was well understood and easy to articulate, and as a result capable of being completed mostly on time and within scope, was born out of a select few individuals being able to identify a real problem and a real solution and grinding away at it in a controlled fashion. But that seems to be rare and not at all "how things are done."

I've always thought that typically overoptimistic estimates tend to be more based on the mode. I.e. 'this is the sort of task that normally takes 1 day, so I'll estimate 1 day'. The high point on the probability curve is the most noticeable, but it's also way further to the left than either the mean or the median.

I have no data to back that up though.

I’ve been coding professionally for 20 years and I’m largely no better at estimating completion than day 1, maybe worse since I’m more likely to feign confidence in a figure I’ve essentially pulled out of my ass.

At some point, I came to the realization that my fundamentally poor concept of time was always going to be an insurmountable obstacle to my career advancement.

My empirically-confirmed heuristic is that the time to deliver a feature set that someone would actually want to use is 2.5x-3x of the time I think of when asked for an off-the-cuff estimate.

Basically, multiply initial estimate by a number between e and pi -- no joke! It's a bit of a problem given that PM's think they're being generous with a 20% pad.

I can relate to your heuristic. The current project I've been working on is close to completion and somewhere between 2.5-3x of its initial estimate.

My theory on why software estimates suck is tied to Rosenberg’s Law:

> Software is easy to make, except when you want it to do something new. The corollary is, The only software that’s worth making is software that does something new.

It's hard to estimate the difficulty of something you've never done. And the nature of software development is to always do new things.

I believe this is the reason why scrum uses story points instead of time estimate. By putting uncertainty on the same level as effort, you give it more weight. And using a fibonacci sequence rather than a continuous amount with the rule you should round up if unsure tend to correct those defects.

Yeah in my experience everyone just mentally translates to time anyway so it is pointless. "11 points, that's about 2 days right?"

If you want to make the uncertainty clear it's better to allow ranges, like 2h-5d instead of trying to play stupid mind games.

Story points are like setting your watch 5 mins early so you are on time to things. It doesn't work.

That happens indeed, but the point (!) stands: the fibonacci scale ensures estimates are rounded up, and that small abstraction merges time and complexity into a single number, whereas it feels more difficult to bump a time estimate based on unknowns/complexity.

That's what happens, its all tranlated to hours and cost instantly. I have seen that at several places during poker sessions. The fun starts when management hears this and starts to calculate with it.

there is an uncharitable response to this thread, which is marked dead. I do think there is a kernel of truth in that response, which is nothing more than mocking.

why fibonacci? I think it's reasonable to say time includes an exponential error. an estimated 1 hour task is very different than an estimated 1 week task. i see that 1 hour, 1 day and 1 week estimates are progressively, and likely exponentially, worse.

Is it just the ease of doing the math? (totally reasonable answer, in my humble opinion). or is there something specific about fibonacci that's actually relevant? I think it's the former not the latter. but if you have any evidence to the contrary, i'd love to hear it.

The kernel of truth of that response is that you won't get more certainty about an estimate by adding more uncertainty, no matter in how much pseudo-scientific cargo-culting mumbo-jumbo you cloak it. (Unfortunately, HN readers don't really like sarcastic commentary which requires reader to think it through. Time is precious, and we just want to be coddled, give me your opinion ELI8 straight, because there is no time to think!)

I think you're half right. adding an error band to a far out estimate won't give you a better estimate, but it might help tell you how much you _don't know_ about what you're facing.

Cumulative error is _hard_. see weather prediction.

The reason the Fibonacci sequence is used is because we don't think in an incremental scale but in a logarithm scale. In other words, we think that some simple takes 1 day, a more complex takes 3 and a even more complex takes 5 days. Usually we don't jump from 1 to 2 days when thinking about a task effort.

You could have also used approximately logarithmic scale that everybody is familiar with, namely, cash! You know, 1,2,5,10,20,50,100,200,500..

But no, here we are doing science, that's why we use Fibonacci, hey even plants and rabbits are using it.

I kinda want to grab you by the lapels and re-enact that part from Clear and Present Danger. It doesn't matter what's true, it matters what i can prove!

Unfortunately, the phrasing would be more like, It doesn't matter what's true, it matters what i can sell to management.

In the absence of evidence to the contrary, i think i'm ready to take a side close to yours. It's useful to expand error bars exponentially as you move away from the time of the estimate, but there's nothing special about fibonacci.

> Unfortunately, the phrasing would be more like, It doesn't matter what's true, it matters what i can sell to management.

Yes, that's my main beef with it. SCRUM could be based on science, but sadly, it isn't. Here's an interesting book: https://www.amazon.com/Making-Software-Really-Works-Believe/...

The reason my team uses Fibonacci is that it cuts down on the “is this a 3, 4, 5, or 6 point ticket?” discussion. Each larger value should have more uncertainty, so there isn’t any point in getting more precise. Not being able to argue over 1 point differences but having to choose between 5, 8, and 13 has a clarifying effect on the process.

It is very easy to answer. Different people have different efficiency, therefore, a task completion does not depend solely on its complexity but also on who is executing it.

You should think about it (even though there are no actual physical units you can use to make this work):

Time to deliver a task = complexity / developer efficiency

This is why it is hard to develop a method to estimate time for development tasks.

If regular time estimation has tricky statistical properties when combining multiple estimates, story point estimation is just hopeless. Especially on a Fibonacci scale. When estimating, nobody thinks that an 8-point story is the same as eight 1-point stories. Even the metric itself is nonlinear!

I push back pretty hard on story points whenever I see them. They’re not useful until several iterations in, once you have a baseline for how many points can be delivered in an iteration, and even then one developer’s 1 point story is another’s 5 point.

When estimating I tend to use a coarse scale of hours, days, weeks, and (in extreme cases) months. All estimates then get turned into a range between the minimum and maximum the estimate could mean - for example hours becomes 1 hour to 8 hours, days becomes 1 day to 5 days, and so on.

Anything estimated as weeks or months probably needs scoping until it can be broken down into tasks that will take between an hour and a week.

I find this method works well because it’s intuitive, comes out with a suitable amount of uncertainty relative to the size of the task, and finally results in estimates with units that are useful to project managers and the wider business in scheduling other work needed to get a feature into production.

One take away is for sprint planning - if there is a reasonable amount of uncertainty on a task, take it out, either break it down or do some investigation, and bring it back next time. You don't want a σ=2 task messing up your sprint!

The assumption in the article is the amount of work is a constant. Instead what happens is that a manager has decided how much time it should take (always too little). If you accept that time, then you will go over.

If you push for more time and get it, then the manager will eventually add more scope and you will go over.

The vast majority of the time we see projects go over deadlines because scope was added under the guise of clarifying scope.

Starting with a business value actually works pretty well to enable people to control scope.

We also use actual velocity on tasks to re-forecast daily. That has been the most effective way to get a good date. Over a large number of tasks this works very well.

I always think of project tasks as flow charts, where every item either takes 1 day, or 1 week. There's no way of really knowing in advance. Complications happen.

It makes it really hard to calculate the "expected value" of 5-10 tasks.

The more tasks you have to do, the more certain about duration you should be - some of the uncertainty will cancel out and you will get a gaussian distribution. For your example, I expect 10 tasks of between 1 day and 1 week each (with flat probability) to take about 6 weeks in total, with a 95% chance of completion within 7 weeks.

Well, I think this is a complex topic. Not because of the math, but because the key to an accurate estimate is to understand who has done the estimate and on what basis.

As stated in the summary, the core driver for inaccurate estimates is uncertainty:

> Tasks with the most uncertainty (rather the biggest size) can often dominate the mean time it takes to complete all tasks.

There are different sources of certainty:

- Experience: If someone has done a task 20 times he probably knows how much time he will require. Someone who hasn't done the task yet, probably underestimate the time he requires (e.g. because of the median vs. mean conflict). But don't be fooled just because you have 20 years of work experience in the field but never actually done a specific task doesn't mean you can estimate it better than someone who just started the job but had done that specific task 10 times. However, most of the time, projects are doing something new. So you have to find out which tasks have been done before by a project member and which are completely new ground. If something is completely new, remember to plan time for getting familiar with a problem space plus a handful of complications (together this will be more than the actual task would take someone who is trained for that specific task).

- Detail: The smaller the tasks the larger the overall estimate... or so. Planning on a top-level is rarely going to be accurate. We do it a lot because it doesn't take much time. But if you want an accurate estimate, you have to plan on small, specific tasks.

- Risk management: Every project has risks. Some don't really have an impact and others blow up the whole project. Know your risks and what you are going to do if something should go in the wrong direction. It is not like you wouldn't have time to figure out what to do when the problem occurs but to understand how it would impact your timing and to take preventive actions (e.g. include stakeholders).

If you have people who have done the exact same task a few times, made a detailed plan of every step and know how to handle the most likely or impactful risks you are in a good position to deliver on time. Most of the time you won't have that luxury and have to compensate the resulting uncertainty with a prolonged time to project completion, but that should be just fine when being communicated in the beginning.

With all that said, remember, that some projects don't require an accurate estimate. Sometimes it is enough to deliver just as soon as possible.

On the experience part, this happened to me few times, when the project manager asked me for an estimation, i give it from my perspective and experience, and then he gives the work to someone else with no experience, and obviously takes more than estimated.

Now, i always give two estimates: An estimation if the work is done by me, and an estimation if the work is done by someone else.

How about making the manager estimate the project, that way if the deadline is not met, the manager receives the blame? It's the manager's job to manage resources, and if the deadline is not hit, then they can hire/bring on more resources. If an engineer works as hard as they can for 40 hours a week, why is it the engineer's fault if the arbitrary deadline is not met? If the engineer estimate's time for a project, the engineer will always have to work more than 40 hours a week because some estimates will be too optimistic.

Maybe if your PM has any technical experience

The manager does receive the blame, and then stuff rolls downhill.

Something I’ve been trying is estimating for the time in which I’m 80% sure I can finish something. I end up racing ahead of estimates most of the time because they are too high, but then some times I’ll find something that is a bit more complicated than expected and it takes a little longer. Overall this seems to balance out, but also have a lot more predictability, it’s easier to predict at any given time what I might be working on. This has been pretty important on my team where I’ve been doing API work for some iOS developers to use.

Yes, this is a thesis I've brought up quite some times in relation to sprint planning. The odd misjudgment having a strong influence on the total estimate biases upwards, not downwards.

What I want to know is why the software developer is expected to give estimates. Estimating how long common tasks take seems like something I would expect a software manager to be able to do effectively and care about. If you’re just a monkey who is asking everyone to do the planning and estimation job for you, I’m frankly unsure why the company allows you to collect a paycheck.

I think the most important issue why projects take longer is not because the time it takes to complete a task is uncertain, but because at the start it will always be unknown which tasks will prove critical. The further you get, the more tasks will reveal itself that were not part of the original scope, but critical nonetheless.

They don't take longer than I think. The problem is nobody listens! True story - They handed me an RFP, asked for an estimate. I gave it and they cut it in half and got the job. I didn't take any pleasure in being right, but I was right. It was an expensive mistake.

1. Do the tasks with, as far as you can tell, the most uncertainty as soon as possible in the process.

2. This is why "agile" tries to avoid estimating more than a few weeks. The more tasks you have in there, the more you estimate is likely to be really off.

Fits symmetric function to clearly asymmetric distribution

Author: Decent fit, in my opinion!

This bad fit makes me genuinely sad (；∩；)

He could probably tweak a skew normal distribution to make it fit nicely, but it's pretty close to normal.

There would be great to have predictions that use ML to estimate how long something will take.

COCOMO and Function point models use regression. That's ML too.

If you are thinking this as opposed to statistical modelling, what is the benefit you imagine?

It takes longer than we think because writing software is solving a math problem, and you can't know how long solving a math problem will take until after you solve it. http://www.warhound.org/kcsest.pdf

Eh don't worry, self driving cars are coming this year, Elon said so.

I've been in a company where all estimates were multipied by pi.

Because they can't take negative time.

I’d also add that the reason why the mean will be larger than the median is usually hard to discern for any specific situation.

This foments bikeshedding debates that are a mix of business pressure to favor uninformed estimates and disagreements about which possible sources of surprises or hitting a wall are most likely.

As soon as you mix this with a formal estimation system like Agile (yes, even the platonic ideal ‘agile’ too), it creates a snowball effect of time wasting because overhead is so frequently required to resolve debates and placate business pressures for estimates.

TLDR anyone?

Thesis: Developers are good at estimating median time to finish tasks. But the tasks that take longer, in fact take much, much longer than estimated.

E.g. Dev estimates that time to complete each of A, B, C tasks will be 2 days. In reality, A will take 1 day, B will take 2 days, but C will take 8 days.

Dev was right about the median time to complete each task (2 days) but average was much higher. Article goes into how to statistically model the distribution of actual time to complete tasks.

That was a really concise but faithful summary. Welcome to HN.

Reply on news.ycombinator.com