> Respect code and systems that came before you. There are reasons for every code and every guard that exists in production

Sometimes there's bad code in prod, or code that doesn't need to exist anymore. You should try to understand when something is there for a good reason versus a bad reason. Cut out the bad code, keep the good code.

I've seen a lot of cases where people assume that current code is untouchable or designed very intentionally, so they wrap it and then you end up with a tower of abstractions built on a poor base.

So, I think as a senior engineer you should try to understand the difference between code that should stay and code that should go.

Took over a system in Aug '18 with someone else. Previous 'senior engineer' had left after a year to go be a CTO someplace else. Everything seemed wrong - bad smells everywhere, spidey-sense a-tinging every day.

In October, we found that code put in place had been losing data since April - we had 6 months of pure data loss. Data that people assumed was 'working' because ... they hit a button and looked at the screen, and it was there. HOWEVER... after the midnight job run, the data was gone. No one ever looked the next day. Until October, and then it was way too late.

The whole "respect the existing code" has a HUGE assumption in it - that things are actually WORKING CORRECTLY in the first place. It also often assumes some of the original people who wrote the code you're dealing with are still on the team and and to answer questions.

THAT particular project above - my gut was "rebuild" - and we didn't. 16 months later, we are still finding code that is simply broken - data is lost, things are breaking, etc. But the whole "well, you're just someone coming in new - all devs just want to start from scratch and you shouldn't do that!" reared its head, and that idea was pushed aside.

I'd turn it around. Someone needs to be able to demonstrate - usually via automated tests I'd think - that things are, in fact, working as expected/assumed. If not, study/understand, then feel free to rebuild/throwaway.

I've taken part in another project with hundreds/thousands of tests, and while I hit code that looks/smells weird sometimes, some of the original people are on the team still, answer questions about 'why', and the tests pass. Even though it sometimes looks 'bad', it's functional and we can demonstrate its functional and working.

This is a HUGE difference, and that assumption about "it's working correctly right now" shouldn't be taken for granted.

"reason" can be "cause/effect" reason, but also "justifiable rationale". The files look like they do because someone typed keys and hit 'save' - cause/effect. But there's often no justification for how some code exists in its state that has to do with issues related to the business/logic itself. External factors - time (as you mentioned) or missing info (as you mentioned) - that missing info should have been documented somewhere.

I put out a lot of bad code in my early days. Seniors who came in afterwards ... yeah, the only or primary reason they could get from my code was "he wasn't very good at this". And they were correct. I got better, but primarily through trial and error (lots of them).

In thinking of some specific projects from 98/99 - I was demonstrably not good. I got stuff done, but it was generally very inefficient. But... it worked (to the level of understanding of everyone on the project). Even then, people weren't coming in after me to make basic stuff work, but they did help make it better.

If you're coming in to a project and there's no unit tests, no sample data, no repeatable build process, no documentation, no testing or verification process, and no previous team members to actually talk to to get questions answered, there's little reason to have any assumption of correctness. There may very well be 'reasons' for the lack of all of those factors above, but nothing makes me assume the code is correct. And... if I'm brought in to a project like that, "respecting" the code or the people before adds no benefit to the project, and may detract from getting stuff done.

That type of wording belies a destructive approach to the problem. What I'm told is "lack of competence" is often someone not being trained properly, or leadership that decided to make a deadline no matter what, or a junior dev that got called a senior dev to fill a seat at a cheaper rate, or someone who knew they didn't have the skills but didn't want to admit it and lose their job.

The other thing I often find is that regular complaining about other people's code is usually projection. The less forgiving someone is the more likely that their code and architectural decisions suck even more than the people they're complaining about.

There's a senior dev at my job who openly craps on other dev teams as incompetent - to the point that he literally says, "those guys are fucking stupid and their code sucks". This guy never documents his own work, makes inflexible architectural decisions that don't take anyone else into account, and generally causes hours worth of workaround code for me every month.

