Skip to main content

The Impossible Deadline

If you've been in the game long enough, you get informed by upper management of a grand promise due in just a little over a month.  Something like rewriting an entire suite of applications in a new technology in 6 weeks.  That's what I'm facing at the moment.  The promise has been made, so after you pick your jaw up off the floor, what can you do?

Do What You Can

The number one thing that causes your gut to tie itself in knots is all the stuff you know you don't know.  The unknown things linger in your mind like a cancer undermining anything possible.  Norman Vincent Peale is credited with the quote "Shoot for the moon. Even if you miss, you'll land among the stars."  Aside from the bad astrophysics, that sentiment is what you need to start with.  Be aware of the deadline, but don't let it consume you.  It's too easy to spend a lot of energy fretting over it that is better spent on just getting stuff done.

Get the Griping Out of the Way

It's natural to gripe and push back when you receive what you feel is an unreasonable demand.  It's part of the process to see how hard dates are, what is most important to get done.  If the dates aren't changing, the best thing you can do is to roll up your sleeves and get to work.
  • Plan enough to know what you need to do, but no more
  • Deploy often to course correct before you go too far down the wrong trail
  • Get the product owner involved so they can see your progress and answer your questions
If you are in an environment where continuous deployment is already in place, then the only thing you really need to worry about is getting the product owner in front of the app and using it often.

Lean on Institutional Knowledge

This isn't the time to do something new and shiny.  If your company has experience with a particular architecture, then you can lean on others to help you get set up as soon as possible.  They can also help you get unstuck quickly.  Just as importantly, if you need to surge your team with more folks, you aren't spending time getting the new folks up to speed with how things are put together.  You'll still have to train them on the domain knowledge, but the fewer new things to learn the better.

Test Early and Test Often

The sooner you fail the sooner you can get over it.  When you apply a little scientific method to your software process, it's amazing how well things can fall into place.  That's how Test Driven Development (TDD) works:
  • Prove your code doesn't do what you need it to do
  • Make the changes to fix it
  • Clean up after yourself
The last step is where people tend to fail.  They get caught up in the deadline and think we'll get to it later.  However, the cleanup is what helps you later on so that you aren't adding bailing wire and duct tape to hold your project together.  You have nicely fitted joints with a minimal amount of glue.  Things work better because they are designed better.

Sometimes You can Succeed

Once you get the negative energy out of your team, you can focus.  When you can focus, you can fix things quickly and move on.  When your customer is in the loop and engaged, they can help you reprioritize on the fly and they will have something they can use by the proposed date.  You'll probably have a lot more work to do, but the customer is happy and they can use the new app.

For the manager who made the promise: reward your team when they make good on your promises.  They definitely deserve it.  And maybe don't do that too often or you'll burn your team out.

Comments

  1. I used to have a boss who thought, because he was so computer-ignorant, that I could simply press a button and fulfill promises he'd made to his overlords. Sometimes I would have to tell him, "You lied, didn't you?"

    Not that I would drag my feet or fail to try to meet the deadline, but I felt that if someone was going to be wringing their hands, he could take care of that aspect while I devoted my energy to fulfilling his "request."

    His "attaboys" were sometimes slower-coming than he'd have liked, but through the process he came to learn that spreadsheets didn't design themselves, dBase apps didn't write themselves, and databases didn't populate themselves.

    ReplyDelete

Post a Comment

Popular posts from this blog

Release 1 of D-haven.org's BibleUtilities

I'm one of a small team that is maintaining our church's web site.  The site has audio, transcripts, devotionals, etc. to help you with your Bible study.  As you can imagine, as time flies and different teams maintain the data, we had a big data problem (not "big data", just a large problem with data) on our hands. One of the things we needed to do was to scrape our transcripts to find all the scripture references in the text.  That's easier said than done since the rules for writing a Bible reference is a bit all over the place.  Add to that multiple ways to abbreviate the books of the Bible, and we've got a non-trivial problem. Bible Utilities The Bible parsing code lived as part of the church's source code until one day when a young Norwegian college student needed help with the same problem.  I helped him out initially with the source code, but since this is a common enough problem I made it an official Nuget package: DHaven.BibleUtilities .  Yo...

Release 1 of DHaven's MVVM micro-framework

I'll be honest, there's a lot of MVVM frameworks out there, all promising to be the bees knees, light weight, etc.  One of the common threads between all of them is the insistence on using their brand of dependency injection to do the job.  There's good reasons to use dependency injection when you have a big enough project, and there's also a lot of good reasons not to use dependency injection for small utility projects. MVVM In a Nutshell Model-View-View Model isn't a new pattern, and there's a couple flavors out there.  The basic pattern works like this: Model -- the representation of application data with bind-able properties. ViewModel -- a layer with a bind-able Model property that handles view specific logic View -- the user control or window that is shown to the user that binds directly to the ViewModel and Model. The two flavors are "View First" and "Model First".  View First MVVM has the view layer reference other view lay...