It’s pretty much an open secret that in software development, asinine (and sometimes completely outrageous) deadlines, like estimates, are a way of life. The comic below shows what is–sadly–a typical representation of your average private sector software engineer.
That being said, it should come as no surprise that everybody has advice on how to try and combat the problem. From TechRepublic‘s 10 tips for meeting IT project deadlines to the utilization of agile software methodologies (see Deadlines in Agile by Stephan Kristiansen). Besides the usual suspects of scope creep, inept employees and managers, and micromanagement from both up top and from the customer. But for the most part, it’s typically managers that cause the most issues, sometimes through no fault of their own (for instance, if the company is riding on the release of a product, it’s either get it done or everyone is out of a job, and us developers don’t get golden parachutes).
A typical communication flow, ideally, would look like below. The bold red arrows represent directives, requirements, and specifications for the project (e.g., deadlines). The thinner black lines represent feedback. This is then processed and sent back down through the bold red arrows.
This is what it looks like in real life, at least from my perspective based on my experiences.
The thickest red lines are the same before. The thinner (but still thick, cause I like ’em thicc) red lines represent pressure, chastising, or other negative reactions. Notice that there is no feedback loop, only a one way path. This phenomenon is called shit rolls downhill. It is a common trope among any team that develops a product.
Some may argue that the idea is to get a product out the door before a competitor eats your lunch. While I agree with that, it can also be argued that getting a quality product out the door that stands apart from your competitors is just as important. To achieve this balance between speed of delivery and quality. Always refer back to the Good/Cheap/Fast paradigm:
I can appreciate that people up top have a vision. I, and many other developers like me, want that vision to become a reality because we share it, too (in most cases; I’m not naive to the fact that some of us just want a paycheck). But reality can be disappointing, and because we live in that reality management has to be open to the fact that some things just cannot be helped. It’s fine you want a deadline, but you have to be realistic about it.
But they try to get around this.
Next time, we’ll examine the Good/Cheap/Fast paradigm and the Mythical Man Month and how wily managers try to cheat the system.
Love ’em or hate ’em, estimates are a manager’s best friend and an engineer’s (developer/producer/whipping post) nightmare.
And they’re not going anywhere.
Reading the comment section on Hacker News today on the article Dear Agile, I’m Tired of Pretending by Charles Lambdin when the subject on estimations came up. Specifically, this comment by bougiefever:
There are two distinct statuses that a software developer will be looked upon by those outside of their respective realm within an organization: as wizards that can turn out miraculous, spectacular(?) software, or as insufferable buffoons who seem to forget that in some cases people’s lives are in their hands and yet they still manage to drop the ball.
This is why I hate it when the upper echelon of my current employer call me “the man”–this placing of me on a pedestal is dangerous and sets a very bad precedent of me being a 24×7 miracle worker. I’m not the Jesus of software engineering, folks.
With estimates, in response to xwdv, while you, the programmer, may reach a mutual agreement with the individual or group requesting the estimate that it is in no way, shape, or form, a concrete definite obligation that it’s going to fall within that time frame, that agreement is moot when they go and construct it as a promise to the next party, whether it be upper management, the customer, or your own mother. And this has led to some small uprisings in the software development community, such as the #NoEstimates movement. From the article Estimates? We Don’t Need No Stinking Estimates! by Scott Rosenberg:
Non-engineers need to understand that software development is not an exact science; a lot of it involves trial-and-error. When the stakes are high, we need time to ensure that everything is copacetic. I know this advice is going to fall on deaf ears no matter how many times I try to teach management and others about how this industry works, but I know you, dear reader, will agree. In any case, perhaps this is a case for business coaches to start teaching their clients about software estimation and project management.
Whatever the case, estimations are not going anywhere, period. Otherwise, you’ll get pie-in-the-sky vaporware that, if it ever does come out, fails to live up to its expectations (“You spent X [months/years] on it! Why does it suck!”) and becomes yet another argument for either waterfall estimation or agile burndown charts (Duke Nukem Forever anyone?). The lack of estimations is merely cannon fodder for management to rubber stamp you as incompetent and find some other schmuck to make that promise. Worse yet, when that check bounces, you’ll still bear the majority brunt of the blow back.
If that’s the case, you might as well project something insane and walk it back. Hey, under-promise and over-deliver, right?
Visual Basic may not be getting much love these days, but its functionality is still there. Mads Torgersen says that the ongoing strategy for VB, as of 2017, is to “do everything necessary to keep it a first class citizen of the .NET ecosystem” by focusing “innovation on the core scenarios and domains where VB is popular.” It is still being actively developed, used, and implemented.
The point is, a language’s popularity should not determine its usefulness. Michael Born said it best in his article Yes, CF is “Unpopular”. No, I don’t care.
We really need to stop with these asinine sunset articles and gloom-and-doom rants on programming languages. More importantly, we need to stop treating them as fads, religions, or special memberships to the cool kids clubs.
He then proceeds to list the following fallacies:
- Nirvana (perfect-solution)
- Appeal to authority (argument from authority, argumentum ad verecundiam)
- Historian’s fallacy
- Misleading vividness
- Survivorship bias
Let’s take a look at what I feel is the most common fallacy we as software engineers (or any professional, really) faces constantly: Appeal to authority.
This can be a bit problematic when you have multiple people vying for a shred of authority in their role. I worked at a location once where everybody around me nitpicked every line of code I emitted because it didn’t follow their ideas. When challenged, they would fall back on either “This is the way he [architect] taught us to do it” or “This is a best practice” or the implied “I’m older than you and therefore smarter than you so you should bow down to me.”
I think programmers are now afraid of taking the risk of applying what they know and have experienced and instead are falling back on the results of others. Let’s say that you write a method that causes a memory leak. When you’re called out onto the carpet, you explain that the way in which you constructed the code was based on the directed opinion and approval of the project architect. Even though you noticed the potential for a leak, you ignored it because, hey, why should you doubt the architect? Isn’t s/he supposed to be the smartest person in the room? In turn, you get to be thrown under the bus while the authority that you yielded to denies all accusations.
At least with blogs, talks, and other tangible items, they can’t fight back.
Being a software engineer isn’t easy by any means and oftentimes we (developers) find ourselves traversing through a Dragon’s Layer-esque of quizzes, tests, and the dreaded whiteboarding sessions. Granted, for a more junior-level position, I can understand a good whiteboarding session or some assessments to gauge whether or not the individual learned anything. But when interviewing someone who has years of industry experience, are these miniature gauntlets really helping anybody?
I think part of the problem is the fear of feeling “stuck” with a bad developer. From the article 7 Reasons Why Software Develoment Is So Hard by Paul Smyth, the author cites that “[t]here is no barrier to entry into the programming world and thus it is awash with many poor programmers who adversely affect projects.” Are we at the point where the industry demands perfection in every aspect of operations?
Or is it just practicality?
Continuing on from Glen McCallum’s blog, we see that while developers hate them, companies love them:
I have bad news for senior developers in the field: many job placement agencies (Robert Half, especially) implement these gates as well. And, as much as I hate them, my workplace utilizes these aptitude tests as we were wasting so much time interviewing poor candidates that couldn’t even tell me what an interface was.
Later we’ll talk about one aspect that exasperated this problem: coding boot camps and the games that they play. Until then, you better know damn well how to use the Strategy pattern in conjunction with a SQL query that can determine the vowel count of every last name in a Japanese customer database and every database has a different collation.