Now of course there are many times where this is used as a crutch to blame system problems, but I've found a trend towards the idea that it's never due to lack of skill/experience on the part of an individual, and always due to some other root cause. That seems equally incorrect, and good judgement about the cause should be agnostic to how one feels about the idea of saying an individual failed at their jobs (which usually isn't a pleasant feeling for most.)

On the upside, one should actually expect people to fail at their jobs occasionally within certain boundaries, in order for them to grow. So failures to due to 'incompetence' (not negligence) should be often accepted and blameless, given they should be happening occasionally if you are pushing people past their limits. The best way to ensure someone doesn't make large categories of mistakes is to let them make one with a small blast radius, and having them take responsibility for addressing the failure and remediations. (This isn't at odds with blamelessness -- most ethical people will accept responsibility for their failures and correcting them, if they are able to fail in an open, respectful environment)

> That can be extended to the rest of the team or management around the worker(s) for not providing a guidance/help.

I indicated this isn't always/necessarily one person's fault.

re: your senior dev. he might be correct that their code sucks, but he's also being an ass in his own right.

I've told this story a few times to folks where... in 2017, I was contacted by someone who said "the system stopped working". Turns out it was something I'd built in 2002/2003. It's eye-opening and humbling to go back and fix your own mistakes from 15 years earlier.

> The less forgiving someone is the more likely that their code and architectural decisions suck even more than the people they're complaining about.

I don't disagree. It's why I tell people to document as much as they can - document the meetings behind decisions, document the rationale for cutting corners. It will help YOU later on when you have to go back and can't remember why you did XYZ. (See above reference to 2017/2002).

I fully realize my stance comes across as offensive in some situations, and I do not always project this stance. I'm fully aware people are forced in to bad choices some times - I've done it myself (on both sides of the table).

However, I'm also often coming in to situations where I have nothing more than running code and a client wanting stuff done. My scenario above about no tests, no sample data, no testing process, no documentation and no previous dev to consult with... it's probably been more than 50% of the projects I've worked on in the past 20+ years. Clients/employers also read some of the same blog posts, and will sometimes throw out the "you shouldn't just rewrite stuff!" line (often while simultaneously telling me stuff is broken but "used to work 2 years ago"). These are sometimes 'dailywtf'-level projects, and if the primary goal is to make sure data and processing works as people need and expect today, large/wholesale overhauls are often necessary.

I've been on a short term project with a team the last few months and this is 100% different from many previous projects. There's 30+ tech folks, I'm on a team of 8, a mix of jr/sr folks, decent communication, a moderately large (and up to date and growing) test suite, test data, some documentation (could be improved), but generally all good people. I've seen some evidence of the "I'm the awesomest" dev work in the code repos, and those people are no longer around.

I'm not coming in to this project saying "everyone before me sucked ass and I'm a dev god". mostly because it's nowhere near true, but the process of getting stuff done is more team oriented - there's people to help, people to review, a good culture around the project, etc. There are problems but nothing like some of the other scenarios I listed above. So... this is the sort of scenario where it's a appropriate to respect the other folks, previous code, process, etc - it's all there and there's a defined way of working and getting better. Not all projects are like that.

FWIW, to the extent I find myself complaining about "other people's code", it's usually just a prelude to complaining about the processes which led to it. Why is someone being told to do XYZ without any context? Why are they excluded from decision making meetings, but given full responsibility for hitting a deadline they can't possibly meet? These aren't questions for the dev who wrote the code, but for the project management which led to that.

Example: Was brought in on a project with horrible code a few years back. Utter garbage - everything was NIH - they'd built everything from scratch. Digging a bit further, I find out that all dev and server boxes are limited from hitting the internet. No package managers work for anyone, so they build everything from scratch. Exceptions could be made - in writing - and within a few days or week or so, you might have someone pulldown and compile resources from a 'blessed' connection, then give you that code to run yourself. Things like encryption/decryption algorithms were being written by hand because it was the only way to hit deadlines in that working environment. Yes, it's literally insane to try to work that way, but I had a team of people who all did that, and felt trapped. It wasn't their fault entirely (excepting that they should have all just quit at once, or threatened to) but day by day things just got worse. Poor management was the root, not the devs - the bad code was just a symptom.

... document the API, document the project goals, document the company values, document checklists and routines, document processes and personal instructions. DOCUMENT THE GOD DAMN HISTORY OF FAILURES AND INCIDENTS!

And then rely in job on all those documents, not on talks and experience or memory of some key engineers. It hurts when you start, people tend to blame all those unnecessary staff, but it pays off in so high rates later. Often it's possible to say if a company will be successful on long run only by seeing its documentation.

