Qualities of a Good IT Manager

In my career, I have worked for and observed a wide range of managers. Some are great, some are less so. But, as I’ve made the progression into management over the last couple years, I have thought a lot about what makes a good manager in IT. Perhaps these apply to other fields, but IT is the one I have the most exposure to, so that is all I can speak of.

Accept the responsibility, share the credit

This first one deals mainly with how achievements and failures by the team as a whole are looked upon by those outside the team. It is a hard one for many managers.

If you and your team do well, a lot of times upper management will praise you. They may be completely unaware of the hard work that your team put in. Be sure to share the credit for the achievement with your team. One of the quickest ways to lose the respect of your team is the accept the credit for what they have done for yourself.

But, on the other hand, if something goes wrong with a project, the manager needs to accept the responsibility for the failure for themselves. Upper management never looks well upon a manager who blames problems on their team. And you’ll gain the respect of your team if you accept the responsibility (at least to those outside the team) for yourself.

Reprimand in private, praise in public

This next one deals with individual achievements or failings of someone on the team. If someone on your team really messes up, never reprimand him or her in front of the other team members, and certainly never in front of people from other teams. I’ve seen this done before and it’s the quickest way to lose my respect. If someone messes up, pull them aside and talk to them privately, where others cannot hear. Discuss what they did wrong, why it was wrong, and what they can do to do better in the future.

However, on the flip side, if someone does an outstanding job, praise him in front of the rest of the team. The team needs to know the hard work and achievement are rewarded. They’ll strive for this recognition themselves.

Know your stuff, but listen to your team

Within IT you have managers with strong IT backgrounds, such as those that use to be programmers themselves, and those without this background. In my experience, the best managers are those that have the background and really know their stuff. However, if a topic comes up that the manager is not familiar with, he or she must be willing to admit that they do not. I have know managers that try to pretend they have the depth that they do not. This is another quick way to lose the respect of your team.

But, as a manager, you have a team. And part of your responsibility is the hire good people. And, if you hire and pay for good people, you would be foolish not to listen to them when they are speaking from their own expertise. A manager must always be willing to listen to his or her people. There are times that you have to stick to your decisions, but you team must feel like they were at least given a voice. But, as often as not, someone on your team will have a better idea than you do. You must be willing to listen to them and have the humility to admit that they are right.

Hire and empower the right people

This is a big one, and I’m pretty sure I’m going to devote an entire post on how to hire the right people. As a manager, you are not doing everything yourself. Most of the time you cannot possibly do everything yourself. You must be able to delegate tasks and responsibilities to your team. And they only way you can do this and be successful is if you hire the right people.

But, just hiring them isn’t enough. After you have hired them, you must empower them. Be able to delegate responsibilities to them and trust that they are going to do a good job. By default, do not micromanage. I have had people on my team in the past that I have ended up having to micromanage, but they were definitely not the right people and should not have been on the team to begin with. The only way to stay sane in management is to be able to delegate to your team and trust them to do a terrific job.

Have the confidence to make the hard decisions

A big part of management is making the hard decisions. These are the decisions where the long term results are unclear and the wrong decision could potentially be disastrous. Collect all of the information you need. Determine if a decision needs to be made. If it needs to be made quickly, trust the input from your team and make the decision. A lot of times problems are made worse because decisions are not made in a timely manor.  These managers lack the confidence in their themselves and their team to make the decisions. If the decision ends up being wrong, have the guts to admit your mistake and move on.

Conclusion

Management is hard, and it can be very stressful. But if, as a manager, you would follow the basic principles I have outline above I’m confident that you and your team will be successful and you’ll win the respect of your team and your peers.

Advertisements

Software Project Estimation Part 9: Conclusion

In the previous posts I have discussed the process of software development so that we can get a good handle on what we are estimating.  I have discussed the cone of uncertainty so we can know how accurate our estimates should be.  And I have talked about four different estimation techniques: Expert Judgement, Count, Function Point Analysis, Story Points, and Decomposition.

