Live data from Hacker News

The Staff Engineer's Path – Book Review

smyachenkov.com

231–240 of 251 posts

Re: The Staff Engineer's Path – Book Review

#231
post #81

Earlier quoted context omitted.

Alternatively, I've worked with Staff Engineers who are still fixing bugs, and also building (maybe staff-level?) tooling and project improvements. The most significant issue is the lack of standardization of expectations. "Staff" doesn't mean anything in a vacuum because it doesn't mean the same thing between any two companies. Personally, I love doing senior stuff. I don't know if I even want to be staff at any poi…

> Staff Engineers who are still fixing bugs, and also building (maybe staff-level?) tooling and project improvements Because they already have the title of staff, and now their success is the team's success, so they are okay with doing boring work. However, this will not get them to senior staff. If you are not a staff and want to be promoted, this isn't the way to go.

Perhaps in some cases, but the ones I worked with pre- and post-promotion didn't really change what they were doing over that period. What I'm saying is that titles are fluid, not fixed, in meaning. They can be inflated or deflated according to an org's mood.

Re: The Staff Engineer's Path – Book Review

#232
post #99

Earlier quoted context omitted.

Sure: nobody wants the car, they just want faster horses. > Even at big tech or any nationally-known tech brand, I'd bet at least half the work in maintenance, support, incremental improvement, and integrations. That's because they are extremely inefficient. Most people build software badly, most companies expect software to be bad, and they hire a bunch of bullshit jobs to do inefficient things to support that bad s…

> These people do stupid CRUD API micro-service bullshit because they're blissfully ignorant of how tremendously amazing their software could be if they fired 90% of their boot-camp dev ops and replaced them with a handful of 10x staff-level developers I wish this was true, I really do. But a few staff developers cannot physically handle the volume of work required to replace that many developers. Staff developers ar…

> But a few staff developers cannot physically handle the volume of work required to replace that many developers.

You're assuming "volume of work" is a constant. I'm saying: 90% of "volume of work" is something that a handful of good developers would make the compiler do instead of humans. It's actually more than 90% over time, because there's a fundamental difference in the "capability growth curve" -- this curve is super-linear with good developers and sub-linear with poor developers, so the ratio between them grows greater over time.

> They are not good at writing 10x more LOC than other developers.

Right, it's quite the opposite: they will write 10x less code than the other developers.

Re: The Staff Engineer's Path – Book Review

#233
post #229
post #99

Earlier quoted context omitted.

Sure: nobody wants the car, they just want faster horses. > Even at big tech or any nationally-known tech brand, I'd bet at least half the work in maintenance, support, incremental improvement, and integrations. That's because they are extremely inefficient. Most people build software badly, most companies expect software to be bad, and they hire a bunch of bullshit jobs to do inefficient things to support that bad s…

Disagree. While I always felt that I want to achieve more than these regular old CRUD apps, no “10xer” would implement them faster/better - because “these systems are building the rails in front of the train”, and it is not even an engineering problem most of the time. I have worked at banks and the amount of back-and-forth between what the bank wants and what the devs need to know is insane, not well specified, alwa…

> While I always felt that I want to achieve more than these regular old CRUD apps, no “10xer” would implement them faster/better

A "regular old CRUD app" doesn't exist. Poor development teams end up translating all requirements into "regular old CRUD apps" because that's easier. Humans are excellent at replacing hard problems with easy ones, regardless of whether solving the easy one is anywhere near as useful.

And yes, they absolutely would implement them faster. Most "regular old CRUD apps" are rife with SELECT N+1 and other simple and crippling performance issues.

> “these systems are building the rails in front of the train”, and it is not even an engineering problem most of the time.

You're assuming we're stuck with trains and rails. In the physical world, we are: if I invent a different kind of train that doesn't need rails, or a completely different way to transport freight, then I've solved about 1% of the problem -- we still need to build out all the infrastructure around it, change all our systems to use it, etc.

If I invent a different kind of process for handling data flow in an application, I've solved somewhere between 40% and 100% of the problem, depending on how 'private' it is, etc. "Building" the thing takes the compiler a few seconds. We might still need to adjust downstream dependencies, but if they're also written well, that should be extremely easy.

> it is a super-human, not-really-compressible complexity

While this definitely exists, my claim is that the intrinsic, Kolmogorov complexity of the problems most existing software solves is somewhere between 10% and 1% of the actual complexity of that software.