Let's say you inherit a large codebase, and it in fact does not have any tests, and is relatively complex and convoluted. Obviously that's not going to be very maintainable without testing, and it may make sense to do a rewrite...

But first, write tests. Test your assumptions. Read the commit history and see how the code base evolved over time. Maybe the reasons it was built the way it was are dumb ("I like naming my variables after my favorite flavors of pie!") or maybe it was done for really good reasons ("The database library breaks with odd numbers of connections, so the pool always has to be an even number."). The issue is that you simply don't know and risk repeating your ancestors mistakes unless you do some investigation.

[1] - https://en.wikipedia.org/wiki/Wikipedia:Chesterton%27s_fence

You're assuming there's always 'commit history' to review :)

I completely agree you need to do investigation, and document what you can about the system. Some of that documentation will take the form of tests. Without a doubt.

The 'assumption' I refer to is either clients or other devs assuming something is correct. I've lost track of the number of times I've heard "it was working fine until 2 days ago", when, in fact, it was never actually working, just not throwing a visible error until 2 days ago.

I will look at the fence - have seen reference to it before.

"until the reasoning behind the existing state of affairs is understood." - you may also need to realize the original rationale may never quite be understood. I've hit this a few times, and we've ended up just scrapping a particular set of functionality because no one could actually tell why it was there any more - everyone involved who may have used it or wanted/needed it is gone, and it's useless (or is now a blocker for other progress).

The senior devs in projects I worked have made 10 level deep 'strategy patterns' for future enhancements which still had hardcoded values underneath and absolutely non-extensible.

So in my books senior developers knew what they were doing comes with huge assumption. I have noticed many sr engineers simply had delusions of grandeur far beyond their programing skills.

> So in my books senior developers knew what they were doing comes with huge assumption.

This is another big assumption, and... especially given that we know in our industry that 'title inflation' is a real thing... "sr" just doesn't seem to mean much. I'm seeing lots of job postings today that call for "sr foo engineer", calling for 3+ years of experience. My definition and expectations of 'sr' are far different.

Interestingly, I've only been in a couple of places that even defined what they actually meant by that title - what was expected was written down. It was still open to interpretation, but a baseline to judge you against, and to give jr folks something to shoot for.

> which still had hardcoded values underneath and absolutely non-extensible.

Don't even get me started on people that just learned the 'final' keyword and abuse the hell out of it. :)

Better might be a comment linking to a ticket or wiki page or internal README with far more explanation. What's the technical reasoning, and what was the business impetus for requiring this done this way at this time?

Again, I've been on both sides of this fence, but the "never rebuild" mantra has a lot of assumptions built in, chief being that things are actually working correctly. If they are, and there's no tests around it, memorialize the existing state with your own tests at the very start. It's what we did on the August project referenced above, and it took weeks (months, really) to have a modicum of basic tests ensuring some base level of understanding for our team (just 2 of us).

I have seen people proclaiming a rewrite with a newer technology would be a good idea who didn't have the slightest clue about the system they were trying to replace (except that it was build with some outdated technology) and I am 85% sure, that their rewrite would have been worse. When I confronted them with my claims, they gave up quickly.

As a Senior Engineer, you should know what you are doing. If you see obviously bad code, thinking about a rewrite is no sin. Just try to understand what caused the current system to look like it does.

Let's say I'm a manager at said company. An engineer who just joined my project - which our previous senior engineer, who I trust (fairly or not), built - tells me it needs a complete rewrite. My default reaction is likely skepticism: the received wisdom is that rewrites are seldom justified; your assertion contradicts both this wisdom and my previous senior engineer. What do you expect my answer will be?

As the engineer making this recommendation, you'll need to do a bit of showing why. Part of this is technical: write some tests that show the problem, quantify the data loss, etc. Show that you've carefully balanced rewrite vs. other more incremental approaches to fixing the problem. Prototype part of a newer system quickly and show that it can be done.

The harder part to motivate - and often the more important part when it comes to "how do I get people to say yes?" - is non-technical. What's the business impact? What's the user impact? Is this an existential risk to the company if not fixed? How so? How do we assure our clients / users / etc. that time spent here is more important than time spent on features they want? Can you get someone with significant decision-making power to agree? How will you de-risk the rewrite and eventual migration, neither of which are trivial? How can you get just enough buy-in to secure the time needed to answer these questions, show quick progress, and reassure others that this won't be an even bigger catastrophe?