So, you may ask, which estimation technique is the best?  And my answer would be, as in so many things, “it depends”.  If you are very early in the project, and have team members with a lot of experience in the environment and good historical knowledge of projects in the domain, Expert Judgement will be a good choice.  If the project will have components that are easily identifiable early in the process, then Count is good.  If you are doing a pure Agile project and your schedule can be a little more fluid, then Story Points will work for you.  If a detailed design has been completed, Decomposition is good.  My favorite estimation technique, though, is Function Point Analysis, which can be executed at any stage in the project.  But you must have a counter with experience in the technique.

The best plan, though, is to become very familiar with all of these techniques.  You can then have these tools in your back pocket that can be pulled out and used on any project, depending on the unique nature and needs of the individual project.

For more information on the subject, I highly recommend reading the book Software Estimation: Demystifying the Black Art by Steve McConnell.  This book does a good job of going into detail on each of these techniques and several more.

Thanks for joining me as I worked though this series.  This is a topic I’m passionate about.  I hope that reviewing these techniques has helped you out in your own projects.

Software Project Estimation Part 8: Decomposition

Decomposition is the estimation technique most software developers are familiar with.  Using this technique, you break the entire project into the individual components that are going to be impacted.  Within each component, you itemize the changes that have be be made.  You then estimate how long each of those changes will take to complete.  Add up the changes for a component and you have the estimate for the component.  Add up the components within the project, and you have the construction estimate for the entire project.

There are a couple of issues with this technique.  The first problem is that it requires a detailed level of design knowledge concerning the project to come up with an estimate.  If you are in the early stages of a project, you aren’t going to know all of the components that must be modified.  And if you don’t even know the components you certainly aren’t going to know the changes within the components.

The second issue is that you have to know the skill level of the person doing the work.  If you have a rock star developer doing the coding, then the estimate should be significantly different then if you have a new hire.  In order to put together this kind of estimate you need to know who is doing the work.

But, this level of estimate does have its place.  It just needs to be utilized late in the project, after technical design has been completed and you know who is going to be doing the development.

Software Project Estimation Part 7: Story Points

This post is part of my series on Software Project Estimation:

Story Point Estimation is the most popular form of estimation on projects using Agile methodologies. Using this technique, you begin with all of the User Stories, or Use Cases, for the project. Then a number is assigned to each of those stories to indicate their relative size. Normally, this number is from the Fibonacci sequence (1, 2, 3, 5, 8, 13, etc.) or a power of 2 (2, 4, 6, 8, 16, etc.).

When the numbers are first assigned, they are not given a unit of measure. That is, a User Story that is assigned a “2” does not necessarily take 2 hours or 2 days to complete. The numbers are assigned based on the estimated size relationship between the User Stories. That is, if User Story 1 is assigned a “2”, and the team decides that User Story 2 is around 50% larger that User Story 1, User Story 2 will be assigned a “3”.

Once all of the User Stories have been assigned a number, the team will decide what they thing their starting velocity will be. They may decide that they can complete work on 20 Story Points per 2 week iteration. The User Stories to be completed during the first iteration will be determined based on this Velocity. Project Management can also use this velocity to project when the entire project will be completed.

After each iteration, the actual velocity will be computed to determine if the number of Story Points per iteration needs to be adjusted up or down. Based on this adjusted velocity, management can determine if they need to push out the end date of the project or remove User Stories from the scope.

Story Points is a great estimation technique to use in Agile development where you aren’t expect an precise estimate.  It gives you a tool to measure how the work is progressing and to project when the work will be complete.

What’s New?

Emma and Caleb

It’s been way too long since I have posted updates to this site.  So, what’s new??

Well, for one thing there is a new member of the Peters household.  Caleb Reed Peters was born on April 18th.  The “big kids” are very excited about their little brother.  But, as you can imagine, things are pretty crazy lately.  So, not quite so much time for blog posts.  The above picture is Emma holding her new baby brother.  For more baby pictures, head on over to our family blog.

