What is More Important? Time or Quality?

I came across a post that raised a few very good questions about the software business, so I thought I would respond.

• How partial can the initial result be and still matter?
• Partial in features or partial in quality?
• Is a later corrective delivery a separate, on-time delivery, or a completion of the initial delivery, thereby making it late?

The underlying question here is how do you make the decision when you can’t deliver on scope, quality, and timeline, how do you choose what to sacrifice? The original author makes a good analogy:

If you’re running for a plane and lose a shoe. Better to make the plane and buy new shoes at the other end, right?

And of course, the counter point:

What happens when the client you were going to visit by plane is on the plane, sitting next to you?

To be consistent with the focus of this blog, I think there are a few rules that apply here to software development teams:

1. Know your users. What will your users accept? If this is a critical, life or death piece of software, quality probably can’t suffer but timelines are allowed to move. If it is an business process automation application, then maybe quality can slip since the ship date is critical.
2. Use your Product Manager. I made a previous post about the value of product management (link), and this is another benefit. Usually, product management owns the customer base and profit / loss accountability. (In your organization, this could be sales, marketing, or a business unit GM. In those cases, target them with this advice). At the end of the day, your team is not held accountable for P & L. Your team is responsible for fulfilling requirements provided by product management. You are not directly tied to the customer or the sales cycle (yes, I know this is slightly different in small companies, but realize that the roles are there, you are just wearing different hats). Let the product manager determine which aspect of the project to sacrifice.
3. Use your best judgment. In the event that you are left to make the decision, go with your experience. If you were the user, what would you prefer? Could you postpone a feature? Could you delay part of the product? Someone has to make a choice, you just need to accept that no choice is going to be popular. Everyone will want all features with all quality on time. Your job is to get past the emotion, and recognize that it just isn’t going to happen this time, so it’s time to make a mature, rational decision about how to proceed. The inevitable “how did we get here” question will certainly come up, so you need to be prepared for it. Remember, history is a great instructor for the future, but it can’t be changed regardless of how much you talk about it.

These are decisions that come across my desk all the time. As a general rule, I try to stick to rules #1 and 2, but in the event I need to decide, I do so. Trust me on this one, indecision is far more costly than the wrong decision. I’ve made a bunch of decisions about projects and scope. Some were right, some were wrong, and some were very, very wrong. Bad decisions happen, the trick is to manage past them, not to let them define you.

The full post can be found here: Link.

Technorati : Development Management, Management, Product Management, Program Management, Software Development Lifecycle, Software Management

As usual, Joel is Right on Point

Joel Spolsky is an incredibly interesting author. He’s written a few books, posts regularly on his blog, and at the same time runs a successful software company. You can search through his blog and see some of his other postings on software management and development, his process and theories behind hiring summer interns, but I recently came across what I think is his best idea yet: The FogCreek MBA program. His premise is that to be ready to run a software company, an MBA doesn’t do you any justice, but he is planning a three year crash course for recent graduates that at the end should prepare them for anything the world of software has to throw at them.

You can read all about the FogCreek MBA program it here. Joel also posted a recommended reading list for this program that can be found here.

Technorati : Development Management, Joel Spolsky, Management, Reading, Recruiting, Software, Software Development, Software Management

How to Hire Talent

I may be in the software industry, but this is a problem that affects every manager in every field. How do you recruit and hire the best talent? There are the general cliche's like "Hire people smarter than you" or "Hire someone you could work for," but these don't actually give any information you could use.

Everyone has their own process for hiring and I've been through several as both a candidate and an employer. The best tip that I can offer for how to run an interview is that the candidate should meet with several people, and all on the same day. This makes it a one-stop shop for the candidate, and allows the company to react quickly if they decide to move ahead with an offer. I'll make a future post on my idea of a recruiting / interview process.

Anyone who's ever given an interview should know that they are walking into the interview preparing to answer one question when they're finished: "Should the company hire this candidate?" The question sounds fairly easy to answer, but the process to get there is complex, and sometimes requires a crash course in psychology 101. I've compiled some tips below that I try to follow with each interview I give.

First, let me put my interviewing frequency in context. I am one of the key interviewers for my company, usually giving 5 – 10 interviews / week, ranging in candidates like test engineers, software engineers, software architects, project managers, program managers, and product managers. While a typical interview with me lasts for 45 minutes, I probably have 2 – 3 hours worth of interview material.

The biggest struggle that I see, especially in first time managers, is the ability to recognize talent. Senior people are always easy to hire; they know their area of expertise, they pass all of the technical interviews, they have the experience of several software projects, and they are mature enough to give the expected answers during the interview. For them, it just comes down to personality fit and they either mesh with your team or they don't.

