Essence of being a successful Development Manager?

The above question was sent to me the other day from a former colleague and friend. He was preparing a presentation for heads of product management and product development, and not being an engineering manager himself he asked for input on the subject of “Essence of of being a successful Development Manager”

I usually refer to a development manager as an engineering manager, as developing software is much more than simply developing the software itself. When you develop/design software today, you need to take all kind of operational aspects into account (


Anyway, so what’s required to be a successful engineering manager. Though question. And maybe not. One thing I’ve realized after working in software engineering for more than 20+ years (wow getting old), and have had a number of different managers, is that the single most important and an absolutely unquestionable qualification for any engineering manager is that they have a background in software engineering. That they actually have written code, tried to find a subtle bug in a multi-threaded application, that they’ve been through the process of reading thousands of lines of code to locate a memory leak (not using profilers). Have dealt with double-pointers (Macintosh handlers), cried at night because a data structure wouldn’t align at word-boundary – all that nitty-gritty stuff that makes us all sweat. I don’t purposely disqualify people that haven’t developed in any low-level programming languages like C and Assembler; however, I strongly believe that even if you’re of the automatic GC generation it still worth your while to understand and gain experience with fundamental aspects of the computer, like how memory operates.

Why is this so important, that an engineering manager actually knows how to write software? For same reasons that a lead of a bridge construction team is a bridge construction engineer, how else can he make critical decisions? Actually how can anyone be trusted to make decisions about any professional field, unless they got the t-shirt? How can any non-software engineer provide any assistance, help or guidance to the team unless he or she knows what it’s all about? I don’t know, and based on personal experience, they can’t!

There’s more to having software engineers running development teams than just being able to facilitate the process of developing the software. It’s also about understanding where in the process the team is, how far we are, and more important (sometimes) how much are we’re off course. Only people with engineering background can read another engineer, can understand where they are, and truly appreciate the work being done. And BTW engineers don’t really trust other professions, that’s just a fact. So lot’s of good reasons to why the single most important qualification of any engineering manager is that the manager in fact him- or herself is an engineer.

So a good engineering manager knows his stuff, knows how to write code, know how to design architecture, knows how to make a reasonable data model and knows how to execute. He can ask the right questions and provide the right technical answers and guidelines to his team, and he’s capable of writing code himself. Actually, any first level engineering manager should spend 25% of their time writing code. Way way better for the project than spending 25% of your time making MS Project plans, that doesn’t tell you anything anyway. Being in the code on a daily basis will tell you precisely where the project is and where it’s heading. If you’re too remote from the code you lose oversight! The project starts slipping, you’ll have delays and the team suffers, the company suffers, customers suffers and the engineering manager suffers – because he’s not a “real” engineering manager.

Able to say a resounding NO

This is actually very important qualification as well. We as engineers don’t like to say the “NO – it cannot be done”. Why is this? Personally I find it very hard to say NO. I feel that if I can’t do it, I somehow failed. It’s like a challenge, and engineers/nerds/geeks loves challenges, hence anything/everything is possible. And it probably is; however, not on a schedule.

So what most typically happens is that we say something like: “Well, it’s probably possible if we add additional resources and delay the deadline”. Nothing wrong with that, right? We don’t really say NO, and we take on the challenge. Wrong, it’s dead wrong. Reason being that the receiving party of your kind-of-NO isn’t an engineer, probably someone in the business, and here’s what they pick-up from your kind-of-NO statement: “Well, it’s ..noise.. possible ..more noise…”. See these people only pick up what the want to hear, everything else gets lost in the translation from engineering-lease to sales-lease.

If you’ve come to the conclusion that it’s impossible within the given framework (resources and time) then, to my knowledge, there’s only one approach that works – and that is to spell it out loud and clearly by starting your answer with the NO, and whatever comes after shouldn’t in any form or shape take the power out of the NO. The receiving party will most likely eye-ball you for a while, and then start the actual negotiation on how to accomplish it. But I tell, you’ll never get to that part if you don’t start out saying NO.

Actually, NO is probably the single most important weapon you have as an engineering manager when there’s a risk of feature creep.

Understands Requirements

The third, IMHO, important qualification is the ability to understand what the business is asking for, what’re the requirements, being able to speak with marketing, sales and product management to gather the necessary input needed to be able to understand what’s expected to be developed. Take that knowledge and turn around and turn it into something engineers understand and can build product based on.

This one, actually ties nicely in with the first qualification, as it requires deep technical understanding to discuss functional requirement with the field, and at the same time being able to envision how the product or a feature eventually could end up being coded. Also, allow the engineering manager to get a sense for what’s possible and in what time frame, without always have to disturb the development team asking for help.

#programming #software #management

Wizards in software are mostly uninspiring solutions to bad design

Here’s a thought maybe even a provoking one, as everyone seems to have reached at the conclusion that wizards in software are good. The general and agreed upon argument goes; that a wizard shields the underlying complexity of the software. That’s fine. However, the question quickly becomes for whom or why do you need to shield this complexity. For the user, mostly the casual user, as the assumption in software design for business applications seems to be that the non-casual user knows how to operate complex screens or at least have read the manual.

But why would a casual user need to use the same software as a power user? Or at least why and where do a power and casual user share the same area and functionality of a certain application? Wouldn’t it make more sense to build different screens targeting the primary user – being either casual or power user? Rather than trying to cram everything into one screen? And then after cramming everything into one screen for the power user, develop wizards to help the casual user?

I can think of one specific area where wizards do make sense mostly concerning installation, configuration and setup of applications. But that’s not really shielding functionality, that’s more semi-intelligent template generation.

It should trigger a warning if you’ve either designing an application and you’re thinking: “maybe we should implement a wizard to make it easier”. Warning, you’re heading down the path of providing an uninspiring solution to a bad design. Don’t go there. Stop and rethink your design and redesign so the application targets the primary audience and provide the level of functionality needed for that audience. Strip away unnecessary functionality, and stuff it somewhere else, and let the power user go seek it out if needed.

#programming #wizards

Methodologies, Better Software and Requirements


Methodologies are like patterns, best practices, recipes or how-to’s. They describe how to get from A to B. But none of them claims that it’ll lead to better software, whatever better software means. Actually, that’s not totally true – some of the newer methodologies got some interesting claims on the subject of providing quality wise better software.

When discussing better software most people thinks about the quality of the software, seldom does people consider whether or not the software does what it’s supposed to do. Probably more correct to say, that people don’t factor the functionality in as part of quality. Can be observed when discussing functionality and/or quality with users, they don’t qualify a missing feature as a quality issue, but as an enhancement – and so do we as software engineers.

Okay, so 2 different objectives when developing software: 1) develop the right product and 2) in the right quality. Right product means that the product does what the user expects it to do, contains the right features. Right quality means that it does the former, without trying to ruin your life in the process – by – say – continuously crashing, or by any other means makes it unnecessary complicated to get your task done – hit the [ANY KEY] (some users actually got confused and tried to locate this key – no kidding!)