Sometimes upstream processes will need to change (usually becoming much simpler). This is usually the sticking point. if the upstream process is the U.S. Code of Federal Regulations, then this isn't likely (without lots of lobbying money to simplify it, which the FAANGs of the world should actually consider a tool in their toolbox, but most of us can't), and we can call the "intrinsic complexity" high.

But more often than not, that complexity is actually coming from the whims of some previous moron vice president who now works somewhere else, and they're conflicting with the whims of the current moron vice president. My whole point here is that the staff-level developers need the authority to tell those people to shove off and implement it in a way that actually makes sense. Yes, I'm aware that will never happen because of the deep toxic dysfunction endemic in modern corporations -- this is my point.

Re: The Staff Engineer's Path – Book Review

#234
post #233
post #229

Earlier quoted context omitted.

Disagree. While I always felt that I want to achieve more than these regular old CRUD apps, no “10xer” would implement them faster/better - because “these systems are building the rails in front of the train”, and it is not even an engineering problem most of the time. I have worked at banks and the amount of back-and-forth between what the bank wants and what the devs need to know is insane, not well specified, alwa…

> While I always felt that I want to achieve more than these regular old CRUD apps, no “10xer” would implement them faster/better A "regular old CRUD app" doesn't exist. Poor development teams end up translating all requirements into "regular old CRUD apps" because that's easier. Humans are excellent at replacing hard problems with easy ones, regardless of whether solving the easy one is anywhere near as useful. And…

I wrote somewhere about there being two kinds of complexities (not the very important essential/accidental, but a different categorization).

I called them vertical and horizontal, not sure if they have some better name, but the vertical one would correspond to “hard” problems, like some complex lock-free parallel algorithm that had to be made in exactly that way to not have race conditions. Or some of mathematics.

The other dimension would be the essential part of business logic, where the business logic has grown in a haphazard, organic way - but since other services depend on it, it has to work as is, from bug to bug almost. This is more like a biological system — cells have plenty of redundant, vaguely similar pathways handling the same thing, it is chaotic, but if you were to simulate the whole thing, you couldn’t go around it, you would have to implement the whole complexity. For a more human example, history might be such subject. These things are complex in the same way compressing a random noise file is.

A software can have both kinds os complexity, they are different axes — and I argue that CRUD apps are usually of the second kind, most of the former kind of complexity are handled by external services/libraries (e.g. they might enter two addresses to a third party system to get two coordinates, and put it to another service to plan a trip between the two — the app only handles the communication). But these can get arbitrarily complex, and the specification is the program itself. That’s why we continue to run Fortran/Cobol software at certain banking firms.

Re: The Staff Engineer's Path – Book Review

#235
post #232

Earlier quoted context omitted.

> These people do stupid CRUD API micro-service bullshit because they're blissfully ignorant of how tremendously amazing their software could be if they fired 90% of their boot-camp dev ops and replaced them with a handful of 10x staff-level developers I wish this was true, I really do. But a few staff developers cannot physically handle the volume of work required to replace that many developers. Staff developers ar…

> But a few staff developers cannot physically handle the volume of work required to replace that many developers. You're assuming "volume of work" is a constant. I'm saying: 90% of "volume of work" is something that a handful of good developers would make the compiler do instead of humans. It's actually more than 90% over time, because there's a fundamental difference in the "capability growth curve" -- this curve i…

> I'm saying: 90% of "volume of work" is something that a handful of good developers would make the compiler do instead of humans

I don't understand what you're saying here. I cannot hand off feature work, rollout planning, context gathering and investigation, etc to the compiler.

> Right, it's quite the opposite: they will write 10x less code than the other developers

At a growing company, that is not helpful... You will not be able to move fast enough.

> It's actually more than 90% over time, because there's a fundamental difference in the "capability growth curve" -- this curve is super-linear with good developers and sub-linear with poor developers, so the ratio between them grows greater over time

This is only true when you are working on complex problems. If I have a lot of tasks like "change the colour of this button" having a few staff developers vs a lot of average developers is far worse.

At almost every single company, there are far more mundane and relatively simple problems than complex problems. Most companies would not get more value from having way less super senior devs. There are just not enough complex problems for them to solve.

Re: The Staff Engineer's Path – Book Review

