Worst: A conversation with this boss-colleague of mine would go like this:
Me: There was an urgent bug yesterday, and I fixed it.
Him: That bug was within my major commit last month. Did you fix the bug because you think I am incompetent and can't fix the bug myself?
Me: Oh, no, it was an urgent bug ticket submitted to our team, so I went ahead and fixed it.
Him: So you are saying I am useless to the team.
Me: No-no, I don't think you are useless. Quite to the contrary. You were busy doing another ticket yesterday. You know what, maybe you are right, and I should have waited and reconsidered before I fixed the bug.
Him: Oh yeah? You are being passive-aggressive now. Your behavior is very toxic and is disruptive to our team dynamics.
Me: I am sorry you see it that way. Could you tell me what I could have done differe...
Him: I am downgrading your performance review, and you would be getting a lower discretionary bonus this year.
This ended up costing me a five-figure bonus deduction.
Since then, after rising through ranks, I too became a team manager. Thanks to this lesson, I know how not to treat my team members.
I don't work in IT/Software Engineering - I work in law. But when I find fault in other's work, it's a courtesy to let them know and give them an opportunity to address it. It's part of being a team player. I am not trying to be critical of you. It's just reading this reminded me of similar experiences where I was in a similar position to you. They were important experiences. People can feel bad when other people fix their mistakes when they aren't given the opportunity to be heard about it. It's so tempting to just say 'I will just do it myself' but you might find other people react poorly to this.
Of course, maybe things are different in the IT world where it may be challenging to identify who committed a buggy change to the code repository, or perhaps just a radically different culture of work. But at the end of the day we are all human.
It does appear you have developed an awareness of this, given what you noted in your reply to him (and props to you for that!). From there on, his behaviour was misguided and not appropriate.
Easiest thing to do ia not to blame but to just find a solution and see as a team if it was a genuine mistake that is unavoidable or if you can make some adjustment to the process to ensure quality and reliability of your code.
People can specialise in a certain area of the codebase but no one 'owns' anything. Everyone needs to respect that any change to the code is a neccesary one. The 'expert' or original coder is usually a reviewer of the changes proposed anyway so thats when they can voice opinion on whether someone has misunderstood something or not.
Bugs/Features can be worked on by anyone without ego getting in the way.
1. Would he be informed of the/a bug(s)? Absolutely. We monitor bug tickets submitted to our team throughout the day. It's a main part of our job.
2. Was there a strict code ownership per individual contributor? No. This team's culture was such that once one contributor's code was committed to the main repository, it is part of the team's responsibility, not just the original contributor. In fact, any kind of don't-touch-my-code attitude was heavily frowned upon, worthy of a warning. I understand other teams may have different cultures.
I was too young to know the office dynamics back then, but in hindsight from more life experiences since then, I now see that he was just a very insecure person. His former colleagues were advancing ahead of him, making 4x his salary, and the last thing he wanted was a young team member outperforming him. This observation itself is a life lesson for me.
Sure, if there is time, it is best to file a ticket and notify the code writer so he can fix his own bug. That’s how he learns, but an urgent bug?
The worst part is his reaction. He literally twisted the person’s words to the worst interpretation possible.
What a piece of shit colleague.
It sounds like one possibility is your boss may have been trying to prevent you from getting to his level which would mean he would have to compete with you.
Stack ranking incentivizes people at higher levels to only allow incompetent people to get to their level because they’ll look better in comparison.
What are some ways to do this effectively?
Why was this bug not prevented? Did I follow the processes? If yes, why did they fail, and how can I change them not to fail next time? If not, why did I not follow them? How can I ensure that this will not happen again?
Also, can I share my experience? Can I learn from someone else experience? I think it's very good to say "I did this and that, which I thought would be enough, but it wasn't, how do you guys do it?".
Not saying it's perfect, and I always feel bad whenever there's a bug in code I wrote, but I'd rather hear about it, if only just to try to reduce the amount of time this happens in the future.
1. Proactively ask individuals for code review.
2. Thank people, visibly and publicly, when they point out mistakes or offer good suggestions.
3. Be an example when you leave critiques; accept that beyond some agreed-on code standards, some things are subjective. Just because you wouldn't write code in a certain way doesn't mean the way they've written it is wrong.
Try to get onto the path of thought that led them there, but let the questions that arise naturally for you hold off as long as you can.
To be clear this is like a policy, you will fail at it but it reminds you of the prinicals that you believe in.
I learn a lot doing this in more ways than i could explain in a book, never mind a comment.
Your peers aren't harming you by finding fault, they're strengthening your position by doing so.
I personally hate it when a bug slips through to production, and I always profusely thank anyone that spots one before it does. Or after. Whatever, as long as it gets fixed...
Transparency leads to trust, but also can be abused. Be transparent in incremental steps, so that you still build trust with those that are trustworthy, and so you aren't hurt too badly by those that aren't.
Failures of people are as often due to the environment they're in as they are the people. That can be useful to not judge colleagues too harshly, and also to remind yourself you are good and capable when you find yourself in a job/role where you're unable to function.
The way to build successful products is to care about them. Stakeholders that seek to explain problems they're trying to solve and why the matter will get results; stakeholders that try to dictate solutions to dev will not. Seek out places that recognize the devs job is the 'how', and the rest of the business' job is the "what".
People who say "we're one team" and "it's not us vs them" are to be avoided. If the groups they're talking about were truly one team, such statements would not need to be made; making them is trying to band-aid over issues and misalignments rather than address them.
Be kind. Even useless assholes can become allies if they see you going out of your way to be kind to them.
What do you mean by those that?
Responsible: You're the one affected by something, and the one expected to respond to it (first, possibly only). You have incentive to prioritize it highly and deal with it. I.e., if anyone cares about it, it's you. So, for instance, an alert goes off that a service is down. While it may affect the whole company, if it's your service, -you- are responsible for it. "We're all responsible for it" is not true; who feels that sense of ownership, who is going to have to write the post-mortem, who would be blamed if it's a blame culture, etc. Or, more succinctly for this example, "who is waking up to deal with it". This matters because it's too easy to blur lines of responsibility; is the director of the department responsible for it? No; while long down time that leads to revenue loss may require his presence in meetings and things, he isn't expected to actually go fix it himself. He's responsible for hiring the right people, and setting the right policies in place; NOT answering the Pagerduty. Broadly sharing responsibility is an anti-pattern, and, frankly, a lie; it's why "decision by committee" and "too many cooks in the kitchen" are bad ideas.
Empowerment: The changes you need to make, you can make. This might be in terms of organizational authority, or actual technical permissions. In the prior example, if I can't access prod enough to fix the issue, I'm not empowered. What I AM empowered, and responsible, to do, is send emails/call someone who can make the changes. If I don't know who that is, I'm not knowledgeable; I can do what I -am- knowledgeable of (send an email to the whole department? Post it in a seemingly relevant Slack channel? File a ticket?), and then wipe my hands of it until I can either acquire new knowledge (who to reach out to), or new empowerment (the ability to make the changes).
Knowledgeable: Knowing what needs to be done. This might be a business need, or it might be technical. Technical is 'easy', in that you can usually go learn it on your own, but the business is harder, as it comes from somewhere that may not want to work with you, or that you can't identify. As an engineer, I might be responsible and empowered to build things, but I'm not knowledgeable about -what- the business wants/needs; I have to get that information from product or other stakeholders.
If I know what and how something should be done, I'm responsible for delivering it, and I'm empowered to actually go get it done, I can (and if a good employee, will) do it. If I'm missing any of those, I can't; I have to get the missing piece(s). This sounds obvious, and it kind of is, but pretty much every organizational problem I've run into can be framed using this (though sometimes with slightly hand-wavey definitions).
Dev is blocked on product; dev doesn't have the knowledge to know what to build. Go to product; they don't have the knowledge either. Further, they're not empowered to prioritize getting that knowledge; instead, they're spending all their time on what they feel responsible for, say, unrelated meetings, UX design, and documentation of status. A fix: change what product is responsible for (from "gather status and respond to upper management -> unblock dev"), and empower them to prioritize their time accordingly.
Dev feels releases are a pain in the ass; they are responsible, but empowerment to actually push to prod resides in an ops team. The ops team has the empowerment, and the knowledge, but they don't feel responsibility; if a release goes bad it's their issue, but if a release doesn't happen it's the dev team's issue. A fix: Either empower devs to release to prod without the ops team's involvement, or make ops feel responsible for releasing (i.e., time between dev says "we want this released", and when it gets released, is a factor on how the ops team's performance is evaluated).
Determining what is missing provides direction in what to address to solve the problem, and if you're unable to, moves it from something to agonize over, to something to accept as not something under your control.
I learned from my worst colleagues: don’t assume that anyone will protect you from toxic or abusive people. You must be willing to protect yourself. When people come for you and your project, either be willing to throw down (metaphorically) or be willing to walk. Bad people often don’t have bad careers, and there is no justice.
I always like to think that “the arc of the moral universe is long but it bends towards justice.” Not all of them, but many of the bad folks you work with eventually flame out or stall.
The rest seem to become CEOs.
well if you are "right a lot" then it's easy to reap "better dividends".
it's easy to get promoted, just never introduce bugs and always know the solution to all problems and deliver it before yesterday!
Compliment people behind their back relentlessly.
My worst colleagues were the exact opposite. They didn’t listen to anything that they were advised and then when the project failed they tried to pin the blame on me. Luckily the rest of the team vouched for me so nothing happened but it left a bad taste in my mouth. There really isn’t much to learn from scumbags since it’s obvious you shouldn’t be a scumbag.
I try to always have this kind of mindset, but sometimes I just don't see how to do it. Imagine you are at the office, the break room's microwave just broke down and you are discussing with your colleagues what should you ask at management to replace it. Two units ? Since the company grew and one microwave for twenty people is not enough. One more powerful ? The old one took like ten minutes to heat even the smallest meal. And then a colleagues, very seriously, suggest that a big barbecue would be more efficient and can heat many meals at a time. If we take the physical constraints (buying a barbecue...) apart since in software we can easily let a bad project dies in the limb of our repository, how can you say "okay, we’ll try it out and see what happens" to them ?
"I have a mobile smal bbq kit at home. I could bring that in for a try tomorrow. But were do we bbq. Fire detectors go off inside the building, so should be outside. Will bring it, but i wont grill out there in the rain, im for a rotating job on that. Volunteers?" There - death by self-execution. And you didnt even murder it by pulling hierarchy, which is always a good way to create a contribution dead company, were everyone just waits for the clock to go forward.
There is more to managing then making decisions (like in the movies). And in reality it should be more of a supportive role. And yes, sometimes you must entertain doomed ideas (like flying bicycles - those wright brothers, i kid you not).
It’s the same thing with code reviews. I make a distinction between issues of opinion vs issues of correctness. I will never let incorrect code get checked in, but if it’s a matter of opinion, then I’m more lenient to let things in.
That said, some of the people I manage are clearly better at dealing with the freedom to come up with solutions than others. I feel like it's often the same people over and over again that try to install barbecues everywhere. I tend to give some colleges more freedom than others, because I know from previous events (i.e. I have a bias towards them) that their ideas might not be so crazy as I think they are. But I tend to stop other colleges, that have tried to install barbecues in the office several times in the past, when they come up with ideas that I think are probably not going to work.
This is key to mentorship and building an actual team. Junior Engineers need help in building their Self-Confidence and grow into Leadership positions and this is the way to do it.
Note that asking you to come up with ideas and entertaining them does not automatically mean accepting it.
You can learn how to recognize them faster, or how to work with them despite their behavior, or practice standing up for yourself, etc.
What did he teach me? He taught me that when I'm sufficiently pissed off, I can be vindictive. I retaliated more than once by doing mostly harmless things like sticking a floppy disk in his PC so it wouldn't boot, and then not helping him fix it so he could do his job (that should date this for ya...). He wasn't computer savvy, and I let him stew in it. That made me ashamed of myself later, and I have never taken the low road again. So he taught me something about myself, and I changed for the better because of it. I still vehemently dislike him and what he did, but that was a long time ago.
What I can do is express that the reflection of myself in that scenario was one I didn't like, and I've become quite a different person overall since then. My conflict resolution methods in general are much more constructive. When I have a problem with somebody I am calm but direct and tell them what the problem is. I used to mistake being blunt for being rude, but blunt (as long as it is kind, and not vicious) can be very effective.
To buck the trend, I'm going to add a few "hard skills" lessons I've learned from managers.
From the best: "Every if statement is death" was an adage of one. He encouraged me to think deeper about whether conditionals were really needed, and at what place they were needed. That mindset helped me write clearer and more easily testable code.
From the worst: In code, "brilliant" solutions are like poems: they're beautiful, they're terse, and they pack a lot of meaning into each line. To mid-level engineers, they have an intoxicating appeal, because they seem like a good way to flaunt their talents. But more often than not, what is really needed is the code version of ordinary prose: straightforward, with a preference for clarity over succinctness, easy for others to understand, easy to edit, and with fewer surprises and deviations from convention than a poem. Your goal should not be to impress your code reviewer with your cleverness but to impress the person who needs to maintain your code three years from now.
if ( unexpected = true )
branch;
do_expected_stuff
Caveat: ways to do things age. Maybe this is no longer true or even slightly advantageous, but so far it has served me.I also prefer 20 lines of simple pedestrian code to 2 lines of clever code. I remind myself that I write for the maintainers, who do not have the benefit of my resident knowledge when they encounter the code.
My rationale is that having done this, I'm left with a smaller combinatoric mental space to work within. Like "if the program counter has reached this point then I know for a fact that X, Y, and Z don't apply - the function would have exited early if they did". And that then means the remaining set of things I have to keep in my working memory is reduced, which makes life easier.
Is that similar to how you see this advice?
Prioritize your backlog to reduce/eliminate 2 AM pages. That's the metric you care about; not tickets, not test coverage, not logging/metrics. All those others are gameable metrics. The only thing that matters other than reducing pages are features, and you'll find that by prioritizing the former, you end up delivering faster on the latter over the long haul.
... has an "else" whether it's written or not. Choose carefully whether to skip writing it, but always know it's there
I try to impress that not as much upon developers, but religiously upon folks writing requirements. Many pieces of code work just fine without the else, but the amount of bugs and rewrites due to someone either not considering "but of course it always succeeds!" or because there was an implied else scenario in their head that they just didn't bother to write down are almost innumerable.
From my good managers I have learnt the value of shielding working employees from excessive meetings and bureaucracy, and trusting people to work out their own solutions while assiting and supporting them.
However, I have learnt so much more (direcly and indirectly) from my bad managers. A couple of examples:
From the manager that everone described as "he is very good technically, ....", I had to quickly learn how to smooth relationships, negotiate with, and jointly arrive at solutions with other parts of the company after my manager would bang his fist on the table, yell about having told them the correct way to do things previously and that the current problem is all their fault before storming out of the room.
From the manager that quickly grabbed full credit for anything and everything done by his team, even when he had zero involvement, I learnt how to be more considerate in making sure I gave out appropriate credit (both internally and to clients) of the people that I worked with.
Worst: If you slather a sub in the hottest sauce available from Firehouse subs, and eat it as a way of proving how tough you are, you can be rendered useless as an employee for the next 36 hours. Very nice guy. But strange in a way not typical to engineers.
Some of my colleagues recognized the transition from student employee to professional, but strangely enough, my own boss never made the mental transition. She continued to treat me like a student in a number of degrading ways, offering condescending advice about preparing for my future and so on. I say this with a 20-year hindsight. I look back at the relationship and still think it was degrading. Within a year I applied to a different department where I got a fresh start and immediately was treated as an IT professional (though junior, of course).
I learned from this that some people are always going to see you like they first saw you. Your mother is going to always see you as the adolescent with the messy bedroom, even when you're 40. Your student job boss is always going to see you as a student.
Yup.
> Your mother is going to always see you as the adolescent with the messy bedroom, even when you're 40.
Nope. She's going to keep seeing you just the same way she saw you when you were the adolescent with the messy bedroom, namely as her little baby.
Even when you're 60.
First impressions matter most !
Not only does your sarcasm need a tell, you need to have previously provided enough evidence that you're not actually an asshole. Otherwise, someone can be sarcastic all day, but no-one's really sure whether they're trying to be funny, or actually offering genuine asshole views coated in the plausible deniability of "sarcasm" for those who don't agree.
"I really can't tell if you're joking" is the first warning flag.
Worst: That pretending you know what you are doing, never asking questions if you don't know what you are doing and having no sense of humility will lead to your demise.
Also memorable was in one of my first contract roles from another, excellent, contractor, "Spend half the day on their stuff, and half the day on your own work. You don't want to raise their expectations."
To clarify that last bit of advice: a contractor should be capable of getting all of the day's work done in half the day (they are good at the job and they don't have to deal with the permanent employees' extra duties). The other half of the day may well be speculative work that the contractor wants to try out that will benefit the company but the management would never be able to say yes to if you asked for permission. Or it may just be real programming.
Exactly right; And that is on a good day!
I like to read about how the "Great Scientists/Engineers/etc." approached their work and have come to the conclusion that they all avoided "busyness" like the plague. Instead they spent a lot of time thinking about What to do and How to do it before embarking on the job itself. Dijkstra famously did everything using Pen and Paper. I am trying to cultivate similar discipline given that the amount of distractions available on a Computer is orders of magnitude more now.
From the best : the value of small talk and forming personal bonds with EVERY person you talk to.
The second one took me a while. We were both leader of team that worked together and things were going great.
I noticed that his team would kill for that guy.
And also that he always seems to know someone that could help. In OPS, in IT, in sales, in the competitor … everywhere.
And then I started to notice the small talk, the jokes, the patience … that makes that guys a nice person to work with.
And then I also noticed that he was leading both of the team, without that being very obvious. And I was not even mad about it. Everybody was exceeding target, we all got a nice bonus that year while having fun, why ruin it ?
I learned a lot from that smooth operator. ( all of that come on top of impeccable technical acumen. That play a role, too )
Policies only matter if the people in power want them the matter. If they like you, they will break policy to benefit you (like early promotions). If you're not their favorite, they will break policy to your detriment (like basing your review on points completed after telling you not to record a bunch of work in stories throughout the year).
That you don't need to actually improve to be promoted. Being a 'yes man' is the easiest way to get promoted.
So, I asked my boss at the time for my own area. He said no.
That frustrated me, and I decided that the best thing to do is to grind some knowledge out of the situation. No better revenge than personal success, right? I slowly became an expert on every little makefile, shell script, Cron job, any little utility program I could get my hands on, I tried to understand it and improve it.
After a few months of this, I went to sysadmin and made a request along the lines of "I'm so-and-so, I work in DBA, I want to interview for this department, and if I I'm more knowledgeable than someone here, I'd like to challenge for that position, and I want my own workspace."
This was ~15 years ago now, it was a bit easier to get away with having one's head up one's ass back then.
Anyhow, I ended up with a role there, and 3yrs later I was the director for that department.
My cubemate never left. I'd still smell his food when I walked through that part of the building to my lunch break. I guess nobody got the last laugh, but I felt proud of myself for realizing I could improve my worth just by working hard at it and using the resources available.
Edit:
I thought of another one. Maybe six months before covid kinda jumped off, a young woman interning for me told me I don't drink enough water and challenged me to drink something like half my weight in lbs, in oz of water everyday. I've been doing it nearly every day since, and it's truly been impactful. Wish I'd done it at her age. My sleep is better, I feel more energized, and I dropped a few pounds before covid came. They came back. But nevertheless, hydration is a big deal.
So for a 200lb man, it'd be 100oz. Just under a gallon.
It seems like a lot at first, and for the first few days I peed a lot, but now it seems normal.
Granted, I'm doing myself a small service by saying 200, but that's just a few covid pounds.
Worst: The more confident someone is, the more likely they are to be full crap. But - just because you don't like someone, or they're full of crap doesn't mean their wrong and/or you can't learn from them anyway.
When I became a reviewer myself I resolved never to be like this. If I didn't like something, I would always indicate what change I was expecting for the next review to pass and also why the change was necessary - what specific problem was being addressed. If I didn't like something but couldn't say why, then I taught myself to not say anything at all, typically because it was a cosmetic difference in my preferences vs. the authors. I also realised that a really good technique was to have a quick chat with authors before they had done too much, especially to make sure we all agreed on the aim and purpose of the doc, and my review criteria - to avoid me introducing unexpected hurdles at the last minute. This became a good way of turning the review process into an iterative learning process for junior authors.
I learned to run code without re-reading it from a bad coder. I used to spend a few mins reading code I'd written to double check it. Then i worked with a guy that just would run code, it would error, my heart would jump, but the world wouldn't explode. So I do that too nowadays a little bit sometimes. Just run the code after writing it without rereading it. It's scary but works 85% of the time. thing is you can run code twice and let the console tell you the issue often quicker than you reading it carefully. (be careful with this tip.) .i.e there's a time to do it and a time not to. i.e. if your changing some css block, you may not need to reread it 5 times before refreshing the page. but if you are about recursively rm some dir then maybe check.
Touch typing is a special technique. Typing and touch typing being distinct things isn't a "way of thinking", it's a clear fact. It's not open to interpretation.
The keyboard is an instrument. Anyone can use it without learning the proper technique, but the technique helps a great deal. That's the whole point.
It is greatly comparable to musical instruments. For instance you can learn how to play the guitar yourself, but if you know the proper technique, you'll have better mastery in a shorter time. This is why it needs to be teached, especially to knowledge workers, who type, type and type all day long.
Maybe the skill you currently have is enough for you, but you shouldn't dismiss the proper technique, especially if you haven't tried it (you sound like you didn't really).
Though if you can answer yes to all the questions below, then you probably don't need the technique:
- Can you easily do 80+ wpm whether it is prose or code?
- Do you have more than 95% accuracy at all times?
- Do you never (no exceptions) look at the keyboard?
These things all make a difference. Having less friction with the input instrument results in a higher stamina in a knowledge worker, which means more productivity per unit of time. Few realize this.
Worst: Sucking up to people and repeating competent people's advice can get you a looong way up to being a C-level while the competent people remain at the lowest levels of the hierarchy.
Reading through a post-mortem with the active voice makes a much more clear picture to me. It becomes easier to understand the events that led to a problem. From there the key is to figure out "Why did the system not prevent this mistake".
Worst: The people who talk about others will talk about you
Worst: Don't tell employees you pay them so they shouldn't have to use Google.
If you sit in IT people bubble then you might feel ashamed that you have to look up stuff all the time.
But technicians always had books like "mechanics guide" or "lookup tables" and they mostly knew which things to apply and where. Without training and experience you don't even know what to look for.
IT bubble people overestimate non IT people level of understanding, I see how "normal" people still struggle with basic text editing or using browser features that are obvious to me like "open link in a new tab". I am not talking here about my grandmother but even people in their 20's but just those non IT.
The same goes for knowing when to pay attention to Stack Overflow or GitHub and when not to. ;-)
In fact, it would probably be funnier if it were $1 to implement a new feature with an npm package and $1999 for knowing which npm package to use.
That said, usually when I search HN and stick to recent posts/comments within the last year, the advice often proves useful to some degree, as when experts share their direct experiences. For less technical concerns the same can be true of Reddit.
The technician thought, poked, checked, asked a colleague.
Finally he got out his phone, googled, and disconnected the batteries for about ten minutes. Then reconnected the batteries, and all was well.
I guess something needed to be put to death and reincarnated.
He laughed about it and told me how he fixed it. I laughed too and thanks him, but sometimes that's what you do, and you have to know enough to select the likely or possible out from the unlikely and implausible.
From best colleague: 10x, 100x, 1000x... developers are real. I also learned that making bold, controversial claims will yield respect dividends in the future when they turn out to be true. For one of my past startups, I was working closely with the CTO who was at least a 10x or 100x and some of the stuff he was saying seemed to defy a lot of the industry practices at the time. I didn't take what he was saying very seriously at first, but over the years, I ended up discovering that essentially everything he said was true and lead to huge productivity increases. It had a big impact on me to understand that software development is a craft which can be mastered on a whole different plane beyond what the vast majority of developers can imagine. I consider a lot of his teachings to be 'trade secrets' and I try to pass them on to other developers I care about (especially open source collaborators).
One of the lessons I learned in my junior years is that I used to write CSS with a lot of nesting and relatively short class names (I used SCSS which made nesting easier) - The CTO kept telling me that I should avoid using more than 2 levels of nesting and to use long descriptive class names. I felt that was against the whole point of "cascading" in CSS. I soon discovered (during the first redesign) that when you have a lot of nesting in the CSS, it becomes extremely difficult to refactor the layout of the application; moving containers around breaks the layout every time. Whereas if you have a relatively flat CSS, you can move around components easily without breaking anything. It seems so obvious in retrospect.
I also learned the importance of having one source of truth and the importance of making sure that each kind of data flows through the system in a single, clear direction (or else you can get glitchy behaviour with certain kinds of realtime data). A common one is to make sure data flows from the source of truth. For example, when you click a component, it should update the URL hashbang, then other components should react to the change in the URL... Don't make the components react to the click directly and only update the URL hashbang as a side effect (because the click event could conflict with the URL change event in some edge cases; e.g. cause the UI to be rendered twice is a common issue). The URL has to be the source of truth.
Another critical lesson was about separation of concerns and the importance of being able to justify all technical decisions using simple non-technical language.
But there are so many lessons. I was fullstack so I learned a lot of backend tricks as well. A different one seems to come up every day when I work with other developers on a complex project. I try to explain the reason as much as possible because sometimes they sound counterintuitive (or I should say counter-narrative) and they're not usually silver bullets so it's important to convey the nuance as well.
That said there are projects for which a developer could be infinity-x compared to other regular developers. For example, a highly complex project which regular developers do not have the capacity/talent to complete, ever... Just imagine some very complex project programming a quantum computer or certain kinds of blockchain or distributed systems projects; some developers will never be capable of delivering such projects. It's beyond their innate ability and capacity for learning.
Project complexity maximizes the utility value of highly productive developers. It would be difficult to identify a 100x developer on a simple project (they might only appear as 2x) but they would stand out as a definite 100x on a complex project.
Worst colleague taught me to be loyal to people and not to companies. You can be friends with people, but not companies. Friends will reward loyalty and sacrifice, companies just want you to think they will.
Bests: Hide your ambition the lazy will try to block you. The ambitious will try to remove you.
Worst: Stay in your lane.
The actual decisions have been made in the days, weeks, sometimes months leading up to the meeting. And the amount of human input going into them can vary from very little to gargantuan.
I believe there is even a saying that before an important meeting takes place the people required to attend it will hold one or more unofficial meetings to make up their minds about the topics on the important agenda.
Worst: but it's amazing how long a person can last without doing much at all!
And it was solved in one go.
However, that might also go hand in hand with an "blameless post mortem" culture, because if one is trying to solve a problem and cover one's ass, now there are two problems
Worst: be open to integrating the solutions of other teams, that may conflict with your own. Purity of your solution is irrelevant if others have gone in different directions already.
Kicker: these lessons were learned from the same person.
From outright jerks: learn to let go. You can’t control everything, you don’t know everything, and you need to take a break from work to get some perspective.
From my favorite colleagues: put humility and service to the customer first. Be selfless with junior people. “We step out ... seeking only peace and friendship – to teach, if we are called upon; to be taught, if we are fortunate.”[1]
1 - https://www.unf.edu/~n00006757/astronomylectures/Voyager%20M...
My most annoying/disappointing colleague, who I was fooled into hiring into a senior position, taught me many, many lessons .. but the most positive was that speed to market trumps attention to detail 9 times out of 10. Seems obvious now!
Best colleagues I have had would point out something to be fixed / improved, and immediately suggest a tentative solution. Worst colleagues would just blame others (major red flag) for any issue they encounter, and never put energy in solving them.
Worst: Fire them all really really quickly. People that are bad after week 2-4 will never not be bad afterwards.
The simplest thing to do is show the candidate exactly what they are going to do. Don’t describe it, actually show the code base and the devops setup and the meeting schedule and the reports that go out and the planning documents and knowledge base and whatever else they’ll need to engage with. Tell them their exact goal for the first year, and exactly what they get if they achieve it.
In other terms, give them the SOP, OPORD, and pre-flight checklists before they reassign. What is obvious to you is not to them.
Worst: Giving the benefit of the doubt for more than a few times will inevitably end in a disaster if the person is beyond redemption. The easiest way to recognize somone who cannot be helped and their work cannot be salvage is to look for persons that don't accept help and act like their work is perfection.
Worst : Many of the co-workers/ department heads etc. etc. have moved ranks above me exponentially and yes because of their hard work. Congratulations to them. But sometimes if I have to reach out to them or they need to reach out to me, they address me as "Sir". "Hello Sir, How are you Sir?" I feel terrible and I feel like they are mocking me for being a looser for not having achieved as much as they have.
Worst: some workplaces allow the negative workers on the team to get away with anything.
There is a deadline or finished software, never both.
If you were a CEO once, people will hire you as CEO again, even if you were horrible.
Some tasks like interviewing and writing exams are distinct skills you can learn and might have nothing to do with the actual work you're required to do in a job.
From bad colleagues - Protect your direct reports from the organisation (politics, snatching away of bonuses etc.) - Junior reports cannot function without a clear task. You need to handle the org and make sure they get it. (this was summarised in a great article - "context down, information up" - https://jacobian.org/2021/apr/19/the-fundamental-purpose-of-...) - Respect everyone and mentor juniors who look up to you. - Don't accept leadership positions if you can't actively play office politics.
Worst: be competent, be rude, don't collaborate
Worst: Good people can sometimes land in the wrong role. Change conditions before passing judgement.
Best: Focus on the project and making it good. If you are correct in your ideas then good. If you are wrong but the project is better then good, everyone wins.
Worst: "perception is reality", coming from a COO that had no idea about technology and what people do but they were second in command and making a lot of decisions.
It taught me that you have to play the game and sell your accomplishments so that upper management sees you. You do not have to market yourself but do not complain about not getting credit for the amazing things you do if you do not sell yourself.
(That's a subthread off of a _rather_ interesting Ask HN)
Best colleague: Knew how to time manage. Knew what was priority and what wasn’t. She also knew half her job was managing her boss’s expectation. She was never late for any work because she knew how to manage up.
Worst colleague: A programmer that played more political games and sucked up to the boss than work. I mentioned his code was not up to par multiple times. The boss ignored me because the other colleague loved sucking up to him. He kept on talking behind my back. After I left, they couldn’t launch a product for 1 full year. Turns out I was the only one lifting the entire team.
Worst: Letting toxic people get away with insults because they're good at their job.
Okay, that's what happened, but what did you learn from it? Presumably you're not always their boss and in a position to single-handedly do something about it. How should one deal with it instead? Or was the lesson about recognizing the situation?
* Be supportive and non-judgemental, not dismissive.
* Really listen, hear the other person out and validate them, even if their concept or idea sounds dumb. Personal goodwill combined with strengths in the domain go a very long way.
* Be willing to share, explain and help others understand things that are new without treating someone like a dummy.
* Be thorough, systematic and organized, and keep working to improve ourselves, our systems, and our efficiency.
* Take the effort to make personal connections, and more importantly, to nurture and grow them.
* The past is the past - though some bad stuff may have gone down, look to the future, to how we can build and grow.
* If things are not working out, make changes, get it working, and don't be afraid to cut my losses and change track.
* Take responsibility for growing myself, I am accountable for my career and well being, invest in myself for the medium-term and for the long-term, keep learning and make sure it's something strategic. Time is always limited and there are a million things where I can waste time. Figure out what gives me the best ROI and invest there. These are the sort of time and energy investments that take time to bear fruit, and when planned and executed strategically they are well worth the effort.
Worst:
* There's a huge laundry list here, and I'd rather not go into the details. Others have covered this.
I regret looking back at my worst moments.
He didn't double-task and constantly check his computer, phone or read/sign papers. I had his full attention while I was there.
It's an attribute that stuck with me.
Best: they believe others are capable of achievement, and they offer help
Worst: After hiring people, act as if they are trying to damage the franchise on a daily basis, give them very little responsibility, remind everyone the place only runs because of the boss's efforts and genius. Give juniors no path for monetary or career advancement.
Worst: some people will put all their effort into the performance of working but never actually work. You risk your own job calling it out because their speciality is hiding their incompetence.
As an overall observation, the happiest colleagues I've had have been the ones who are good at their jobs and care about producing good results, but also know when to let go, and to decouple their jobs from their personal lives. They were on time, did their jobs well, were good colleagues and always helpful.
Clock in, do good work and be proud of it, clock out.
Some people want to go for the high risk/high reward 70-hour week stressfest, and they always seem to be worse off for it, to try and be in that 0.1% who succeed in the struggle. That's their choice, but it comes at a too high cost.
Worst: two here...
If something's hard to understand, it's probably just done poorly.
You may outpace others. Just help them as you can.
Best colleague: Talk openly. Engage in discussions. Conversation about conflicts and criticism is good.
Worst colleague: Don’t engage. Shitty people are just shitty people.
Worst: almost no business deliverable is one tenth as important as the people telling you to give up your time, strength and sanity in order to achieve it will tell you that it is.
Heaven is other people.
From the best: "Ambition is the will to try what others won't."
Best: always be curious. When you spot a bad idea, be especially curious about the parts that will go wrong. Most of the time, people will figure it out and change course without a conflict.
Its very common for people to come to you with a suggested solution rather than telling you their problem.
Can't count how many times I've been assigned to build feature X, and upon further digging realized it will not solve the requester's problem or won't do what they think it will.
Life is too short. Or, to put it another way, life is too long.
* If you screw up, acknowledge it without passing the buck, take responsibility for it (works best if you have already worked out a mitigation strategy and timeframe to implement and can communicate this effectively)
Worst: a programmer with a huge ego. He was extraordinarily defensive about his work and this made the whole team unproductive.
Worst: Code should be designed for users, not any individual engineer's philosophical preference.
Worst, the way it is written left me a bit confused.
I understood:
If someone wants "perfect code" because of "software craftsmanship". Where "users are stupid" because they should learn how to use the software. It is really bad way to do software.
Quotations mean beliefs of person having such of a approach.
> [ . . . ]
> Quotations mean beliefs of person having such of a approach.
You can learn how not to do something from observing someone doing things wrong.
From the best: abstract only when needed.
Worst: Apparently knowing how to use excel efficiently isn't better because manual calculations prevent errors.