Don't just trash it, learn it, understand it, talk about why it could be improved - people write crap code for many different reasons.

Do replace it but do it with valid reasons and without being horrible.

People also tend to forget human and business impact. The code might look different if there is 1 week or 4 weeks given for implementation. Timelines, pressure from management/stakeholders to deliver faster has impact to made solutions and implementations.

That is when respect is needed - having empathy to understand why this part of software looks like it is now.

https://www.joelonsoftware.com/2000/04/06/things-you-should-...

https://en.wikipedia.org/wiki/Wikipedia:Chesterton%27s_fence

I think that’s exactly what the rule is saying, I think almost everyone would agree. The problem is assuming that code is bad, or even actively looking for “bad”. If it’s in prod, that usually means it worked and was needed. Engineers in my experience do like to assume things are bad and actively look for reasons to re-engineer things without properly accounting for the number of ways things are going right. During my career, I’ve watched two separate large teams at two separate companies decide to rewrite a major codebase because they thought there was too much bad, and they thought there was a tower of abstraction. The result was they both dramatically underestimated the time needed to rewrite, and after having wasted literally tens of millions of dollars, ended up with roughly the same code quality as before and a couple of years of unnecessary down time. It’s more difficult to understand the code that came before and the reasons why it’s there, and it’s easier to judge it bad and decide to rewrite it without completely understanding it, that’s why the default should be to assume the code is there for a good reason, and try harder to understand the reasons.

That rule should, of course, be balanced with this rule, both are true:

> Simplify code, systems, and architectures relentlessly

I personally suspect that writing down and maintaining all the requirements and lifetimes for the codebase separately from the codebase, and having a regression test suite with complete coverage, is the way to safely deprecate features and continue to simply old large complicated codebases. But I’ve never seen that work in practice, yet...

> There are reasons for every code and every guard that exists in production.

Sometimes the reasons are not good ones. Maybe that's exactly what the author meant. The rule doesn't read like that to me, though.

And yeah, if you're rewriting something, don't rewrite the whole damn thing! Good code is modular and you should be able to pick it apart and replace components that are causing problems. If it's not causing a problem, don't rewrite it...

However if you're going to be adding features to a section of code (or otherwise working on it a lot), it's a good time to try to understand if you can do a bit of refactoring along the way to clean it up. By default, all code gains code smell over time and also becomes more robust. It's a tight rope to walk.

Replacing something simply because its not code you authorised or written isn't respectful. Replacing something because its not on a shiny platform, took too long to figure out, or simila, again isn't respectful.

replacing broken code, fixing bugs, changing architecture to adapt to another situation is fine.

1. https://littleblah.com/post/2019-09-01-senior-engineer-check...

2. https://medium.com/@littleblah/my-top-25-items-in-a-senior-e...

3. https://github.com/littleblah/senior-engineer-checklist

Posts derailing this 'high bar' are posted semi-daily to Hacker News, no? It's a really big dilemma (extensive hiring process that weeds out good candidates due to time and frustration or take risks) and it makes it sound like it's just something, you can, you know, do on a Tuesday in your spare time, and then on Wednesday you can solve the architecture problem.

And that's pretty much this list summed up. It's nice on paper, and maybe it will make a difference if someone consults it when making tough decisions. Thanks for your effort.

I'm not part of the hiring process at our place but from what I've tried to contribute as a potential technical test, I get told it's too hard... It's really really not hard at all. But from what I can tell if you ask them to code, even in their own time or in the interview, that's unfair and stressful and you aren't seeing them at their best. So you ask questions instead of asking them to code, but then developers don't remember stuff they can just google nowadays. Again, you are being unfair and it's too hard for them!

We really seem to have allowed the infantalization of our industry, it's very depressing. Maybe the answer is just reject anyone under 35?

Once we become experts (relatively) at something it becomes very difficult to judge "easy" and "hard" things. I suspect we have rose tinted glasses about our prior selves and their ability. Plus, the people we are testing are not our prior selves and have a totally different set of experiences they draw from.

You're comment feel very much so "back in my day" which I am almost certain is a logical fallacy.

I think even a simple fizz-buzz can be a good litmus test. "I see here that you put JavaScript on your resume - good, we need that here. Let's open a console window in Chrome and do FizzBuzz". I've honestly gotten blank stares - developers who don't even know where to start.

