Smart Software Development on Impossible Schedules 225
Andrew Stellman writes "Jennifer Greene and I have an article in the new issue of Dr. Dobb's Journal called "Quick-Kill Project Management: How to do smart software development even when facing impossible schedules." We got a lot of great feedback from our last article on open source development, but there were a bunch of people who wanted to know whether it was really feasible to do planning and reviews on a tight schedule. That's a fair question, and this article is meant to be an answer to it. We pulled out bare-bones project management practices that will help you protect your project from the most common and serious problems, and gave instructions and advice for implementing them that should work in a real-life, high-pressure programming situation."
Tried and true (Score:4, Insightful)
Re:Tried and true (Score:4, Insightful)
A couple of points:
- If you don't have a clear vision of what the software is suposed to do and how to get there, having people work 10h/week or 80h/week produces exactly the same result - you get nowhere - either the project is late and gets canned or what you deliver is not accepted because it doesn't match the expectations of the customer.
- Long hours => tired developers => a lot more bugs => much more time is needed to implement the same features => long hours. Unless long hours are restricted to a couple of days, the end result is a vicious circle where removing the extra bugs introduced by tired designers/developers ends up consuming more time than whatever extra time you got from those extra work work hours.
Making people work extra hours gives the appearence of getting more work done while reducing the actually amount of work that does get done. This is one of those management techniques that sites high up in the list of "Things that managers that have no sense of strategy do", right above measuring productivity by "lines of code written" instead of by "requirements features implemented".
Re:Tried and true (Score:5, Interesting)
For details, see http://www.igda.org/articles/erobinson_crunch.php [igda.org]
Techniques don't make up for a bad schedule! (Score:5, Insightful)
In the real world, no amount of tips and tricks is going to make up for a bad schedule. We end up doing code reviews while are software is in verification and validation. Is that smart? No. But when you need to get features done, that takes priority. As for documentation, that always falls to the wayside as well. The truth of the matter is this. The only way to make schedule is to totally inflate your time estimates on the project. We developed a rule of taking the engineers estimates and double them. Of course we're still running a little late ;)
http://religiousfreaks.com/ [religiousfreaks.com]Re:Techniques don't make up for a bad schedule! (Score:5, Insightful)
Re:Techniques don't make up for a bad schedule! (Score:4, Insightful)
In otherwords, the future value of 'doing it right' is lower than the immediate value of 'damn the torpedoes' and getting it done. (unfortunately)
Re:Techniques don't make up for a bad schedule! (Score:4, Insightful)
Some companies works with a sick "problem bringer"/"problem solver" mantra. Removing feature to allow you developping beter code invariably put you in the "problem bringer" section and that is bad.
On the other hand, putting all the features = "(management) problem solver".
When the application crashes in production and the situation looks very bad for the manager, if you come with any way of cleaning the mess you are again a "problem solver".
Every time you remove a feature or refactor the code preventively, from a management perspective you move 1 step in the dark side of the force, so you must handle that with political gloves, not common sense ( i.e. use fear factor, find tactical advantage for your manager not to include a feature, sneak "cleaning" code into features your manager think are worth extra-time to be able to cut budget later on a refactoring,
Re:Techniques don't make up for a bad schedule! (Score:5, Insightful)
It's this notion that not going off and making a total ass over end cock up of a project, and "taking the time to do things right" that is really the problem with allot of developers, and managers attitude to software development.
The quickest way to get a project done is to do it right ONCE! Not five times badly. At developer meetings I've often heard managers or developers call UML and other methodologies a waste of time or unnecessary, it always flabbergasts me to hear such ignorance.
I've been in a situation where an (un)manager told me "We don't have the time to do document and do things the right way", my response was "No, we don't have the time not to do things the right way". We only had 6-8 months to get a large project out, with four programmers, a business analyst and two DBA's. I was told I wasn't to spend time in UML and documentation land, and you know what, I ignored him and spent 3-5 days creating high level class diagrams and interaction diagrams, the core of which lasted us through the entire project.
Any project that you forecast is going to take longer than 3 man weeks ie 120 hours needs some sort of design in place to ensure that the major architectural constructs are already decided before coding takes place.
The key to employing methodologies in projects successfully is unfortunately experience. It takes experience to use methodologies successfully, it takes experience to create good designs for applications and to judge when a design has become mature enough to allow development to commence without the risk of major refactoring later on in the project.
It does in fact take time to acquire this experience (years in fact), but it does not take time to employ this experience once it has been acquired. If you feel like your project needs some sort of methodologies in place, but "you don't have the time", the answer is simple, it's not that you don't have the time, you don't have the right personnel. It's true if you have no one with the experience of delivering the architecture required in a professional and timely manner then taking on methodologies new to everyone on the team is going to take time and lots of it. A good manager however will make sure that the project is correctly resourced.
Re:Techniques don't make up for a bad schedule! (Score:3, Insightful)
Unfortunately
Re:Techniques don't make up for a bad schedule! (Score:3, Interesting)
I agree completely that one should spend time making sure the design is right. But I disagree that it should all happen before starting coding. You will never know less than at the beginning of the project. Improving the design should be a continuous process; then you get to take advantage of new
Re:Techniques don't make up for a bad schedule! (Score:3, Interesting)
Is that the norm or the
Re:Techniques don't make up for a bad schedule! (Score:4, Funny)
( -> anomaly)
Can anyone really estimate accurately? (Score:5, Insightful)
It's interesting to look down this thread and see how many different rules of thumb are employed, apparently by quite experienced developers/managers.
It seems to me that we can make two reasonable assumptions based on this:
One might hypothesise, based on these assumptions, that any project plan that quotes hard figures up-front will be inaccurate most of the time, and without allowing a huge defensive overhead that inaccuracy will often be in the wrong direction.
Now, working from unreliable estimates is in no-one's interests. If a company overestimates by too much on a fixed-price contract, it risks being undercut by a more realistic competitor. If it underestimates, it will look bad when things over-run, its profits will fall, and its reputation will suffer as well.
So what conclusions can we draw from this?
Firstly, if we're looking for realistic management, the way to go is almost always some sort of time and materials contract, with floating deadlines based on when features are actually ready. This allows good developers to do their job properly, which in the long run will be more efficient, and it means that other groups such as sales, marketing and customer support can be kept informed and given realistic expectations.
Secondly, fixed-price contracts are only a good bet for a software development firm if it can include enough slack to be safe, without including so much that it can be undercut by more realistic competitors. The corollary, of course, is that if you're a client, you're almost inevitably going to be screwed by agreeing to a fixed-price contract, even without considering the lack of flexibility it entails.
It is a rare project indeed that truly requires hard deadlines. Smart clients and smart development shops will reach a more flexible arrangement, and come to respect each other for having realistic expectations and providing realistic updates as time goes on.
Re:Techniques don't make up for a bad schedule! (Score:3, Insightful)
An easier approach is to measure progress.
Divide your project into microfeatures, deliverable units of work that are either done or not done and take less than a week to build. Estimate each microfeature on a simple complexity scale (I like 1/2, 1, 2, 4; anything above 4 gets split into smaller features).
Then just start in developing and see how many units of work get done each week. Even a manager can see that if you got 5
Re:Techniques don't make up for a bad schedule! (Score:5, Interesting)
Of course you're running late.
Let me guess - you're a young pup. It's always been the same, since the dawn of history. Every generation laments that succceeding generation has to make the same mistakes, and learn the same lessons, over and over again.
IBM solved this estimation problem back when dinosaurs roamed the earth, virtually all computers were made by IBM, and they came with a "free" (as in beer) systems engineer.
IBM's solution was that every level of management that had to review an engieer's estimate would triple the estimate of the person who reported to (almost invariably) him. So, if the estimate required two levels of managerial approval, the quote to the client was 9 times what the engineers figured it should be. If three levels of approval were needed, the official estimate was 27 times what the engineers came up with. Now you know how IBM was able to afford that "free" systems engineer with every computer.
Actually, there are ways to drasticly increase the likelihood of success on "mission impossible" projects. I successfully led an EDI implementation project where there was no spec, no data, no customer, no access to the computers, the programming had to be done in an obscure language, and there was an arbitrarily set deadline of three weeks. Sometimes you take on such projects because you want to stretch yourself. But that's a story for another day.
The same lessons... (Score:2, Insightful)
Oh, and none of them come up with a cure to the problem, but insist that doing it their way is the cure.
double time ain't enough. (Score:5, Insightful)
Top 12 - Rule of thumb says:
1) Triple the estimated time + 10%.
2) Add 2 weeks to that amount for a complete code review.
3) Any changes by the customer means "adding 2 weeks to the schedule", even if it's one line of code... why? because, it must pass documentation, Q.A., validation and be reviewed by the entire department, without accounting for "double bug", bug induced by another bug and stuff like that or bugs that are in the core library and means retesting "everything", "every module", etc.
4) Any changes must be approved, reviewed and means adding delay (normally a big NO-NO) and therefore, 99% of the case thoses changes are left for future phases or abandonned by the client when they realise the implication. If not, it's your objective to discourage them or force them to reconsider by any means. =P
5) Don't give any feedback to the customer unless you must! If you do, downgrade any progress to minimum to reduce expectation and refrain the customer from adding new stuff to the TODO list.
6) Which means, each phase must be clear, consise, humble, realistic, feasible, with lots of buffer time for fixes, reviews and testing. Exagerating how complicated it is to a customer is always a good idea, because in the end, everything that seems easy is actually very difficult.
7) Do minimum documentation, UML to get started... They'll get rewritten at least 30 times, before everyone in the group agrees after what 40 meetings?
8) Once the phase somehow works and the thing is somehow settle, start documenting it, so you don't forget. It's actually a very good way to detect logical mistakes, misbehaviors, bad coupling, bad cohesion, missing corner cases, bad design choices, usability problems, etc.
9) Best teamwork is small team of 3-5 senior people working toghether hand-in-hand, sometime helped by 1-2 junior, which can do much better than 120 junior who are completely clueless and never deliver on time...
10) For big projects split things up in component and/or phases that a small team of 3-5 people can do, keeping in mind of the big picture so its scales up, but ignoring any meaningless future details that don't matter "right now".
11) Rush the people to do it in "the simple 1/2 time delay", keeping in pocket the "double time" remaining for any arising issue and reworking the core libraries, overhaulin the code, reviews, fixing bugs, etc. This means that if you are really late, you are actually late on your "buffer time". If things goes well, then the project will be done before it's expected, which will impress any client.
12) Finally, but not the least, there's no such thing as a bug, it's just a "small improvement", a "new feature", "code overhaulin", "mispelled requirement" or a "security enhancement". It keeps customer smiling, it's less depressing for everyone and overall keeps the mood up on everyone face with a laugh or two!
Furthermore, no ones want to hear that the code is "full of bug", but saying that a group of people are always "enhancing, overhauling and improving the code base" also means bigger bonus! =)
Hope it saves you from any future project delay or cost overrun!
Re:Techniques don't make up for a bad schedule! (Score:3, Informative)
wow you do code reviews? My last employer dropped those over 3 years ago to "speed up the process"
Re:Techniques don't make up for a bad schedule! (Score:3, Funny)
I've found a more reliable estimation rule is to take the estimate, double it, and change units to the next larger (common) increment of time. E.g. 2 hours => 4 days, 5 weeks => 10 months.
Re:Techniques don't make up for a bad schedule! (Score:3, Insightful)
Starting a project without gathering requirements, scoping the project, hammering the list of business rules and doing a high-level design is a great way set the project up for getting out of control after a couple of months, even without the extra pressure.
Printer friendly version (Score:5, Informative)
Smart? (Score:5, Insightful)
Getting back on track (Score:5, Insightful)
Step 1: Admit being late as early as you can. If people start ranting, keep cool. Tell them that ranting won't fix it. The sooner you admit to being late, the sooner you can stop screwing around and start getting the project back on track.
Step 2: Help management prioritise what they want and what can be delivered when and what options are available. If they want a product to sell, they'll need to make some compromises.
Re:Getting back on track (Score:3, Insightful)
Re:Getting back on track (Score:5, Interesting)
-- this little line has helped me throttle down a lot of rants over the years.
Re:Smart? (Score:5, Insightful)
The appropriate response to any of these is "You should have proposed this project X months ago (where X is a conservative estimate."
Re:Smart? (Score:5, Informative)
In the first case, my company tried to break into the professional market (we were big in the education market) so we announced a major overhaul and several new new features. It was a fantastic vision but unfortunately the president made the mistake of announcing the full feature set and that we would start accepting purchase orders that summer. By the time spring rolled around it was clear that were were going to miss the deadline by several months (very bad when most of your sales are in September), but since the feature set was set in stone, we couldn't cut features. The writing was on the wall but we accepted it and started working 13 hour days nonstop for 6 months. Customer complaints over late orders flooded our phone lines and prevented our previous customers from calling tech support, so our old customers felt neglected and our new ones started cancelling orders. We gave up in christmas and released the complete but buggy product and got more complaints.
The president was replaced, and under his leadership we were able to finish the product we wanted to finish within a reasonable schedule. Depite all the doom and gloom earlier, we survived. Unfortunately, we lost the senior software engineer and another developer in the process.
Then, president hired a vice president which wanted to revamp the whole product and move it to an even higher market. I gave a detailed estimate that said it would take 2 years. The VP said we'd go bankrupt if we didn't release in 9 months. I repartitioned the estimate and said that we could do it in two stages, each 13 months long or three releases each 9.5 months long. No go. It had to all be done in one release, and that release could take no longer than 9 months or we might as well close up shop. I came close to losing my job over the issue, but since I was the most senior programmer there with the most experience about the product, the new senior software engineer told the VP if I went he'd have to give up too. 2 years later, after a complete turn over of the team twice (including the new senior programmer), the product was finally release It had more bugs than we'd like, but it was recieved well by the market so it was "good enough". At release time, I was the last person standing from the original team, but I had enough and left soon after. The product was well received but since the team was new, a new version of the product wasn't released into three years later.
All the VP's threats didn't change an impossible schedule. You can't squeeze 2 years of work in 9 months, not matter how you try to force it. If you try, the most you can do is destroy your team and lose sales in the process. Most of those doom and gloom professies don't pan out. If they *are* true, someone is running the company wrong and development schedules are the least of your problems.
In the later case, had the VP chosen either a more reasonable schedule (like any of the 3 I laid out above), we would have had most if not all of our original team at the end and been able to do subsequent releases at the same measured pace. We would have had regular sales and the company would have prospers much more.
Being a software architect or project manager is hard, but ultimately, the best ones just lay out out all the credible options on the line and stick to their guns, even if it means risking your job. My experience in that job showed me that you can do it even in a hostile environment. If you lay things out properly and tell the truth, you may be resented, but you will be respected, even by those who chose to ignore your advice.
Re:Smart? (Score:3, Interesting)
I don't have a problem with that, really. The trick is to only give the suits levers you want them to pull. The deal I make with my clients is that I control the estimates and they control the scope. I estimate each feature; they d
Re:Smart? (Score:3, Insightful)
And then you: a) get fired.
And then you go compete with that company and bury them because they don't know how to schedule and, most likely, can't prioritize features because they never listen to their engineers.
Re:Smart? (Score:5, Insightful)
Do not lie to your customers when you make a quote for them just to get one contract. Be honest about everything. The most important customers are repeat customers, and you will be #1 on their list if you get them a quality product on time and on budget.
Losing one contract is no big loss, particularly when you know for a fact that your competition cannot possibly make the goals they're quoting. They will look like fools when they ask for time and budget extentions or fail to produce anything usable, and nobody likes to do business with a fool. As they say, people might not know the difference.
Certainly there will always be competition that lies to get the sale and customers that make poor decisions based on unrealistic quotes. Dishonest business and mismanagement are commonplace. That doesn't mean you should compromise your quality or ethics. That's called "professionalism". Customers worth doing business with appreciate that, and you will attract repeat business and new customers through word of mouth.
Re:Smart? (Score:2)
Re:Smart? (Score:2)
Re:Smart? (Score:5, Insightful)
You will be on nobody's list if you give them realistic schedules.
On the contrary, in my experience companies tend to come back to you to ask you to clean up the mess made by the low bidding cowboys when they realise that you were just being honest with them. At this stage you can often get away with jacking up the rates too, as they have made that realisation that you get what you are willing to pay for.
Re:Smart? (Score:2)
What the article says is "when faced with impossible demands from management, do a quick but brutal project plan that shows what the actual realities are". I.E. blast through this and come back with what the real schedule is.
I was disappointed that it didn't mention my all time number one schedule shortening trick though: lose features. Brutally. Slaughter the bastards. Keep slaughtering until someone says "but if it doesn't do that then what's the point".
Code reviews (Score:2, Interesting)
And of course there's always static analysis [sf.net] to catch any problems that do manage to sneak in there...
Re:Code reviews (Score:3, Interesting)
I'm not saying code reviews are the end-all be-all, but is static analysis really going to tell
Re:Code reviews (Score:2)
Mind you, this can also be solved by picking appropriate people to pair with, and having the person not 'driving' being critical enough.
Re:Code reviews (Score:2, Interesting)
--------------
Re:Code reviews (Score:3, Insightful)
Aye here. I've experienced this a number of times and started thinking about it. Generalizing a bit, most developers who like to do code reviews, like to do all sorts of things throughout a week (set up a build system, do some design, code a module, do some testing). However, these are exactly the same developers who often have trouble with the nitty-gritt
Re:Code reviews (Score:4, Insightful)
No charge for the clue.
Re:Code reviews (Score:5, Interesting)
a) An in-depth code review (formal or not) has a big difference from pair programming: the analysis is done by a fresh pair of eyes. Pair programming can result in two people who are too close to the code to detect flaws in their underlying assumptions.
In my experience, code reviews are not that useful to detect syntax or style errors, nor do I think they're meant to be. That's the kind of thing you can automate with a tool anyway. If you're spending all your time looking for that, I agree most people will feel it is a waste of time.
But code reviews can be extremely useful at a higher level: to detect design gaps and flaws in the implementation, or just get improvement suggestions that a fresh set of eyes ban provide, once you see the whole solution.
Often the very process of explaining the whole solution top-down after implementation allows you to detect issues. Other times you can identify common patterns and needs in different features that we're not visible before ('hey, I had to do the same thing elsewhere and we have a common utility class/method for this that avoids this obscure bug here').
b) I don't see how it should be that different regarding the attitude problems you are describing.
If people get so easily offended by a code review, it seems to me it'd be because of team problems bigger than a code review process: either the programmer thinks their code is perfect (which is something to fear) or they don't trust their peer enough to have honest conversations about code.
I guess this is the one advantage of pair programming, it forces people to work closely and practically guarantees that trust. But I do not think you need to lock two people in a room and do everything together for them to trust each other professionally in a healthy work environment.
Heck, code reviews should be fun.
They're peer conversations about code, and if you enjoy programming it should be fun to argue techniques and solutions with your colleagues, even (specially?) when there are strong disagreements. Both sides typically learn something from it; even if a lot of times it is not something you want or need to change in the current code, it will be useful knowledge elsewhere in the future. Just like college or academia, for that matter, back when coding was done for fun.
Re:Code reviews (Score:3, Interesting)
They're not only suggesting a formal code review (with fancy printouts and email tracking and logs and supervision and lots of program management stuff). They're suggesting team-wide formal code reviews.
Although they do suggest being selective about the pieces of code to review, and this can be very useful for very critical code, in most cases such a wi
Re:Code reviews (Score:3, Interesting)
2) If your code reviews end up being "slugfests" and nitpick sessions, then you're not running them right.
Re:Code reviews (Score:2)
A well run code review does not go into slugfests. I personally like how my company does it- we have a web based program that shows the effected files (with the diffs i
Re:Code reviews (Score:2)
The recipient of the review should in that case, grow up. Unless the reviewer is being unnecesarily nasty, in which case they should grow up.
or, just as ineffectively, full of "you should put a space after this brace" comments
Find or grow a code layout standard. Use it. debates on the topic should then run like this: "Minor differences to layout standards on lines 35 to 45", "Noted and will fix. Next?".
For even more fun, find a code beautifi
Review checklist (Score:3, Interesting)
A good way to avoid pissing matches over brace indentation and other nits is to lay down a qualification checklist that m
You can explote your coders better by outsourcing (Score:2)
Re:You can explote your coders better by outsourci (Score:2)
Re:You can explote your coders better by outsourci (Score:2)
" we love deadlines, the whooshing
sound as they go by, priceless ".
Or something like that.
Re:You can explote your coders better by... (Score:3, Insightful)
Re:You can explote your coders better by... (Score:2)
Re:You can explote your coders better by... (Score:2)
There is a hidden flag you can test for.
Easy! (Score:5, Funny)
That's funny, but... (Score:4, Insightful)
I think that the most important thing to do when a project is on an insane schedule is realize that you aren't super-human and pace yourself. If you don't, and crunch hard nights or extra-long 50-hour sessions, you'll spend the next few days with a fried brain and a complete inability to make use of your time.
If you're normally a 9-5 guy, pull 10 hour days. If you're normally longer, possibly consider working longer, but notice when you've started lagging because of fatigue.
Other things:
And my build is done...
Re:That's funny, but... (Score:5, Insightful)
Nooo!
I wish I could beat with a crowbar all the cut-and-paste programmers who make my life difficult - I have to maintain the piles of repetitive crap code that they produced - they knew how to use Ctrl-C and Ctrl-V but could not or did not bother to do the most basic of programming taske: eliminate repetition by factoring code into meaningfully-named, paramterised procedures. This was best practice in 1970 already but so many people still don't get it.
Re:That's funny, but... (Score:2)
Not chunks of functions... (Score:2)
Copy and paste come in handy when you're refactoring a function call, building a table of similarly named elements, or propogating a new flag/variable. It can be a serious time-saver. Ctrl+Shift+(left or right) to select, Ctrl+V, or double-click, Ctrl+V.
I'm not saying that copying huge chunks of code is a good idea. That ends up costing you more time. I'm saying that typing things out fully when yo
Re:Not chunks of functions... (Score:2)
I'm honestly not having a dig at you personally here, but I never understand the attitude exemplified by your post:
Re:That's funny, but... (Score:2)
Luckily for me, this programmer _had_ factored his menu code into functions. 26 of them, in fact!
Re:That's funny, but... (Score:2)
All you gotta do is j
Re:That's funny, but... (Score:2)
I'd like to add another one: fitness training.
Don't stare at me like that. Of course even you can do it, it's just a question of starting small, and working your way up.
Trust me, when you've just sweated fifteen gallons (or at least it feels like it), really finished yourself, and took a long hot shower afterwards, you feel completely new and relaxed. Especially if you finished the shower with an ice-cold minute
Have a look at, for example, http://www.bodyforlife.com/ [bodyforlife.com] - they have a pretty good
Re: (Score:2)
Why do people buy into this nonsense? (Score:5, Insightful)
"Smart ... on an Impossible Schedule" is just management/corporate speak for "How to minimize the crapiness of a project when we know we can't spend the proper time required." You can dress it up all you like with sleak catch-phrases, and call it a rose if you want, but it still stinks.
Re:Why do people buy into this nonsense? (Score:4, Insightful)
Done regularly actually. The big difference is that the impossible schedule dramatically increases costs (heating in winter for year-round construction, running three crews in shifts for 24/7 construction), etc.
For some reason "Impossible Schedule" in software development means cutting corners instead of increasing manpower.
Re:Why do people buy into this nonsense? (Score:2, Interesting)
I think the prime difference is that buildings have a much greater lifespan than software, so it's alot easier to justify the increased cost of a building.
Re:Why do people buy into this nonsense? (Score:3, Insightful)
Because software is something of a virtual product, people think that is very easy to make changes along the way. You wouldn't
Re:Why do people buy into this nonsense? (Score:2)
Re:Why do people buy into this nonsense? (Score:2)
Re:Why do people buy into this nonsense? (Score:5, Informative)
Because that's all you can do (in general). Adding man-power to a late software project only makes it later, as was shown by Brooks [amazon.com] some 30 years ago.
Re:Why do people buy into this nonsense? (Score:4, Funny)
Re:Why do people buy into this nonsense? (Score:3, Informative)
There's a lot of truth in Brooks, but you have to take it in context. Adding manpower to a late project may indeed make it later, but adding more manpower up-front and managing it well can increase the capacity of your team to deliver a project, and therefore get the work done sooner. You get diminishing returns to an extent, of course.
Re:Why do people buy into this nonsense? (Score:2)
And increasing manpower can only get you so much benefit, or as an old boss of mine used to say: "It takes a certain time to bake a cake, and you can't speed it up by turning up the heat or hiring more chefs, unless you really don't care what it tastes like."
Certainly if you don't have enough people, hiring more will help, and there is some window beyond that where addi
Re:Why do people buy into this nonsense? (Score:2, Insightful)
In a business to business transaction there's little to protect a client from a bad development shop. Once you're in more than half-way on a project, there's little a client can do to stop the bleeding. Sure, you could have internally managed the project well from day one, but you chose the lowest bidder (or at least made a compromise). Do you halt development? Most software shops aren't to eager to pick up the pieces of a unfinished project. Also, a project that is la
Good On Paper (Score:4, Insightful)
So yes, the article does make some good points, but they only go as far as the factors covered are under your control. Even in the best circumstances, a poor programmer or a less than perfect team lead can hamstring the whole team. In the end, I think that the only benefit that articles like these have is to make you really think about process. Process might not save you in the end, but at least going through the effort should make you a better developer.
Re:Good On Paper (Score:2)
I used to work at a company that did consulting projects (we'd design hardware/software products for customers and get them through small manufacturing runs). We had one particular difficult customer who just didn't seem to understand that at some point, we had to define what it was we
Re:Good On Paper (Score:2)
Next time will be worse (Score:3, Insightful)
Re:Next time will be worse (Score:2)
fast, cheap, well done (Score:5, Insightful)
A truly impossible schedule is by definition impossible to meet.
An extremely-difficult-but-possible schedule is by definition makeable if the correct resources are applied... correctly.
If management is giving you an impossible schedule, they are either idiots or setting you up to fail or both.
If they are giving you a difficult schedule and refusing you the resources you need, or do not have the authority to give you those resources, see above.
If they are giving you a difficult schedule and you haven't requested the necessary resources, then they are testing you and you've failed the test.
--
What do I mean by resources? I mean anything that can make the project go faster without sacrificing quality. This may mean additional manpower, the authority to say "no" to new feature requests, the authority to make feature cuts, or the reassignment or hiring of people with key skills to your project. It may also mean late-night pizza parties and family-support to the "code widows" until the project is complete. It can also mean additional or extended time off for the entire team after the project is shipped.
Next in this exciting series of articles.... (Score:2)
How to spend money without making any...
How to eat without any food...
How to find another job after your company's poor planning puts you on the street.
12 Rules (Score:5, Insightful)
2) Make sure you only work on things that you need to ship version 1.0 of that.
3) Make sure you keep the prototype running always.
4) Show Demos every few days to make sure noone is confused about what is going on.
5) Tell them they can ship it whenever they want, they write the check.
6) In the meantime, work towards the goallline like a football player, do not circle it like a lion waiting for it to die.
7) Don't make any project your time to show how clever, cute, or interesting you can be...
8) Keep Teams/Egos/Methods/Files/Modules/Projects/build times small. Small is good.
9) If someone is not clicking with the rest of the team:
- talk to them privately
- reassign them
- if this person is you, read #11, and consider if you want to build this project, or do something else. Follow your heart.
10) Do the riskiest part of the project first.
11) Remember that the enemy of the better is the best.
12) Don't worry about it. If you are working hard, and follow 1-11, you are doing your part.
That's enough to chew on. As homework, go build a paper mache model of the project, complete with testers whizzing around, filing bugs that are actually feature requests.
Re:12 Rules (Score:3, Interesting)
Very good indeed. Did you collect these yourself? If so, do you want a job?
I'll add a few more of my own rules:
- Make sure you're in total control of your toolset and improve it systematically
- Do not take the clients' deadlines literally - first accept the project, then renegotiate the deadline.
- Don't implement anything that is not going to be used immediately.
- Design your software around interfaces so you can make massive changes cheaply.
The EA method... (Score:5, Funny)
Drag and drop (Score:2, Funny)
How's that version of "Quick-Kill Project Management"?
Slashdot's bot checker a mind reader?
too idealistic: it's the same old sw management (Score:3, Insightful)
However, the article appears to be far too idealistic.
1) The only good schedule is a realistic schedule. If the schedule is intentionally compressed, it's a bad schedule. The only way to compress your schedule is to cut work (e.g. features).
1.5) Working under the "hurry hurry hurry" "boss wants it yesterday" environment means your engineers will cut corners everywhere. When faced with a choice to copy/paste a function in 15 minutes vs. taking some time to refactor and reuse the code in 1 hour, engineers will choose the earlier. In my experience, design debt then accumulates really fast.
2) Code reviews as suggested in the article are a drag (2.5 hours at a time?!). In my experience, they rarely get anything useful done: it's usually too late to make medium or major changes and under the gun (see 1.5) engineers will scoff at "wasting time" with minor changes. From what I've seen, the code reviews serve mostly as a cover-your-ass mechanism for management.
Code reviews need to be short (30-45mins) and happen as soon as possible, while the original engineer has all of the reasoning and decisions in his head. Hot-on-the-heels code-reviews of bug fixes and feature check-ins (especially useful for bug fixes).
Perhaps the code reviews need to happen as the code is written (sometimes I ask my coworkers to show me their draft solutions). That's almost pair programming though. Unfortunately, that's not practiced at my job, and so I have no expereince with pair programming.
3) Estimates. What the article described seemed to be a basic process for doing the SWAGs and the engineering time estimates that we all "know and love." I fail to see the novelty in the proposed approach: it seems to be run of the mill waterfall stuff.
It's so easy to say "break down estimates into small tasks, so you can estimate well." However, I found it very difficult to do so effectively. Pardon the Rumsfeld flavor, but often we just don't know what we don't know: stumbling blocks occur, requirements drift or get "clarified", surprises abound. Pressuring developers to provide task breakdowns and estimates past their knowledge point can create a false sense of security (i.e. misleading task estimates). I've seen many such a small task breakdown become trash as the project progressed.
Often, to get a better idea of the remaining work and tasks, prototype work is required or some progress on key features.
I have no good answer for this problem, but my feeling is that it lies somewhere in the realm of being able to react quickly to change and reevaluate the project's progress. This is where things like smaller tasks and more frequent completion points of features seem to help. At that point, changing direction is easier because you have fewer concurrent unfinished tasks.
This is where the smaller tasks and frequent iterations of the XP fame seem to be a benefit. Unfortunately, many managers can't take the thought of not having a detailed per-small-task project plan in their MS Project window. So, in my unfortunate experience, such managers attempt XP-style iterations, but then quickly regress into more traditional long-term milestones. I've seen it happen time and again.
Web-u-like (Score:2, Interesting)
I went on vacation, returned after 3 weeks and nobody had used the CMS to populate the site with data and graphics. In f
Re:Web-u-like (Score:2)
"oh, you wanted the buttons to DO something????? that takes longer
Release early, release often (Score:5, Interesting)
As architect of a small software company, the most frustrating aspect of designing software is the knowledge and understanding that there's no way to know how to do it right until you deliver something that's wrong. People almost never seem to know what they need, but they do know that whatever they have isn't it, and they'll tell you why.
So, we have a very different tack, similar to Agile Programming [agilemanifesto.org]. When we implement a new feature or functionality tidbit, we release very early - pretty much as soon as it more or less works without major errors, - with as much fanfare as we can manage on the cheap, and then wait for the feedback.
We're very up front about it, and openly welcome the feedback and ideas. This takes any conflict out of the relationship and turns it into a sort of partnership. Customers love being listened to, and feedback we get, in droves. When a customer sees THEIR idea implemented a week or two after they suggest it, even when it's something stupid-simple (such as having a particular button selected by default to avoid a common mouse-click) then they're your advocate for life!
It's that continuous, iterative cycle that's resulted in our young, 3-year-old codebase having eye-popping features, and remarkable stability. The software updates itself at the client's discretion, so nobody seems to mind much. They update as often as they like.
With this model, there is no due date. It takes me about 15 minutes to issue a release of our software. The idea of a "release" means almost nothing - we've done more than one in a day! (we've released 46 official releases in the past year alone, with too many "unofficial" releases to count)
Faced with this "impossible" situation, (I've lived "impossible" schedules for years now) I'd step UP the release cycle and start pre-annuoncing alphas/betas of the product the instant that something that appears demonstrable compiles and can be stuck on a dev server someplace. Invite comments and download. Call people to ask about feature X or Y. Let them know it's really early, and make sure that they have a place to bitch about the problems they find.
When you do, you'll be surprised how much of what you thought was required was, in fact, completely un-necessary - or at least could be put off until next March for a future release. But, you'll find some simple, straightforward ABSOLUTELY GOTTA HAVE that takes a man-month to code that the users would sacrifice their firstborn to have.
Agile software methods will find this "gotta have" pretty quickly. The waterfall model [wikipedia.org] of software development would take a decade.
You decide.
This model won't work for all products and/or markets. And it's very important not to take away functionality that the customer previously had, or they get the feeling that you're taking something away, and that's bad. But for us, it's been very, very successful, and the relationship we have with our clientelle is very friendly, close and intimate.
PS: Maybe it helps that we're an ASP.
Re:Release early, release often (Score:3, Interesting)
Glad you pointed that out. We code medical devices that cannot fail. Sending alpha or beta code to customers without a written agreement wouldn't be such a good idea.
Rapid Development: Taming Wild Software Schedules (Score:4, Informative)
Rapid Development: Taming Wild Software Schedules
by Steve C. McConnell
I'm in no way related to it, I just own it and I think every project director should have one. It contains a lot of ideas and hands-on tips you can immediately try on the field. The last section, named Best Practise, is a practical reference guide. There is also a chapter if you already are in a crazy project and want to rescue it.
Re:Rapid Development: Taming Wild Software Schedul (Score:2)
Quick-Kill Project Management (Score:3, Insightful)
1. Quick kill the managers who set the impossible schedules
2. Quick kill the developers who can't stay within a reasonable schedule
[Sarcasm off]
It's impossible to change the development time outside of the -10%/+10% margins. If your schedule is wrong you either have incompetent managers, incompetent developers or both. What ever you do, work overtime, drop in more developers or else, all you gain is a few percents.
Development time is IMO a rather static variable, the only thing which can improve this time is education. Yet education has to be done in advance before the project is even started. During the project there's no time for education while the knowledge should be available right from the start. The easiest solution is to always plan for a 25 - 30% education phase at the beginning of your project.
O. Wyss
Just say no (and more) (Score:5, Insightful)
From architect on up, one of your key job responsibilities is to push back on features, schedules and so on, and to set expectations right from the get-go. Early on, I used to laugh out loud when being told proposed dates by marketing. That didn't go over too well, of course, so I've adopted a more diplomatic way of saying 'no' since. :-)
The gist of it is that many executives believe in Spanish management (very well explained in Peopleware [amazon.com]). This boils down to setting ridiculous schedules, asking for continuous overtime, etc. The idea being that every minute an engineer spends more will get the product out the door faster. Of course, this is not the case as Peopleware will tell you in great detail. It is also matched by my own experience.
However, if you push back with data in hand (such as a detailed sizing) and a constructive proposal what to do differently, you may very well end up with a more reasonable schedule, a good product and happiness all around.
A few more gems in Peopleware:
- Schedules are counterproductive. Teams that don't have schedules ouperform those that do by up to 50%.
- Overtime is only productive for one week.
- Cubicles are sinkholes of effectiveness. Why do Microsoft and IBM only have offices for engineers?
Peopleware is rather sobering. Every other page you think "wait - we're doing exactly what is being described here." The good news is that you can do something about it once you can recognize the signs.For those of you with a humorous bent, I highly recommend checking out Joel Spolsky's articles [joelonsoftware.com] on project management. A few highlights:
- Human task switching considered harmful [joelonsoftware.com]
- Joel's test to identify bad software companies [joelonsoftware.com]
As far as the TFA goes, once you've accepted an impossible schedule you're already hosed. If you can't push back, leave. The job market is good right now.If you can get to a reasonable schedule (by way of reducing features, adding time or people), the TFA is a bit limited in its scope. I have a few recommendations that have worked for me in the past (your mileage will vary, and you should read Peopleware anyway):
Simple answer. (Score:2)
Cripes you guys, pulling miriacles out of your asses every day means that management expects it.
Then sales starts selling your team as "getting it done in 1/4 the time. and then youare royally hosed with the worst job ever.
it's really a 1 step process (Score:4, Interesting)
I've had many, many instances where someone asked me how long something would take, and I told them that there's really no good way to do what they're talking about so at least a month or two. It was only after this that I was told that they had already agreed to 2-3 weeks, so I'd better "figure out a way". But what if there is no way? It's not like 9 women can have a baby in 1 month, you know.
A new word for managers' vocabulary (Score:5, Insightful)
I've taken development teams down into the Valley of Death and out the other side. It can be done. But there are consequences, and you're kidding yourself if you think you can avoid them.
The first consequences is that you can only do this once. If you're smart, you hire smart people. They know when you are ordering them to jump into a pile of shit. And if you're smart, you hire craftsmen, and craftsmen have pride. They resent being told to do that. What that means is that if the second time you try it, you end up losing all the people who can find a job easily -- in other words your most valuable employees.
Another word that should be in managers' vocabularies is investment. Developers create assets that produce future revenue and expenses. You want programmers working as hard as they possibly can, but not simply to get the job done. To get the job done right, which means producing something that generatesw more revenue and less expense. When you focus on just getting the job done, you end up with something that barely breaks even. That's the minimal criteria for "not failing", not the maximum possible success.
That's why I hate questions that start with "How hard would it be..." because they focus on the present, not the future. It should be "I think we can make X dollars a year; how much would it cost to support this feature, and would the amortized development costs be justified by the net revenue given the other things we could put our efforts into?" It's not as pithy as "How hard would it be...", but it covers the things managers should think about: the future impacts on revenues and expenses, the opportunity costs of the road not taken.
Re:A new word for managers' vocabulary (Score:3, Interesting)
I don't think this is possible given U.S. corporate practices or the market for software. My day job talked about trying to shoot for long-term success, but of course they're still fighting short-term fires (layoff when a customer has a bad quarter, stage releases to get something barely working out the door, keep cutting test time, etc.) Don't know whether they were really going to do it and failed, or whether they were just telling the engineers what they wanted to hear.
Since neither yo
No such thing as a quick fix (Score:3, Informative)
Want some good (aka REAL) tips, check out Steve McConnel's book on Rapid Development [amazon.com] (Ignore the fact that it is produced by M$ press). This book is great, and if anyone is serious about software development they should read this book. And for the developers out there, please read his other book, Code Complete [amazon.com].
Fundamental problem with planning (Score:2, Interesting)
Because you are doing something new, you cannot predict in front how much time you need as you don't know the problems you will encounter and the additional requirements/features that pop up during development (this always happens in software or system development).
PS. I am talking about real innovation. Most real innovations are build upon existing ones. So this holds only is you maximize sharing or
Engineers survival kit. 3 solid tips. (Score:3, Informative)
If you want to continue to give your whole life to your comapny in the mistaken concept that you'll get recognition for it later then chances are you're still a naieve new grad. Experienced engineers know they have to train their managers.
After 25+ years of software development heere's what I learnt works best:
* Demand the necessary time to do good work, no matter what time problems that may cause others. Reason: You will actually need about the same time, no matter what quality concessions you make. Furthermore, your manager should have had involved you in his time-estimates for project planning. This is management 101. If he didn't then this is the only way you'll convince him to involve you next time.
* Don't ever agree to deliver low-quality product, regardless of other peoples deadlines. Reason: Non-techincal managers mistakenly believe that time can be saved by sacrificing quality. Actually the opposite is true. Low quality software takes more time overall. Furthermore, if you deliver crappy software, people will forever identify you as being a crappy engineer, regardless of any justifications you may have had at the time. If you're a crappy engineer you're like too many others and worth nothing.
* Don't work overtime unless you both want to and are being paid extra for it. Reason: Your employer is making significantly more money from your work than they are paying you. If they weren't, they wouldn't keep you there. Its basic business economics. They are not a charity and you deserve to be paid and treated just like any other professional. Furthermore, it does nobody any favors if you set urealistic norms and expectations. Yet another reason is that you are far more effective if you're not continually burned-out.
The BIG secret your company doesn't want you to know:
Nearly all deadlines are just artificial mechanisms created by management and designed solely to get free overtime/more productivity from the workforce. They usually have no relation to what delivery date was acutally agreed with the customer.