It's the diamond in the rough that seems to be the most difficult to identify. And these people are the most critical to your project; the 'B' players; the group who makes up 70 – 80% of your team; the group who'd you love to see a few grow into 'A' players. So how do you sort out the candidates with potential from the ones who are just repeating what they memorized in the latest programming book they read. The basic knowledge is usually the same. The candidates most all be competent in your technology of choice, they must get along with your team, and they must fit your budget range. Now the hard part, once you've identified a few candidates that fit these basic criteria, how do you know who will really succeed? Who will improve your team? Who will exceed your expectations?

1. Evaluate Problem Solving. Try and find out how the candidate works through a problem that they don't know the answer. How do you weigh a 747? Why are manhole covers round? How many cars are there in New York City? Questions like this are not designed to reach the answer, but to see how the candidate thinks. How do they respond to help? Do they ask questions? Do they break down the question logically or randomly? These are some key indicators for imaging the candidate 6 months down the road when you have to develop a solution that no one on the team has ever seen before. Maybe an obscure defect that you can't reproduce These situations will inevitably come up, and you want your team best prepared to handle the unknown, and be able to breakdown a problem logically.
2. Hire Smart People. When in doubt, hire based on intelligence. Generally speaking, intelligence has a direct correlation to ability, adaptability, and efficiency. I'm not saying this is a black and white issue, but when you can't decide between a few candidates, the smarter candidates have a higher probability of success
3. Admitting Ignorance. Throw out some questions that the candidate has no way to answer. Don't throw out a brain teaser for this one, but throw out something extremely technical or deep, or on a technology just outside of their knowledge level. You already know that they don't know the answer, the test is whether they'll admit it, try to dance around it, or engage you in a conversation to get to the answer. As a rule, anyone who tries to give me a b.s. answer, I immediately won't hire. Anyone who can admit they don't know something when they are engaged in an interview is someone with the maturity you are looking for. Professional maturity is a great indicator for future success, knowledge transfer, and constant growth.
4. Communication Counts. Try to get the candidate to explain something complex to you. Did you understand it? Was the information presently structurally or randomly? How long did he consider his answer? Was he comfortable launching into a diatribe? At the end of the day, communication is key for any team, and yours is not any different. As long as someone can clearly express their status, position, opinion, thoughts, really anything, then your chances for team success have just gone up exponentially.
5. Career Goals are Good. Senior talent generally know what they are looking for, and have usually already achieved some career goals. Entry level people probably have no idea what they're looking for, but just have some skills out of school and are looking to learn. Again, it's the middle group who really have something to prove. You want to make sure that your candidate has some goals, and he's on the path to reach them. The actual goals aren't very important, it is that there is a career plan being executed. It shows forethought, direction, and purpose. The one exception to this rule is if the candidate's career goals don't map to your field. For example, if someone came in and told me their ultimate goal was to save up some money and move to Outer Mongolia, and they are 4 months away, I probably wouldn't hire them. Outside of that, you're in good shape.

I'm sure that there are other beneficial characteristics to look for, but these are a few that I use. Anyone who'd like to post more tips, please comment this post. And remember, interviews can never determine if someone will be a successful candidate or not. Interviews can only increase your probability of selecting a good candidate, and all you are trying to do as the hiring manager is to hire the candidate with the highest likelihood of succeeding.

Here are some other links around the web that I've found as good reading.

• Guy posted a reader's email – Link
• About.com article – Link

This will be a future post, but here are some postings about how to retain talent once you hire them.

• Why Developers Leave – Link
• Harvard Business School on Lost Motivation – Link

Technorati : Development Management, Management, Program Management, Recruiting, Software Development, Software Management

Upcoming Posts

I thought it might be nice to post a list of the initial topics I plan to post on. I'll update this post with links as I post the content

In no particular order

• The Value of Product Management
• How to Negotiate Scope
• SDLC in the Real World
• How to Hire Talent
• How to Grow your Employees
• The Value of Automated Testing
• Strategies of Software Teams: New Development vs. Maintenance Development
• Strategies of Software Teams: How to transition to a New Technology Platform
• Does anyone really want to be a CTO?

I'm open to any input for other topic suggestions. Like I said aboe, I'll be posting in a fairly random order, but I'll be trying to post at least one topic a week.

---

Technorati Tags: Program Management, Management, Software Development, Development Management, Recruiting

SDLC in the Real World

SDLC – System Development Life Cycle (SDLC) – a methodology used to develop, maintain, and replace information systems.

I’ve run into more than a few project managers, developers, testers, and product managers that have caught the SDLC buzz word fever. They’ve either latched onto the newest, latest, coolest, hippest methodology, or they read in a book that you can’t succeed without one, or (most likely) their manager said that they need to have one. However they get to this state of mind, they usually follow the same course of action.