[Edit: Spelling]

"Make everything as simple as possible but no simpler." All well and good if your requirements are written in formal logic or if there is only a single axis along which complexity can be measured.

"Hire only the best." What if the best only want to work with the best pay and the most interesting work? But "hire only the best of the very few who are willing to work on your projects for the kind of pay you're willing to offer, who will consider it a blessing that they were hired at 20% above your minimum starting salary with no other career avenues than management, and who are naive enough to think of options as valuable rather than lottery tickets" isn't quite as snappy or happy.

"Don't be evil." And since you have that slogan anything you do is by circular logic not evil. Handy.

That's the interesting question. The hard choice, that I rarely see discussed, is what to do when "the best" won't work for you. Do you hire the "perfectly adequate" or do you not hire and not do that thing you want "the best" person to work on.

Yes, this is the right question. I think the reason there is no generic definition is because it's subjective. The most generally applicable part of this is the differences in hiring practices at large-scale vs tiny-scale (there was an article on HN previously explaining this particular area):

The main points were google-scale can afford high salaries and can afford to cut out good candidates from the hiring process in the name of automation, so easy to automate and standardise empirical testing works for them, but not for small-scale, because you wont be able to afford the same candidate. Instead small-scale either hire for the people who fall through the cracks of large corporate structures or they hire for potential.

In answer to your question, this difference affects (or should affect) the qualities being measured... for large scale it's whatever the job requirements are, measured there and then; for small-scale it's the potential for whatever the job requirements are e.g enthusiasm, drive, domain specific interest. That's just one dimension of a company, there are all kinds of other aspects that will also affect qualitative measurement of a candidate.

But we also had some one who was even more of a GURU IBM used to ask him for advice on large Mainframe database problems.

I've certainly worked in places where they'd rather I didn't get involved in the hiring process. These kind of places often heavily relied on external recruitment, and would rather that I spend my time working on projects than potentially rejecting candidates that could do the job, but weren't up to my standard.

These aren't non-tech companies either - these are companies that deal in/sell tech as a project and/or service. Even in companies that live and die by their development team, non-technical management can run the show and dictate hiring.

I mean, starting with a negative reputation in a team that felt betrayed by your arrival doesn't seem to be the best condition to give the best out of yourself.

Also undocumented in large companies: how to get ANYTHING done outside the team.

Then when it comes to reviews, especially in large companies, you are utterly beholden to whether or not your manager likes you. I've only ever seen one person the manager disliked get a glowing review, and the manager did it as a joke since they were quitting.

PRevious place I worked had probably a hundred senior developers and none of them had any involvement in hiring.

IME the only developers that get involved in hiring is architect level and Lead Developers.

• Question everything and ask “why” repetitively until you get to the root of problems and situations.

• Do not be adamant about your views. Listen to others and accept that there is more than one way to look at a problem statement, and multiple valid solutions to a problem.

• Have strong mentors to help you navigate and grow in the company.

• Read a few technical books every year.

• Actively seek feedback from your manager

The bullets above brings me to halfway through the list, and I feel that I was pretty selective in the ones that I chose. At this point for the remainder of the list nearly every item is one that I'd suggest for any experience level.

Always be ready to review any opinion you have in the face of new evidence. In fact, seek out information that will challenge your opinions. But until the burden of evidence favours another opinion over yours, be prepared to hold and defend your opinions stridently.

It might seem obvious, but this part is extremely important and can be very difficult to live by because it encourages (healthy) disagreement and conflict. "Strong opinions, weakly held" is explicitly _not_ about giving in to a majority opinion or because the opinion is coming from a position of higher authority. It's essentially the scientific method. It does not mean you should agree with other peoples' opinions just because they said it louder and/or more often than you did.

I've witnessed senior engineers and managers misunderstand this mantra and (mis)use it to punish ICs who disagreed with ideas of other more/tenured engineers but lacked evidence for being "better".

If you intend to use this framework as a value in your organisation, make sure you and everybody else understand what it means (_especially_ your engineering managers).

I had never considered this before and it is right and true.

Thank you for enlightening me.

Sometimes that mentor is you. It's good to know if that is explicitly expected of you in your role, because you will need to budget time to do it properly. It is an extremely important role for any team, so take it seriously too.