And work has been pretty busy as well.  Never mind the fact that Hertz announced that they were going to acquire us.  Then, only a week later Avis announced that they would pay even more.  Day to day work hasn’t really changed at all since then, it’s all business as usual.  But I have been in the middle of several big projects that have been keeping me very busy.

So, things are crazy right now, but more blog posts are coming.  I’m working on at least one more post in my Software Estimation series, and I have posts started on several other subjects.

Outsourced

Last night I was sure that FlashForward was starting back.  So, after a long day at work and after getting the kids down to bed, I crashed on the couch ready to watch.  But it was not on my TiVo.   Come to find out, we have a couple more weeks before it starts again.

So I found myself browsing Netflix’s Watch Instantly library looking for something to watch.  Outsourced caught my eye.  Having worked in the IT industry for a long time, I have a lot of friends and coworkers from India.

Outsourced tells the story of Todd Anderson, a call center manager whose job gets outsourced to a call center in India.  He is then sent to India to train his replacement and help improve the call center there.

One of the most memorable scenes shows him trying to explain cow branding to the call center workers, in an effort to explain some of the products they are selling.  He’s trying so hard to teach them about Americans so they can talk effectively to Americans on the phone.  One of the workers looks at him and says, “You really need to learn about India.”

The rest of the movie shows him learning more about India, their religion, and culture.  I was struck by the fact that I have worked with Indians for so long, but I also have learned very little about their country.

It was a very funny and eye-opening movie.  I would recommend it to anyone that also works with people from India.

Software Project Estimation Part 6: Function Point Analysis

This post is part of my series on Software Project Estimation:

Function Point Analysis is one of the estimation techniques I have been most excited about over the past few years.  It’s actually a specific implementation of the “Count” methodology that I talked about prevoiusly.  But, I figured it was important enough to give it it’s own post.

In Function Point Analysis you count the number of Function Points in a project.  To get there, you first have draw a boundary representing the scope of your project.  You then make an inventory of all of the interfaces (data in motion) and files (data at rest) associated with the project.

There are 2 different types of files that have to be identified:

  • Internal Logical File (ILF): A file whose data is created and maintained by this application.
  • External Interface File (EIF): A file whose data is referenced by this application, but not maintained by it.

For each one of the file types you have to count the number of record element types (tables) and data element types (columns within the tables).  Based on these counts, each file is assigned a number of Function Points.  The important thing with these files is to keep in mind that they might not actually be a database or a file.  They could be something like another system that is interfaced with.

There are 3 different types of iterfaces that have to be identified:

  • External Inputs (EI): Data coming into the system from outside the system.  An example would be a user’s login form.
  • External Outputs (EO): Data coming out of the system from inside the system. An example would be a report.
  • External Inquiries (EQ): An interface where some data comes in which causing processing and then some data coming out.  An example would be a search form.

For each of these interfaces, you have to identify the number of record file types that are interfaced with and data element types that are carried along the interface.  Based on those counts, each interface is assigned a number of Function Points.

Once you have identified the interfaces and files and assigned a number of Function Points to each, you can add up those counts and come up with your Unadjusted Function Point count.

The Global System Characteristics can then be used to adjust this Function Point Count.  The Global System Characteristics are attributes used to assess the complexity of an application.  Once you assign a rating to each characteristic, you come up with an adjustment factor.  It may be something like 1.1.  You then muliply your Unadjusted Function Point Count by this adjustment factor to get your Adjusted Function Point Count.

At this point you just have a number which is pretty meaningless on its own.  However, industry standards exist showing, on average, how long it takes application development teams to complete projects of different Function Point counts.  In my experience doing .Net projects, I know that it takes about 15 hours per Function Point for coding and unit testing.

This will give you the hours for development.  The percentages assigned to each phase of the project can then be used to determine how long the entire project will take.

It’s very easy to learn the basics of counting Function Points.  Becoming an expert, however, takes lots of study and practice.  If you give the same project requirements to two different expert counters, their counts will come out almost identical.  This makes Function Point Analysis a very useful methodology for estimating the size of a project.