Question becomes, can a methodology help you to build the right product in the right quality? Personally, I don’t think so. However, a methodology – actually any methodology – can be a good starting point for building appropriate structure into a new project. Existing methodologies can be a source of inspiration on how you could do it. It’s much like a food recipe, if you follow it 100 %, you get something that’s not quite like on the picture and it doesn’t really taste as good as it looks (on the picture in the cook book that is).

That’s all good, but how do we then built the right product, in the right quality and at the right time? The answer to this perpetual question, and it is really perpetual as it’s been tried answered in tons of articles over the last 30+ years, isn’t 42. Probably more like 42+ something.

The Requirements

This may seem bleeding obvious, and it really is bleeding obvious – but apparently it’s very hard to get right, otherwise, we wouldn’t have late projects, wrong applications or defunct products. The key to the 3 R’s is the 4th R, being the Requirements. Having the requirements sorted out allow you to built what’s expected, to provide more accurate estimates (not just guestimates, or wise ass guesses) and also allows you to construct the test cases needed to validate the software against the requirements. Pretty obvious – huh? Well, apparently not!


If requirements are so important, why not gather them all up front before even starting to code? Not a bad idea! And in essence that’s what the Waterfall methodology is all about. Phased development plan, with well defined processes and stages for moving from one phase to another. Widely adopted and used methodology until the late eighties. For the waterfall methodology to be successful you need to be dead sure you got all your requirements right in the initial phase of the project, if not – there’s a high probability you’ll be hosed when delivering, and users will go: “Dude, I still can’t find the <ANY KEY>” or worse (maybe) “Dude! This is what I asked for, but didn’t expect” (more on this particularly scenario later).

Lots of empirical research indicated that waterfall works fine for projects that’s either extremely expensive or, if done wrong, kills the end user. Either way, if you don’t get the stuff right you’ll either be prosecuted and go to jail or lose your business. Huge motivator for getting it right – right?

Lots of other empirical research showed that for software projects, the whole idea of understanding the problem domain upfront seemed impossible. Mostly due to the shorter life cycle of software products compared with their more expensive hardware ones. Also, the investment model is different for software products, as the majority of the costs are salary. For e.g. chip manufacturing there’s a huge initial investment prior to producing, which is building the manufacturing plant.

Post Waterfall

Gathering requirements is an extremely difficult task, mostly because most users when asked what they want go: “Dude, show me what you can do….” or “something like who knows, that can – you know – when you hit the – whatever key…” Sigh! Very hard.

It turns out that users really can’t relate to the majority of the means used to communicate the end result. However, what users can relate to is the end result – the product, but problem being that it’s hard to change the final result. Somebody then came up with the idea of iterative processes, which essentially breaks down the development cycle into mini cycles, that each have all the phases known from the waterfall methodology: requirement gathering, analyses, design, implementation and testing. But added an evaluation phase, where the users evaluate the newly developed functionality.

Over time more and more iterative methodologies have emerged, but they all originate from the idea of splitting the phases into smaller cycles and including the users to evaluate the result on an ongoing basis, until the product is ready.

Better Software

If better software is defined as the sum of RP + RT + RQ where RS is right product, RT is right time and RQ is right quality. And we agree that the requirements actually are a key driver for obtaining RP + RT + RQ, then I believe that newer methodologies (or at least all methodologies deriving from iterative ones) will provide better software.

This being said, then personally, I believe there’s a small issue with not knowing the requirements initially as it’ll be very hard to get an initial estimate to cover RT. There simply need to be an initial phase prior the iterative process called high-level requirement gathering. The product of this phase is essentially a rough blueprint/proposal that top level explains the purpose of the system.

This leads to: for RP + RT + RQ = True, requires R. Meaning that to deliver right product, at the right time in the right quality you need to understand the Requirements.
#requirements #programming #software #engineering