For project managers/employers reading, it is paramount that you make mentorship be part of the senior developer's roles. As your company grows, you will be churning through employees as new hires and as people leave. It is very easy to not notice that you just lost all of your domain knowledge because you thought everyone was on the same page, but actually you had your senior developers too busy to effectively spread the tribal domain knowledge.

Documentation is great, but there is nuance and depth to complex software decisions that can't be captured in text in a reasonable amount of time. Not only that, but you probably have less documentation than you think you do, no matter how much you asked for it. People don't read it either. They will sooner google a problem, or ask a colleague.

Some developers absolutely do not like the role because of the regular interruptions, I get it, but some people are more than happy to help be a go-to. It remains the favorite part of my job. Make it a question in your interview process so that you can make sure you have someone who is going to be happy making sure your domain knowledge is shared throughout the company.

I would happy to do it if management acknowledges that managing people as a senior dev will take time away from doing actual coding work.

But somehow, they think you can manage to pull off doing deep coding work and managing people at the same time. This refusal to adjust expectations is just baffling to me.

Here's my thoughts on a few of the items themselves:

"Follow the principles of extreme ownership." -- Unless the term "extreme ownership" describes something specific (like "Extreme Programming"), it should be reworded to clarify. What are these principles or what is 'extreme ownership'? Is it clearer to say "make sure you take ownership"? Or "don't waste time working on things outside of your domain"? Or "don't limit your focus to just those items explicitly owned by you"? The latter is approaching XP's "collective code ownership" / "shared code."

"Be reachable to other engineers" -- is this like making sure you're available? Like "check into the company Slack channel frequently"? "Make sure you reply-all to that 11pm email so everyone knows you were checking your email then?" Sorry: that sounds a bit cynical but it's easy to misread this principle that way. Best reword this one IMO.

"Avoid stretching yourself too thin to be effective" - this is a great tip but is it specific enough to be useful? How will I know when I've done this? I think I know the answer but would a junior engineer reading this list know?

"When dealing with politics, avoid it, but have right folks vouch for your work" -- this one is not specific enough for me. "Avoid politics"? Who are the "right folks" -- how would I know whether I had asked the right folks to vouch for the work?

"If you are under-utilized, ask your manager for areas to explore" -- IMO this works better if you can specifically say "I want to work on X" and bonus points if "X" is an item that you know contributes directly to high level goals for the company.

It is very difficult to avoid politics unless you operate in a total isolation. Every time I need to talk, to get consensus, to request, politics is involve. It gets much more difficult when folks are not in agreement with what you want to do.

I will revisit this list in some time, and make changes based on feedback. If you can, feel free to contribute through the shared github link.

If you work for a small startup (where you'll be forced to be "senior engineer" if you like it or not), you'll have no "manager", "peers", "projects", "hiring", "mentoring", "networking", and so 95% of the list items immediately pop.

peers = peers

projects = you’d have at least one (and smaller additions to the product that could be projects in their own) hiring = you could be involved in the hiring process even though probably the CTO will handle it

mentoring = you can mentor others or get nentored by e.g the CTO

... etc

so where is that 95%?

1. https://blog.samaltman.com/how-to-hire

2. https://startupclass.samaltman.com/courses/lec02/

I have never had a job where my one on ones didn't devolve into status meetings and chitchat. What the hell am I supposed to talk about?

https://randsinrepose.com/archives/the-update-the-vent-and-t...

But i think the point of one-on-ones is to have some reserved time and space to discuss important things should you ever need to. If that need hasn't arisen yet, and you end up chitchatting and talking about the current project, that's great - that means you haven't had a crisis!

https://jasonevanish.com/2014/05/29/101-questions-to-ask-in-...

Haven't tried it yet, but might help you to change your one-on-ones.

There is little description or context to this, so I'm not sure what I'm looking at here.

Apologies for being dense!

'Checklist' made me think of something a little more task-focused, e.g. checklist for reviewing code, checklist for designing systems, checklist for deployment etc.

So... I love the content, but I'd change the terminology.

This is my biggest pet peeve with junior developers. I find there's a total lack of ownership about making sure the feature is completely wrapped-up (not just the code, but the tests, the metrics, that it's shipped, that it's correctly marked as done and communicated, etc.)

I find they /expect/ that someone else at the company will review and make sure everything is done and safe, rather than be proactive about it.

It's why chefs-in-training at elite restaurants chop vegetables, mop floors and perform other menial task for an uncanny amount of time before proceeding to other things.

It's OK for junior folks to not see the big picture. I'd be FAR more concerned about heavily silo'd senior engineers only focusing on one thing.

tl;dr: s/"Avoid politics, but have right folks vouch for your work"/"Become an adept politician".

I would say tactical negotiation and leveraging personal connect is healthy, but manipulation for personal gains at the cost of a larger good is what is my definition of "politics".

I have seen couple of managers in my career who, while were poor managers based on employee voice surveys in the company, ended up with large charters due to being good at politics/"rubbing backs". I want to say that end result was they screwed it up since their directs ended up leaving their team, but in reality, they thrived despite losing folks and not delivering projects, again due to politics. As an engineer, I failed to appreciate that.

Now, if you're a good politician with the best interests of the company at heart and the technical skills to deliver, the math is different, and the sky's the limit for you :)

