On Managing Developers
techcrunch.com
techcrunch.com
As a leader of an engineering team (and an engineer), I think the is this is entirely the wrong approach. It's a leader's job to get the team to understand why writing tests is important and have them write them. Sometimes an individual isn't a great fit on the team and you need to figure out how to handle it (i.e., they refuse to write tests but the rest of the team is).
There are few points in this article that resonate - but there are many that are complete off base such as
> Managers translate the project’s Big Picture into individual tasks for developers, with their details and interactions specified in minute detail
I agree that leaders/managers translate the big picture to developers (provide vision) - but the team should figure out the minute detail - otherwise you're removing autonomy, the ability to fail, and are yourself falling into the pit of micromanagement.
I like how this statement completely skips the reason why developers don't like to write tests. The majority of managers refuse to allocate any time to write any tests. Hell, when we come up with a 6-week estimate for a project, they then tell us we must do it in 4. At 4 weeks, the complaints and blame game begins over why the project isn't completed. Why? Because it was a 6 week project, morons.
I've only had one company with management that wanted unit tests written for code. Yet there was no official time dedicated to this process. That 6-week project that would be estimated without unit tests? Still 4 weeks. Huh? What magical world do you live in?
Quality requires time. That 6 week project now needs 8-9 weeks. Not 4. Not 5. Find me management that understands this and actually cares about quality instead of impossible deadlines that fit their fantasy plan for the current quarter, and we'll talk.
To be clear, I love writing tests. I would always have them if the decisions for project deadlines were left to me. Such decisions are out of my control, so the company gets what they are willing to pay for.
Writing tests that are not highly coupled to implementation is hard. That means that every time you change the system, you have one or many test changes to make too.
How do you know what to test and what not to test? How many tests do you write? One line of code can, if you think about it exhaustively, require 3 or even more tests.
A lot of time you'll write code that facilitates testing. Do you test this code? What happens if the code silently fails and now you don't have proper test coverage of all the code paths said code is supporting? This is particularly true if you are mocking objects.
Learning how to test, properly, is almost as hard as learning how to code. My advice is, if what you're doing is boring, like most Rails apps, lean on the library as much as possible, break up anything that goes against the grain into unitary features, and test them each in turn. You don't need to test that ActiveRecord.belongs_to works.
It doesn't surprise me that there's developer reticence towards testing. I tried powering through that reticence, believing there's some "magical world" as you put it, where testing actually helps you code faster and more accurately, but I found even myself a TDD apostate, I don't even do it for my own projects anymore.
This disastrous ecosystem exists with QA too (which is again, a form of testing). A lot of companies - usually the smaller ones - don't invest any resources at all for QA. Others just do point-and-click smokescreen tests that'll discover bugs that are blatantly obvious (also typically the ones the developer should never have committed to begin with). Real, proper QA? That requires investing serious time into test cases - completely figuring out every possible interaction and scenario that can take place. All before a single actual test is run. And similar to unit/functional tests, QA test cases need to be reviewed whenever the smallest bit of functionality changes.
The reality is that most employers who "want test cases" want there to be a magical solution that gives all the benefits, without any effort.
Employer, start of project: "Oh, it'll save time? Great!" Employer, end of project: "You said it'd save time, lies!" Developer: "I specifically explained how it saves time in the long run. Not the initial implementation." Employer: "..."
And sometimes you shouldn't write tests, or perhaps no unit tests, or perhaps write the tests but throw most of them away, etc etc. It is all highly context specific.
The real issue for managers is even if they start out technical, within a year or two they lose touch.
Also, do you have anything quantitative to back your statement about being out of touch? That hasn't been my experience generally and I work quite hard to ensure I don't lose touch. That's obviously only data on my experiences - but I didn't make the assertion (I genuinely interested though).
Fundamental shifts occur in development all the time, and if you're not actively coding while these are going on, you can definitely get left behind and be out of your element when it comes to decision making.
I have peers that cut their teeth on Enterprise Java and Oracle and now they are managing engineers doing Native Mobile, JavaScript Apps, Ruby on Rails, DevOps, Distributed Databases, and deploying on public clouds like AWS.
It's very easy for them to get lost in the jargon and they end up leaning on and trusting senior engineers to guide them a lot.
While this can be a good thing, it's very easy for the wrong senior engineer to lead them astray and start pushing their own agenda (rewrite all the things, resume driven development, etc).
This is a very good point, but how does an organization do this? Who can be at a management level for the majority of their time, yet still remain technically sharp enough in multiple technologies over time, to know when someone is outright lying to them? And it's not like you can just ask them to walk you through it - even ignoring the significant minority of egomaniac technical people who will more or less outright refuse such a request, in many cases even if they are relatively cooperative, often the subject matter is simply too low level or complex to be explained (or is deliberately explained in this manner), and sometimes the disagreement is not even a matter of fact, but rather a matter of opinion (everything XML, language choice, 100% test coverage, etc). It's a tough problem.
One possible defense against this is to regularly refresh talent, and encourage high performing individuals to swap between contributor and manager roles without any career penalties in between stints.
Even if it doesn't work out for a contributor to manage people or a manager to write code, the cross pollination of talent could strengthen the technical capabilities across the organization. Contributors and managers would build trust with each other, and ultimately empathize enough with each other to act as trusted partners.
I've seen this play out in the startup ecosystem as you see VPEs leave to become early stage startup CTOs, get their hands dirty to launch ideas, and then ultimately bring in trusted contributors once the products have found product-market fit.
How do you know you haven't already lost touch? :p I joke, but the first time I switched into full time "architect" mode I did lose touch without even realising it.
I guess the key measure would be: could you jump into a senior developer role on your current project and be as productive as the other senior devs on the team? In my experience most team leads can, but very few managers can.
I doubt there is much in the way of hard data either way. I've personally met less than a handful of architects/managers that were clued in over my 15+ year career.
It's like looking at code written by a python developer who, a couple of years ago, used to be a c developer. The developer still understands memory management, but it's no longer forced to the front of their minds. And it shows in the code they write. Likewise because as a a manager you aren't forced to deal with the code your brain quickly abstracts it away. Your "atomic operations" when you think about a problem become a lot larger.
http://martinfowler.com/articles/is-tdd-dead/
The takeaway is that the usefulness of tests is the feedback it gives you about your code (and confidence, a subtype or result of feedback). All of the BDD vs. TDD vs. Test First vs. Test Whenever can get wrapped up in too much zealotry, and is ultimately secondary to the goal of getting feedback.
Way too often, real world discussions about management in teams turn into discussions about technical detail ("If we only had tests / quicker builds / used language X then we'd get better results") and this basic, underlaying problem of room for autonomy in the process is overlooked in favour of topics that are more easily discussed.
The main reason I added this (mostly useless) comment was that all replies so far had followed the same pattern of only discussing the issue closest to technology; the tests.
Edit: removed duplicated word.
I think you stopped your quote too soon. Writing a couple tests sets a pattern, an example o follow, and demonstrates how important they are because you are willing to take time to do them to begin with.
But just giving lip service to the importance of them does not change a culture of untested code.
Setting up code coverage reports, test harnesses, a few examples, and then talking about the test metrics shows it's important to management.
> Few developers like to write documentation. That means it’s your job.
OMFG. Most traditionally-trained devs I've met in person are next to illiterate. Bizarrely incompetent at docs. Unsurprisingly their code quality stinks too.
They'd probably ridicule you for mentioning "programs must be written for people to read, and only incidentally for machines to execute". (Unless you say you're quoting "the Wizard Book", because they defer to argument from authority.) Read my sourcecode, they say, as if that doesn't mean "Go fuck yourself".
And they simply never want to proactively improve. That would require introspection and self-critique. Pulling teeth.
If there's no real leadership, then you're stuck in the backwaters of being managed. My advice is if you find yourself in this situation, either use it as an opportunity to work on your leadership skills or check out and throw your passion into side projects.
Kathy Sierra in "Badass: Making Users Awesome" said: "An important, unconscious way to develop expertise is being around high-quality, high-quantity examples of expertise." The flipside is apparently true: exposure to mediocre examples begets mediocrity.
On the other hand, end-user documentation can be a lot of really tedious screenshotting in some markets, and it can't always be automated.
Some developers aren't great at gathering requirements, estimating costs, triaging requests, saying no, or any number of other things... if only because they'd rather be coding. And that's not even getting into what they can mess up when it comes to the actual development portion.
A good technical manager can help cover for their shortcomings, and let them focus on their interests - what they're good at. They're not just an ablative meat shield.
To be fair, nobody is great at those first two.
You're right about that being one of the challenges, but it's still an easy challenge compared to everything else.
(BTW, the biggest issue within the emotions category is that developers tend to deny, even to themselves, that an issue is an emotional rather than a rational one.)
No, please.
I mean, correct diagnosis is one of the first and most fundamental things a hospital does when admitting patients. Failure at this stage cascades through every step that follows, possibly with fatal consequence.
If you're "managing" a place that handles this work without a working understanding of the process involved, there's a very good chance that failures can be traced - in large part - back to your desk.
Directly to this premise. Correct diagnosis is a difficult and often error prone things that a hospital can do. To think you can train someone to be a manager and be good at diagnosis is putting a lot of trust on someone.
Should they be able to help? Certainly. But, at some level, I would expect the manager to be better at knowing which doctor to get you in touch with moreso than how to do the diagnosis themselves.
When it comes to the people I manage, I don't need to be able to do their job, but I do need to be able to speak their language and understand their concerns well enough to see the task from their perspective.
I should add that this has always been self-evident to me. And it's always worked very well. But I should also note that it's not the norm, and when people I work with discover how much I know about what they actually do, they're almost always pleasantly surprised. "Oh", they say "you really get it."
Nearly everything about management gets easier if you're starting from there.
So, yes, we are in agreement. :)
E.g. Managing a team of 10 developers at a company with 30% turnover is very different to managing a team of 3 developers at a company with 5% turnover. Approaches and techniques vary drastically based on context.
Suppose "your team" have to paint a cathedral for a king and you are the "manager". Of course you cannot paint yourself and hence holding an opinion that the paints and brushes are the most important things in this business.
Nevertheless, you have noticed, that some guys, like Leonardo, are much better at painting of the ceilings and in order not to disappoint the king you have to hire him and all the second best guys. Of course, you are sure that these guys are just lucky and overrated.
What you ougth to do, in order to not be beheaded by the king, is to be sure that Leonardo and the other painters has everything they need, of best possible quality and there is not a single obstacle on the horizon.
Now imagine that instead you have decided to hold daily meetings to discuss how to mix the paints properly, about responsibility to the whole team, and importance of writing daily reports about elements finished so far, together with detailed statistics of materials spent on each element.
To be sure that everything is going well, you have to climb to the ceiling few times a day and ask smart, psychological questions in orfer to avoid any possible lapse in productivity by exercising employee's morale and dedication to the project. For that reason you have short meetings in the morning.
Because you have no idea why the masterpieces of these guys are so highly acclaimed, you are constantly trying to improve their decisions by introducing new elements and changing colors, which are, you have been told, are industry standard best practices, and forcing them to use not the paints they used to, but guaranteed, safe, battle-tested priducts they used to paint the walls of the king's palace and stables.
If you look at a company of say 100,000 employees, and a generous span of 1 manager to 10 subordinates, there are 33,333 managers - and as they usually are paid better than their subordinates, the cost is typically over 50% of salaries. And it's a rare industry that is not mostly salary as cost.
And we now have an amazing set of technologies and examples of new organisational forms (Linux?) that say "hey, you can eliminate a huge cost base and be more productive.
Wanna bet how the next decade is going to go for those called "managers"?
Why would, for a company of 100,000 employees, it bump up to 33,333 managers?
Linux, organizationally, does not fulfill the same functions as are needed in a company (recruitment, firing, finance, HR to name a few.) How would you model a company after it?
That is the single reason for many orgs screwing up their system as this forces excellant developers/workers to abandon their core skills and move into management..
It becomes a problem when tech salaries are on the rise, because at some point the company either has to start paying coders more than managers, or has to implement pay rises throughout the management hierarchy in order to retain good technical staff.
At this point its really tempting to promote good coders into management to keep them.
This is just greed/pride. As a manager, the only person who knows that an engineer makes more than you is you. And it's pretty common these days for companies to have an engineering track that has a VP-equivalent top position, so it's pretty common that the most senior engineers will make more than most of the managers at the company.
That's like saying that a film doesn't need a director. Well maybe in theory you could make a film without one but that's not the best way to go about it.
- Leaders get a project done. They may or may not be managers. They think about technical problems, they write code, they organize teams and answer questions, they write design documents, they communicate technical stuff to other teams and managers. In some companies these are PMs (but the meaning of PM has been devalued to "someone who does non-technical project management, like bug tracking and scheduling").
- Managers deal with people. They write reviews, they fire people, the might hire people. They do donkey work like finding office space or ordering hardware or making sure that people get compensated properly.
Those are two different jobs, and they're often conflated.
1. Zappos: http://www.businessinsider.com/tony-hsieh-self-management-me...
2. Medium: http://firstround.com/review/How-Medium-is-building-a-new-ki...
3. Valve: https://managing-essentials.com/valve-software-successful-se...
Medium is a tiny company.
Valve...had some interesting claims surface when their structure was discussed here. Such as a shadow management structure.
In school, most people don't get the project done unless there's a deadline imposed upon them by someone else. And in the professional world that someone else here is the manager..?
Such manager doesn't exist in the current development biotope.
As a manager, I try to let the team and the PM work out the individual tasks, and ensure there is consensus and follow through by individuals. Handling external pressures, clearing roadblocks, and resolving team conflicts are where I feel that my time is best utilized.