#236
post #71

Earlier quoted context omitted.

Typically the direct reporting relationship is about managing someone’s career and not necessarily their work. The leadership described here is more about the work to be done rather than the person’s fulfillment and suitability with that work. This separation is more pronounced with large (1000+) engineering organizations. Often people don’t experience this difference because it doesn’t exist at the smaller scales. E…

When you say "about managing someone's career" I can't help but feel you actually mean "someone's job". No manager is paid to care about an employee's career that I have ever seen or heard of.

> No manager is paid to care about an employee's career that I have ever seen or heard of.

This is an incredibly common part of the role(s), so my guess is that you have been unlucky in this.

For what it's worth, all the strong managers I've ever know or worked with pay attention this this, and vast majority of companies (again in my experience) made it an explicit part of their role.

I'd go so far as to say as a people manager (as opposed to a project manager, say) you cannot do a great job without considering things like career progression, because if you don't, you don't understand your team well enough to be really effective.

Re: The Staff Engineer's Path – Book Review

#237
post #83

Earlier quoted context omitted.

Can you explain better the difference? I am trying to figure this out myself for a while...

A Staff Engineer doesn't really have to care about for example people that have a rough patch, or about notorious assholes ruining the team's morale. That's mostly a people's manager problem. On the other hand people's sense of who they should really listen to always skews to their manager (the person that can fire and/or promote them, or at least has the most say in the process).

If I can modify that slightly: The staff engineer isn't accountable for people that have a rough patch or who are assholes (and the manager is). I've found as a staff engineer that I definitely have to care, adapt to the rough patch, and campaign/do politics to get the assholes out, but I'm not accountable for it.

(I originally wrote this with "responsible" in place of "accountable" but that was fuzzier; surely as a staff engineer I'm responsible for more than my direct contributions even if I'm not directly accountable for them.)

Re: The Staff Engineer's Path – Book Review

#238

Earlier quoted context omitted.

Dogma in the tech industry is that the ceiling on individual contributions is close to the median. That the leverage is all in coordinating larger groups of engineers. Belief in, affection for, or aspiration to be the lone-wolf super-genius coder who does something transformative in his own editor is a negative signal, associated with "brilliant jerk" and "not a team player" archetypes. Tech companies are generally s…

And the stronger this rejection, the stronger the pressure on anyone who represents a counterexample to the dogma to leave.

Strong coders are usually pressed into technical leadership roles where they don’t have much time to code. It’s true that if you shirk your non-coding duties you’ll get managed out.

Re: The Staff Engineer's Path – Book Review

#239
post #83

Earlier quoted context omitted.

A Staff Engineer doesn't really have to care about for example people that have a rough patch, or about notorious assholes ruining the team's morale. That's mostly a people's manager problem. On the other hand people's sense of who they should really listen to always skews to their manager (the person that can fire and/or promote them, or at least has the most say in the process).

If I can modify that slightly: The staff engineer isn't accountable for people that have a rough patch or who are assholes (and the manager is). I've found as a staff engineer that I definitely have to care, adapt to the rough patch, and campaign/do politics to get the assholes out, but I'm not accountable for it. (I originally wrote this with "responsible" in place of "accountable" but that was fuzzier; surely as a…

Yeah I agree, accountable is a much better word.

Re: The Staff Engineer's Path – Book Review

#240

Earlier quoted context omitted.

Obviously, it depends on the work (why would we try to have a discussion like this without setting parameters?). But in general, I think the places that need 10x the code are outnumbered by the ones that would be better with 1/10th the code they have, written by fewer people. It doesn't happen, but that's better explained by organizational reasons.

I think it's the complete opposite. There are very few businesses that can exist without having to solve an enormous amount of edge cases. Most of the time that's the whole reason the business is valuable! Also, this shouldn't be framed as 10x more code but 10x faster velocity. That is what I meant by "[staff developers] are not good at writing 10x more LOC than other developers". Staff devs cannot move 10x faster th…

Well, yes, I mean, how can we really have this conversation and throw numbers around without defining even what countries and industries we are talking about?

But, maybe it's true that most code covers edge cases; then in my opinion, staff developers should be building tools for the rest of the company to use, and if they are powerful enough, you might be better off by having fewer people employed as programmers and more people writing programs. Obviously a lot has to go right for this sort of thing to happen.

Post reply on HN