I think that's an unhelpful definition; one should avoid conflating the activity with a particular goal. Politics is governance and decision-making, and how to convince people to support your position; whether that's performed for personal gain, or for the good of the company, or for the good of society (and the three are not mutually exclusive), is another thing.

This means developing empathy for other sides of the business, building up favours from other teams, forging alliances, listening, gathering intelligence and spotting trends.

at some point, you _will_ have to make hard decisions, your budget will be cut, project killed, etc, etc. If you are a skilled "work politician" you may be able to negate some, or all of the bad effects.

I would consider this list to be a little over-engineered

How about ethics? company reputation? legal compliance? corporate responsibility?

...that's about it.

Delivery and ridesharing apps have algorithms that are almost indifferent from tip skimming. Many people working on those platforms live in financial hardship.

In an east asian country, people live under constant surveillance: physical (cameras, face detection), financial, and online activity. If you criticize the government you lose access to everything: payments, transport, credit, job, etc.

If you were paid a lot of money, would you implement those "solutions"?

That is the importance of ethics.

I worked at a company where the the work I was assigned was undermining my career to the point that if I didn't do something on the side, I wouldn't be able to pass an interview.

So while the business aspect is important, it is not the only thing that matters; it never is.

Balancing strategy and tactics is something you do as you become senior. Pumping tech debt is a tactic, good practices are a strategy.

The guidelines say that we should respond to the strongest plausible interpretation of what someone says, not a weaker one that's easier to criticize.

The following quote could easily be interpreted as viewing software engineering as a subcategory of engineering:

> most of the items on this list seem broadly applicable to different types of engineers

Given that interpretation, it seems more like they expected an article like this to be about software-specific concepts.

OP is just happy that this can be applied more generally.

In my opinion, engineer is just a term for people who solve practical problems. Which is a huge community of people these days.

I work with many kinds of engineers, every day, from electrical to mechanical, and I do not find their way of working any more advanced than what I have become used to from disciplines of Software Engineering.

I look at some of their math and think magic. They look at my code and think magic. However, anything else seems pretty much the same. We do iterative development, they do iterative development, although less sophisticated and with much longer feedback loops, so they have higher incentives to get designs right the first time - but that does not mean that they always do!

And it was, thus they were pleasantly surprised.

A junior web developer, with less than 1 years experience might have spent two days reading https://www.amazon.co.uk/Sams-Teach-Yourself-PHP-Hours/dp/06... (if that).

Let's not pretend those are the same.

Software Engineering has a history of trashing any benefits of formal education, and refusing to believe that any of it has any worth.

This is more or less the case where I am from, so I assumed that to be generally applicable, but no? In that case, I agree.

As above, visit [1] for the end-user version and [2] for the repository.

1. http://htmlpreview.github.io/?https://github.com/dpmm99/deve...

2. https://github.com/dpmm99/developer-knowledge/

from link #3 thats coded has high effort, shouldn't that really be a medium or even low? It should be easy to figure out how projects impact the bottom line at the senior level. In fact, i would argue a senior engineer ought to be looking at some monthly sales figures every so often.

I have a couple questions with your notes about politics.

Could you expand on what you mean when you say "fall back to first principals"?

"If politics thrives due to team of company culture, switch" Could you expand on this if possible?

https://jamesclear.com/first-principles

Why json and not csv? Strictier parsing by javascript.

https://themes.gohugo.io/hugo-theme-even/