It's essentially a Darwinian selection process for bad developers.
It's essentially a Darwinian selection process for bad developers.
If you are at a place with sane management, though, don't be in a great hurry to leave...
What is the equivalent in management? Does it exist?
Management is very different from engineering because there is no objective right or wrong, it is all subjective and all about the feelings of the people around you. Management is essentially a babysitting exercise. If you keep your people from throwing tantrums, having meltdowns, and going against the grain, you succeeded, and if you didn't, you failed.
Peer criticism is thus inherently orthogonal to management because very few people can maturely handle even a mild quantity of criticism. Keeping colleagues and superiors in a good emotional state is even more important for career development than executing your job description in a non-disastrous way.
Directing a business is much different from management, even if some management is required, but even then it's difficult to pinpoint cause and effect because there are so many externalities.
You'd think this would mean that good people who can deftly juggle a ton of variables are attracted to such positions, but in practice it seems that people who are bad at things and depend on having many ambiguous potential causes to diffuse fault over take them instead.
That's definitely the case in management; people who are incapable fall into those positions because their performance can't be definitely measured.
Because management is about managing employee feelings, whenever an objection is raised, Bob can say "Well, Alice and Dan were having a really serious issue, which I can't discuss with peers due to confidentiality concerns, and we really had to dedicate a lot of effort to defusing that and retaining them in order to keep our mindshare and minimize legal risk". That's a legitimate managerial effort. Unless you're also in a position to intimately know the issue with Alice and Dan (and if you are then why does this manager exist?), you can't really say "That was an incorrect way to solve the issue."
Human emotions create a drag on productivity, can't get around that. A manager's job is to minimize, defuse, and de-escalate that drag. You can sort of say "Bob, your team always has the most problems, you clearly can't keep them under control", but it really depends on a lot of variables, and unlike software engineering, you can't directly quantify the impact of most actions/tradeoffs. It's very non-scientific.
If you know of a management culture that facilitates this kind of peer feedback, please let me know. My personal experience is that successful management types are extremely emotionally aware and well-polished, and know that providing criticism to anyone only serves to generate hostility. They will try to manage their reports indirectly, attempting to curb behaviors and get results without having to directly criticize.
We must not become overly committed to a company, because a company is only as good as its people, and people come in and out all the time.
Strong engineering orgs hire managers who could do and have done most of what their team does. Most TPMs at G, for example, have CS degrees.
Non-technical managers have the organizational leverage to undo any amount of design & planning that skilled people underneath them set up. It's the brain equivalent of having ADHD -- your executive control shuts down and that sabotages long-term goals.
If you've never lived through this, watch the beginning season 3 of silicon valley where their new CEO wants them to 'just build a box' and gets angry when the conversation gets any more specific than that. (If you have lived through this, don't watch it -- it's too real).
Edit: Agree that technical managers are best suited to evaluate the level of design and planning.
I'd rank technical challenges well behind culture and domain understanding as reasons software projects fail
It makes me uneasy when everybody's answer is exactly the same and they arrived it not through individual opinions but by adapting to whatever was set in place. This isn't bad if all options were thoroughly explored or possible pitfalls addressed (there are no absolute, only subjective and relative truths that come with pros & cons which each decision)....but when there won't even be a debate or conversation asking if what we are choosing to use is really the right thing because we thought it through independently or just because some big name at big company X declared it is the new paradigm.
After all, we are all fallible, development and tools we use is influenced more by marketing than proper cost/benefit analysis. Whatever seems hip, new, cool tends to triumph.
"What? PHP is sooo 2006, we need a React/Redux app for our blog so it will be easy to scale using node.js asynchronity"
https://en.wikipedia.org/wiki/Groupthink
What you're describing doesn't have any obvious "out" group in it. I think instead what you're describing is what you'd expect to see in an environment where judging the merits of tools or processes is very hard and requires a lot of experience, which may be lacking. In such an environment it's natural to look to very successful companies and just copy whatever they're doing, even if you don't fully understand it, in the hope that it works out. And sometimes it will.
This isn't helped by the massive expansion of the developer workforce over the past decades, the fact that experienced people tend to get promoted up into management where they lose touch with coding and become 'architects' working entirely in the abstract, the fact that it's almost impossible for firms to correctly match team sizes to the amount of work required resulting in frequent periods of either overload or boredom (that then leads to reinvention of the wheel simply to find something interesting to do).
And yes, finally, fashion plays way too large a role in things these days. If I had a dollar for every time I read a blog post along the lines of "we had entirely generic serving problem X and we had to pick between Rust, Node or Go", with the far older and more mature .NET/Java stacks not just discarded but entirely unconsidered, I'd be a rich guy. We end up locked in a vicious circle that works against maturity of tools and processes:
- Profitable but slow enterprises look at startups, envy their ability to get things done and wonder if it's because of the stodgy old tools/processes they use.
- Fast but money-bleeding startups look at enterprises and say "we aren't a stuffy enterprise shop so we'll do whatever cool thing I read about on hacker news the other day" and often end up boxing themselves into a corner with immature tools or business approaches. Eventually they (might) turn into big slow companies themselves, often entailing either a rewrite along the way to use more traditional tools or absurd investments into digging themselves out of technical debt (Facebook's PHP runtime efforts being a case in point)
You are totally spot on in that mature stacks don't even make the list. Obviously, new developers are going to be exposed to the new and hip fashion trends while veterans prefer predictability and stability.
It keeps me awake at night thinking about who is right. It could be that we are on the eve of a new paradigm where JS dominates the enterprise or we could be seeing another blip on the radar.
I do however think that AWS is a definite paradigm shift in how developers work, especially as serverless is gaining momentum but this is more of a devops/serverops shift imo.
However if, for example, you have a complex site with intermittent performance problems, good luck. This applies whether you are running complex async code in node.js and you're trying to track down the badly coded callback that blocks everything else. It also applies if you have multiple microservices and you're trying to track down which back end service is causing front end requests to be painfully slow 1% of the time.
And, of course, I'm waiting for Javascript to have something like the problems that Rails did in 2013 when it was discovered that automatic deserialization of requests allowed remote code execution..in multiple ways. In the case of Rails, you just had to get an updated package. In the case of npm, however, the dependency system means that you won't be able to eliminate the bug without updating the whole toolchain in a way that is very, very hard to do. The problem is that in Javascript, libraries A and B can and often do import different versions of library C. If C has a critical bug, then you can't get rid of it until you've upgraded all three. Now imagine this with hundreds of dependencies, each of which has pinned its dependencies and has not been tested with breaking changes in underlying libraries that they depend on...
Every widely used stack eventually has an "upgrade the world" fire drill. That fire drill is going to be very, very messy with Javascript.
http://idlewords.com/talks/website_obesity.htm#heavyclouds
Javascript is a mess. Node got traction because it enabled lots of web devs to port their skills to the server side without having to learn new languages. Heck, the web is a mess. We desperately need a better app platform.