1. Go to bookstore and buy 1 book
2. Read at least the first few chapters of said book. Some even make it all the way through
3. Go to their next team meeting, and declare that they are implementing an SDLC. No one else can ask questions or offer input, because the book says it will work exactly as its written
4. Meetings are called with subjects that mysteriously match the book’s chapter headings
5. The rest of the team has no idea what is going on, but they are following their enlightened SDLC leader blindly. It still seems like they’re writing and testing code, so at a granular level, most everything seems to be the same
   …… The Project Continues …..
6. Utter chaos ensues, the product is late, the quality suffers, and it is deemed that SDLC’s are worthless
7. Team reverts to prior process, and ships with previous efficiency, tracking, quality issues, and date slips. While that may sound bad, they still ship and shipping software is a key test of success or failure in commercial software.

So where does the value from using a methodology come from? For me, it all comes down to one thing: change management. If there was only one programmer, and he knew the customers, wrote the requirements, wrote the code, tested the code, fixed the code so it was bug free, packaged the product, and shipped it, there would be no need for an SDLC. OK, now back to the real world. Requirements change. Team members quit. Testers miss bugs. Developers write more bugs when they fix the bugs QA already found. Customers can’t articulate what they want. The list goes on and on. This is where having a defined methodology helps. It gets your entire team on one page. When someone falters, everyone knows, and everyone understands the impact of what that means and can adapt. It is not a blame issue, but one of good communication. When you have a team driving toward a common goal, working in a common way, helping each other succeed, then you have a team with a shared vision. A team with a shared vision can do amazing things. They can have requirements change at the last minute, and everyone knows where to help, who is impacted, and how to react. The same scenario goes into effect when someone on your team leaves. Normally, the team is lost for a bit. Some piece of critical information or a critical process lived only in that person’s head, and now that they are gone, the team is lost. Again, common steps, common process, common knowledge, shared vision, and teamwork. All of this leads a team to be adaptable to change, and having a team that can adapt and manage change, rather than letting the changes manage them is key to large scale success in software.

Having a team that can adapt and manage change, rather than letting the changes manage them is key to large scale success in software

Then how does all of this apply to me? I’ve been through a handful of projects, and I’ve learned the most important lesson about SDLC: No SDLC is perfect. All of those books look really good in print, but they are all based on best case scenarios and case studies. The key is to learn as much as possible, study many methodologies, and adapt a methodology to your team. I have a personal methodology that I usually try to follow, with parts taken from a few different communities, but with each new team and each new project, the process is adapted. The value of a process is to help organize your team, not to organize your team according to the process. There is always pain, resistance, and adaptation when implementing change, but it should be for the betterment of the team, not because you are trying to fit the team to something from a book.

This is the general methodology that I have used successfully in the past. It is a combination of a traditional waterfall development cycle, but focuses on short term, iterative deliverables during the development cycle. These are similar in principal to sprints from the SCRUM methodology (my personal term is protocycles), but with a different up front planning process. There are also aspects of XP and MSF woven throughout, but I won’t get into that many details in this post.

1. Establish high level requirements. These need to be detailed enough that the technical design can be built from these requirements. This deliverable essentially drives the vision for the release. A 3 release roadmap is also required, so that the development team can understand what the future product plans are, with as much clarity as possible.
2. Define the detailed requirements. This task takes the high level release requirements, and drills down to a sufficient level of detail required for the development team. As each detailed requirement document is completed, it is sent for peer review and acceptance by a representative from development, quality assurance, architecture, product management, and development management. This task happens in parallel with the technical design.
3. Define the technical design (Architecture). Based on the high level requirements, establish a product architecture taking all three releases requirements into account. The architecture deliverables for version 1 should be at sufficient detail for the development team to use, and mock architectures should be vetted in order to validate feasibility for the version 2 and version 3 requirements. This task happens in parallel with defining the detailed requirements.
4. Product Development. The development team executes the detailed requirements and the technical architecture. This process is somewhat agile in nature, since features can be started once the specification for that component is complete, rather than waiting on an entire requirements package.
5. Quality Assurance. The QA team validates the software created by the development team meets the defined requirements. Test cases are created for each completed requirements document, following its peer review acceptance. For a test engineer, the requirements should read like a contract, validating that development met their end of the contract. As is typical during a development cycle, requirements will change. These will be handled as requirements addendums or modifications.
6. Release to Manufacturing. This is the final step in the process. Once a product is ready to be delivered to market, this step represents the processes preparing for general availability. Depending on the organization, this could include source code escrow, marketing coordination, gold CD creation, retail packaging, etc… The timing for this process is generally organizationally dependent.

There it is, how to ship software in 250 words or less. I’m not trying to demean what any of us do, but at the end of the day, it all sounds so simple, doesn’t it? Define what you want, research it, document it, code it, test it, give it to people who will pay you for it.

Technorati : Development Management, Management, Methodology, Program Management, SDLC, Software, Software Development, Software Development Lifecycle, Software Management

More Reading for Development Managers

I've read Jack and Freakonomics. Not a bad list. I'll add to this in the near future with my pics.

Read

Good Reading for Development Managers

I try to spend a few hours a week reading articles on the web. To me, the word "article" has a loose definition, but basically anything someone has taken time to put together that adds knowledge or value, I'll read if I can stumble across it. Here are this week's selections:

• All Code Has Bugs – Link – Full Article
• Google Hiring Strategy – Link
• CEO Reading List – Link
• Art of Recruiting – Part 1, Part 2

Good Reading for Software Architects

My background is in software development and architecture, so here are some good blogs that I try to read regularly.

• Martin Fowler – Enterprise Architecture
• Don Box – Windows Communication Framework Product Team
• Architect Linkblogs
• Tim Berners-Lee – Father of World Wide Web

Defect Count is a Constant

One of the most inspirational people in software that I've come across is Jim McCarthy. I had the privledge of seeing him give a presentation, and he had a few quotes that made a lot of sense. The one that really stood out to me was

"Defect count is a constant."

This became very clear to me last week, as my team went through a Bug Bash. In 48 hours, we closed out over 400 defects, but the number of defects open with development stayed almost level. I could go into the details of the defects, such as priority, severity, category, and so on, and we did make some substantial progress, moving our average defect severity from critical to medium, but at the end of the day, all software has problems bugs defects. And this was one of the most difficult lessons I've ever had to learn:

Shipping software is an act of reality, not a pursuit of perfection.

This lesson was extermely difficult since I come from a development background, I always want my software to be perfect, to be bug-free. Unfortunately, the larger the project, the less control that you have over it. As a manager, your job is about steering the ship, and you have to trust that your staff is all rowing in the same direction. There are things you can do to get more involved with the low level tasks, and I recommend that you do, but at the end of the day, you can't spend 40+ hours per week with each member of your team (Trust me on the math, after 4 employees, this model doesn't scale). In the world of software management, you need to accept a product that is less than perfect, and understand what is critical to ship and what is not. I'm not saying that you should ship a garbage product, but at the end of the day, if a new feature isn't ready, you can probably cut it, ship the release, and your world will not come to an end. Note the exception list here is long, like if the feature is contractually committed, or highly marketed, or the center piece of your release, etc…

I added some links at the bottom for more informaiton about Jim McCarthy for your reading pleasure.

Jim McCarthy – I highly recommend that anyone involved with shipping software, expecially in any leadership position, should check out Jim's book and video if you can get your hands on it.

• Book
• Video / Signed Book
• Reprint of the 21 Rules – Link

The Value of Product Management

When I started out, I thought that it was critically important for each developer to know all the ins and outs of the end user. If you are writing a financial application, the developer should be able to pass for an entry level accountant. Well, then I got into healthcare, and I realized that it’s impossible for developers to know anything close to what an end user knows. This is when I saw the light on the value of product management.

A great product manager will perform three tasks:

1. Drive a product’s strategic road map. This means that the product manager understands the end user’s needs and understands the competitive marketplace. Understands which features are competitive disadvantages, market differentiators, visionary features, and customer satisfaction issues. The road map will align these features by priority and usually group them into 3 releases. A near-term, tactical release, a longer term strategic release, and a long term visionary release. Dates on these releases are irrelevant, since the road map defines what needs to be done, and then the timeline can be wrapped around that.
2. Cut features from a release scope. Inevitably, customers, marketing, and product management will want more features than the development team can support in a given time frame. It falls to the product manager to work with the program manager and reduce the scope list (The entire scope planning process is another topic for another day). The product manager must balance the needs of sales, marketing, existing customers, and new customers to prioritize the list and make some tough decisions. A good product manager understands and accepts this. A tell-tale sign of a poor or inexperienced product manager is one who will kick and scream to make it all fit into the scope, rather than accept the constraints of reality.
3. Understand the customer’s business. This is the most critical skill above anything else. A great product manager truly understands their customer. Usually, this means that they came out of the field that your product is now servicing. Maybe they were an account if you are developing accounting software, or a nurse if you are developing hospital software. This allows the product manager to converse with the customer in their vernacular, build a repore, and gain insight to new developments in the industry. The other benefit is that they become a key resource for the development team. The development team will not understand all of the intricacies of a particular business function, but the product manager should. And if they don’t, they’ve built relationships with key customers that they can contact to get the exact answer. This allows your team to correct an issue in the design phase, rather than waiting until it is in the hands of customers, and is 10 times more costly to repair.

The key takeaway for anyone in development is that product managers are the ones responsible for the domain expertise, and the rest of the team should leverage and benefit from that.

Technorati : Development Management, Domain Expertise, Management, Methodology, Product Management, Program Management, SDLC, Software Development Lifecycle, Software Management