2. Are willing to help with getting proper requirements
3. Don't need a JIRA task for everything
4. Don't say they are done if something is untestable
5. Are willing to do stuff other than their skill (eg. one of the graphics required for the project is too big, top engineer opens up gimp, resizes and continue. Bad engineer will report to manager that design team did shitty job, reassign JIRA ticket, write two emails and wait for new a graphic)
6. Top programmers deliver well packed, documented software, keep repository clean with easy setup steps accessible for everyone.
7. Top engineers enjoy what they do, and are making the project enjoyable for everyone, keep high morales and claim responsibility
other than avoiding hurting people's feelings. why not? (honestly asking)
bad code should be called out. It's reasonable to feel frustrated by bad to terrible decisions that your predecessors made and left you to clean up the consequences of.
when a group of people is presented with a shitty situation verbally commiserating with your co-sufferers is a form of group therapy. Yes, it has to be tempered with hope and humor, but... bitching is good. Cynicism actually helps ward off burnout (barely, but it's one thing that contributes to warding it off).
“Bad code” is entirely subjective based on unclear standards. We had one engineer bitch about some solution that wasn’t “elegant” enough for him and he proceeded to waste 2 days “fixing” it.
There's a huge gap between bitching about bad code and coaching someone to refactor code into a good (or at least better) state. A code review is ideally the latter.
However, sometimes the sign of a senior is the ability to distinguish when something isn't a fire and should go through the proper channels... so maybe I'd also add:
8. Knows when a JIRA task should be necessary before starting work.
> Are willing to do stuff other than their skill (eg. one of the graphics required for the project is too big, top engineer opens up gimp, resizes and continue.)
This kind of thing can be dangerous in the wrong sort of organization, be careful about stepping on other people's toes. What you call Bad engineering is adaptive behavior in an organization like this.
Bad organizations incentivize bad behavior and punish good behavior.
I read this like "good engineers will unblock themselves with interdisciplinary action". I think the follow up on that example involves getting a resized asset from the UI team, but that should not hold up development and testing.
My personal heuristic: if it is worth doing, and it takes less than an hour -- just do it now. Organize your team so engineers feel free to knock off quick tasks at their discretion.
If you try for an hour and it's still not done -- make a ticket.
There's nothing more annoying than seeing the same trivial task get shuffled around 4 sprint planning meetings, taking mental overhead from 8 people.
And nothing comes out of sprint planning with less than a quarter day allocated. You've turned a 20-minute task into a whole day of wasted effort.
I totally agree with this, providing your team is strong and motivated enough. As a contractor, this is usually the case for me, but definitely not always.
My point is that the overhead of writing up a ticket description becomes a significant fraction of the total work involved. Write a commit message if you want it documented.
There's no need for a ticket for small tasks, unless you are being evaluated on number of tickets closed (which is a separate problem)
On the other hand, being forced to write something up gives you extra time to think about what you're about to do. I've had many experiences when I was about to commit what I thought was a trivial change to the code, but then suddenly realized that it was going to break something.
Like all things in life it depends on the team and workflow. I have my PM’s make tickets because many times I am in the middle of a different feature or bug and don’t want to have to have the mental load of remembering what the issue was. Secondly I work with very solid PM’s who document the ticket very well and it saves me time having to reproducing the issue. My team does have a lot of tickets but we make it work for us and our process flow.
You can also just create 1 ticket with a bunch of small things.
The devs on my team are encouraged to move tickets around and plan their time however they want, but JIRA allows our product, design, dev, and qa teams to coordinate without being in the same room every day. It's just another form of async communication that helps us make sure we're shipping everything we promised, and fixing all critical bugs before the end of the week.
Yes, it's basically the same for us as well. And we do group together smaller things into one ticket often.
For us tickets are most important to track what gets included in releases and patches, and to tell QA to test our branches (and we almost always require QA to test our branches before they're merged).
Just do it now maybe works on small projects, but large projects that span multiple teams and stakeholders typically have enough little tasks to complete that “just do it” might be referring to 1 of 50 different things.
You need some way to prioritize and work against those priorities, typically measuring impact or some variation of ROI.
I think having a ticket also helps coordinate things if your working between global offices. Also, having a ticket helps others pickup if your out of the office. This has saved my team many times.
Bitching about legacy software is often necessary if you want something to change: pay off technical debt, additional time, migrate third party software to a newer version.
That’s a different thing, though. Proposals for change which are backed up by examination of the costs and benefits are welcome. Pointless complaints like “why are we still using PHP for this system, we should retire it” without any analysis of why is much more like “bitching”, is annoying, and something that I’ve noticed almost all less experienced developers do.
Agreed. I've spent most of my career cleaning up other people's messes. Bitching about legacy software a) makes it clear that the prior practices are not acceptable and can't continue (no tests, ignoring edge cases, ignoring users, all the standard stuff that makes up legacy code) b) helps keep you sane.
The difference, which I hope the original author was alluding to, is that experienced dev accepts that legacy software is a part of life that has to be accepted, and dealt with, and that fixing it / keeping it on life support is frequently the right answer. Whereas junior's see it and run screaming or say there's no hope and it needs to be rewritten from scratch even though they don't really know the details of what "correct" behavior is.
You’re writing tomorrow’s legacy code today, so be kind about “other people’s messes” because you’re going to be the recipient of that same criticism one day.
Many things are not testable. Not sure I'd use that as a reason to judge someone down. In fact all the most productive teams I've worked on or with, don't have anywhere near full test coverage. The best had none in fact.
It isn't about test coverage, it's about feature completeness.
For eg. One feature require backend & frontend work, after a week of work engineer says that this is done. So you ask him to demo, and it turns out he is doing a backend demo with some dev tools.
From a product perspective nothing has changed. Top engineers understand, that no one cares that only one part is working, they know the end user and will not bother managers/product owners with partial solutions.
So you mean, it should work? Not sure I'd agree with that being a distinction among great programmers as much as a minimum bar of entry to call yourself one.
Is this common outside of organizations where people are told to not work on anything that is not a JIRA task? And do people that do that not come mostly from such organizations?
* Better googling. Time-restricted, url restricted, site restricted searches. Search with the variant parts of error messages removed.
* Read the source of upstream dependencies. Fix or fork them if needed.
* They're better at finding forks with solutions and gleaning hints from semi-related issues.
* Formulate more creative hypothesis when obvious lines of investigation run out. The best don't give up.
* Dig in to problems with more angles of investigation.
* Have more tools in their toolbelt for debugging like adding logging, monkey-patching, swapping parts out, crippling areas to rule things out, binary search of affected code areas.
* Consider the business.
* Consider user-behavior.
* Assume hostile users (security-wise).
* Understand that the UI is not a security layer. Anything you can do with PostMan your backend should handle.
* Whitelist style-security over blacklist style.
* See eventual problems implied by various solutions.
Ah, a personal favorite of mine which often makes other people uncomfortable.
1. Users are like Marines, if it can be broken, it will be broken. If it's use is not clearly marked, it will be used incorrectly. If it can be fucked (literally or figuratively), it will be fucked.
2. Users are malicious and are actively trying to backdoor everything you do. Why? Because it's the first thing I do with a new product / what I do with the competitions products.
3. It is the developers responsibility to mitigate the above cases.
Ah yes. Should be revised to "unless it is clearly marked, it will rarely be used as intended. Even when clearly marked, users will misuse in ways you couldn't imagine"
True. Clear markings are like a deterrent control in security. They can mitigate damage but something that prevents wrongful use needs to be used in the end.
Let's say there's "slowness" on a route in a Rails app. A
really junior engineer might start blindly optimizing.
A mid-skill engineer might start by trying to diagnose the problem, and usually will get somewhere, but occasionally they'll run out of ideas. They might assume it has to be one of the things they've seen before, but their list is not exhaustive.
A top engineer will start by looking at the big picture and generating hypothesis. They will usually be able to generate more hypothesis and have more ways to test them than less seasoned folks. Often this is because they've seen more things.
For example, off the top of my head, the slowness could be:
- n+1 query problems
- slow remote service calls
- streaming to slow clients
- object allocations
- loops in loops--bad big O
- resource limitation (memory, CPU, IOPS)
- database connection limits
- worker process/thread limit
- frequent cache misses
- noisy neighbor problem
- lack of indexing and data size growth
A top engineer will run through their own list, and for each, they have some ideas on how to check on that item or to rule out what is unlikely. Some of them are trickier than others. The key is they have more angles that they'll know off-hand to follow up on.
PostMan allows you to send any query to a server. When building an API, you expect some required parameters (ie. "login" being a string) but postman can send or not send the required login parameter and it might or might not be a non-empty string as expected. On the other hand your web form will consistently send the login parameter and check it is a non-empty string before sending to to the server. So it's straightforward to implement the API assuming your required parameter will always be sent but in practice it's not always the case.
The point here is great engineers make sure the API answers correctly even if the query is messed up.
To add context to the other reply, it’s not uncommon for penetration testers to have Postman in their toolbelt, in addition to traditional security tools like Burp, Metasploit, sqlmap, etc.
Sure. You can draw conclusions about what will be a good design, or where a problem is occurring, or what you should optimize from doing "the math."
The simplest example is probably using a Big O approach to view how to walk a large data structure. The math works out that certain approaches to walking it are cheap enough in terms of total operations at small scales, and incredibly expensive at large scales. By doing the math, I mean that you can both know when you can get away with sloppy approach, and when you have to be careful to not touch each object more than once.
I didn't just mean big O, though. You might do calculations like "if every user creates these structures in a database, every 5 minutes, we can expect that this table will have n records by time y. If that happens, one, is the size tractable, does it need an index, and do we want to reconsider this approach in favor of a cleverer design that can avoid this query? Things like that.
A recent example for me was researching max zookeeper writes per second and deciding if it can be used for super high volume writes in a system. The conclusion, based on some napkin math of the system needs, and some benchmarking of ZooKeeper was that a different tool needs to fill that spot in the architecture because it was too write-heavy for zookeeper.
"Correct enough" is the phrase I usually use here.
Knowing where on the scale to set that mark requires being able to bridge speed of implementation, execution, maintainable, upgradability and the overarching business goals you're building for.
So really a broad range of understanding that only "excellent" senior developers will possess
Much like a codebase, some of the brilliant engineers I've met relish the video games that lets them scour around the universe, think about strategy, and get into action. It's like watching someone attempting an Olympic weight-lift move.
One thing I havent seen posted which I mention in threads like this one anywhere I am online: humility
I don't care how good you are, if your personality is hostile and toxic, you're not making the team productive. If you can't take honest feedback during peer review, or QA or even from the client, then you need to evaluate why.
The best engineers I know are humble. They don't freak out when you point out a bug, they look into it and figure it out, then they share with you what they found vs what you found in order to determine if it is indeed a bug. Then there's developers that think all their code is perfect and sacred. Nobody likes working with those kind of developers.
Humility is underrated. I know a few devs that are not only a pleasure but inspiring to work with. Unfortunately few appreciate this virtue, schmoozers always get ahead.
There is a grey area where a non-technical manager wants to make a decision without understanding the long term impacts of that decision. Is the good engineer submissive here and go with the flow or does the good engineer put their foot down and suggest that that is not a good idea?
No, of course not. Humility doesn't mean you become completely submissive. There's a fine difference between a great engineer blurting out "THAT WILL NEVER WORK, WHAT ARE YOU EVEN SAYING!?" and... "Hey, Jim, I think that's a reasonable proposal, however, I have some concerns ..." which do you think sounds like the professional / good engineer, and which one sounds like a Junior whose ahead of themselves?
I've met people who literally believe humility to be a weakness, I think a lot of people misunderstand what it means to be humble these days.
It is one thing to understand that you are not perfect and you could learn something from everyone and to respect your co-workers.
It is another thing to be a legitimate expert and to not voice your opinion to avoid conflict. I have seen smart people who avoid direct conflict at all costs. Even if that means working on something you know is a bad idea.
They do it out of fear of conflict probably, or in other cases you're so burned out you don't want to argue anymore. I've been burned out enough to where I didn't care anymore I just wanted it to be over with.
Yeah, I do think it's a superpower to, even if you "know" something is right or wrong, to put it in the form of a question about a risk. You frame the other party as possibly having information you don't.
It opens up two new good paths: 1) the other person actually having important perspective you don't, and you learning that in a civil way, and 2) the other person recognizing the problem, adapting the plan accordingly, and still feeling ownership over the plan.
It also opens up a new bad path: 3) the other person being ashamed of not having this perspective and digging in on the bad plan.
But if you're seeing #3 regularly, that's a job you need to quit ASAP.
Know when the juice is worth the squeeze, whether it be a refactor, a political fight, or even the job itself. There are not a lot of hills I'll die on anymore, while when I was younger everything seemed life or death. Now I got other things to worry about.
They have a great mental model of the inner workings on the product. Even for a part of a code they haven't seen in a long time. When you debug code with such a person, you notice that they seamlessly translate the piece of code on the screen to the mental model and back (it probably takes hours for Jr engineers to piece those together). Neo deciphering the matrix is a good analogy.
overengineer and prematurely optimize everything because a pragmatic approach to software development is too boring and you couldn't use a lot of fancy tools and features otherwise.
tongue in cheek, yes, but with a grain of truth, I'd argue.
I'd argue that those who do so are "top engineers", but not actually top engineers. They have the reputation (especially in their own minds), but they're not the real deal.
The best engineers I know do their best to discover the core problem. They ask why a problem should be solved. They also challenge “known” assumptions and do their best to discover the real constraints to a problem.
1.5. Be willing to rethink the architecture when it turns out problematic. I have seen systems that probably looked good as a diagram before a line of code was written, but had to work around their own architecture with gross hacks.
Architecture is important, but organizations employing "software architects" tend to be bad at software.
The second part may read as a non-sequitur. The connection is that in organizations that have separate architect roles, architects are shielded from their mistakes because they don't work on implementation, and their work usually isn't questioned.
The worst thing I remember is a web API where some call could fail but didn't tell you, it just gave you some kind of plausible looking inert data. The call to query system status was separate, so there was always a time of check / time of use problem. Also there was a transition period when the original call did return an error but the system status API didn't yet. Nobody (I hope) comes up with such a disaster while implementing and testing it.
They are strategically lazy, putting a lot of thought into how to simplify at all levels. Great engineers loathe complexity and indulge in it reluctantly. Solutions should never be more complex than what the problem domain demands.
A corollary to above: they use language features and constructs to solve problems, not to show off how smart they are by constructing the most "clever" bit of language gymnastics with which to waste the time of those who have to maintain the code later (including the author!).
They know assembly language and the basics of CPU architecture regardless of what language they use so they understand what is actually happening. They also have a grasp of other aspects of the system like networking and storage even if they do not do much with those directly.
They know the history of computers and computing and how things have been done at various points in the past. This helps them spot fads and rediscoveries of old things that have been tried already as well as generally deepening understanding.
They are skeptical of fads and don't instantly adopt whatever thing is trendy unless it's a genuine improvement.
A lot of good points were made. I'll add one I think was missed (and I'll avoid the title "engineer"): A top developer knows that the stack does not matter to the user. The stack provides interest or a familiar or economical grounds to said developer but the user - they couldn't care less.
One thing I haven't seen mentioned yet that I think to engineers do is read the side code of the third party libraries and frameworks that they use. Usually when they are trying to figure why something is broken, but sometimes just when they are learning how to use it.
The ability to quickly learn enough about new subjects to be useful. New technologies or APIs; new algorithms; mathematical or statistical subjects; and most importantly, your problem domain. Some of this ability is a skill, "knowing how to learn", which covers google-fu, reading comprehension, prioritization, time management, etc. Some of this ability comes from having enough aggregate experience that new information just clicks into place like jigsaw puzzle pieces. Some of this ability comes from the confidence of having climbed enough seemingly insurmountable learning curves that this next one is "just another day at the office".
A sign you're doing this wrong: "I need training!"
#2 Understand The Customer
IMHO, the best engineers are half product managers. You can easily get a 10X improvement in productivity by building the right features and not building the wrong ones. Yes, professional product managers are great, but technical limitations often impact product design. A great engineer knows when to push back or suggest alternatives. This requires empathy not only for the customer, but for the product management team. This ability is also tightly coupled with #1 - you need to quickly come up to speed on the problem domain, whatever that may be. If you wan't to be a great engineer, don't study algorithms (until you need an algorithm, of course), study the particular business that you're in.
A sign you're doing this wrong: "Whatever, just tell me how you want it and I'll make it that way!"
As a long-time product manager, I completely agree that customer empathy and domain knowledge go a long way, especially around tactical needs. The easiest way to start is to just ask yourself, "If I were using this product/service/feature, would I want it to work this way?"
That comes right before getting customer data or asking them, right? It's easy to make up just-so stories and completely disconnect from customers' reality if you're stuck in your own head.
Customer data and asking customers isn't fool proof either. That's why the best shortcut to being a great engineer/product manager/designer is working on stuff you would use yourself to solve a problem you really have. That way you limit misinterpretations.
I would also like to add that business problems to be solved should not be driven by technical desires, rather accompanied. The problems being solved have a high possibility of losing track if the tech starts controlling it. I have seen instances where people have first set their minds on the tech problems to be solved and then deriving the real customer need from them - this is wrong and does not go a long way.
Every PM needs to do that, but working directly with a customer isn't always an option for the engineer. Point above is just to point out that thinking about whether you'd use or pay for the service yourself goes a long way in changing a mindset and building empathy. It's not a recommendation to make up stories.
> IMHO, the best engineers are half product managers.
Absolutely agreed. I think this is part of the source of the endless fighting around "10x engineers". In most discussions where people are trying to "prove" their existence, they will usually bring up things that are outside of the scope of a traditional engineer, that involves some kind of outside/customers/business perspective on a problem/solution.
I think the author is thinking more of someone who is insisting they cannot proceed without being given training, versus someone who is doing everything they can to keep up and could benefit from some training to stay on top of things.
"I need training!" says that you need to figure out how to make me good at this role. It shifts responsibility onto the organization; if I suck at the job, it's someone else's fault. A great engineer figures out what to do no matter how dysfunctional the organization.
It's not that it makes you a bad engineer if you can't thrive in an imperfect organization. All organizations are varying levels of imperfect. Great engineers figure out how to be great anyway.
What if training is simply the most efficient way to get the required knowledge and it has nothing to do with the level of perfection of the organisation?
I don't think Googling is the fastest way to learn things in general.
But I was mostly thinking of stuff that can't be found on Google, e.g. the last time I said I needed training was when I was going to do maintenance at some company, on some internal application that I had never seen. I didn't know the domain either. But I had heard that a two-day training course for users existed (also given by internal people). So I said I wanted that training (developers before me hadn't), people thought that was a good idea and it turned out to be very helpful.
Sometimes, it is completely justified: Taking on responsibilities, or just getting work done that should be done, requires time, efforts, followups, etc. While such work is often menial, it frees up the organization keeping systems alive and breathing, avoiding firefighting and hero-saving episodes later.
Then some manager tells you, "we need Kafka, can you provide our solution for that early next week?"
THEN, you say "I need training!" (necessitating relief from other duties).
Arguably the best engineers are also good designers, and everything else related to the product.
Some of the best ones I know dabble in things like art and music, and do it better than most of the people who are full time specialists. It reminds me sort of like watching sports, where a world class defender can attack better than a second division forward. Maybe they just have really outstanding soft skills.
> Arguably the best engineers are also good designers
Is there an implied caveat that this applies mostly to Frontend engineers? Or do you think this is something Backend engineers should also be good at? Or I suppose there is third option that great engineers should do both.
Good design in my opinion extends beyond the GUI. It encompasses api design, software architecture, system architecture even the version control and deployment systems.
Well, a lot of them are "full stack". Full stack seems like a fantasy but this really seems to be the case. I know plenty who work front end for a couple years and switch to a back end role just because they want some back end experience. Some even switch to a sales role.
I think it's part of the learning process, where cross-discipline helps them learn a lot faster. Or maybe it's the attitude, where they work to learn as many things as possible rather than optimize for some high paying specialist role.
154 comments
[ 6.0 ms ] story [ 288 ms ] threadhttps://www.youtube.com/watch?v=9LfmrkyP81M&app=desktop
2. Are willing to help with getting proper requirements
3. Don't need a JIRA task for everything
4. Don't say they are done if something is untestable
5. Are willing to do stuff other than their skill (eg. one of the graphics required for the project is too big, top engineer opens up gimp, resizes and continue. Bad engineer will report to manager that design team did shitty job, reassign JIRA ticket, write two emails and wait for new a graphic)
6. Top programmers deliver well packed, documented software, keep repository clean with easy setup steps accessible for everyone.
7. Top engineers enjoy what they do, and are making the project enjoyable for everyone, keep high morales and claim responsibility
bad code should be called out. It's reasonable to feel frustrated by bad to terrible decisions that your predecessors made and left you to clean up the consequences of.
when a group of people is presented with a shitty situation verbally commiserating with your co-sufferers is a form of group therapy. Yes, it has to be tempered with hope and humor, but... bitching is good. Cynicism actually helps ward off burnout (barely, but it's one thing that contributes to warding it off).
This! One hundred percent this!
However, sometimes the sign of a senior is the ability to distinguish when something isn't a fire and should go through the proper channels... so maybe I'd also add:
8. Knows when a JIRA task should be necessary before starting work.
This kind of thing can be dangerous in the wrong sort of organization, be careful about stepping on other people's toes. What you call Bad engineering is adaptive behavior in an organization like this.
Bad organizations incentivize bad behavior and punish good behavior.
Genuinely asking: how so? Tickets are not just some bit of bureaucracy, they are also a living log of what has been done and why that thing was done.
And as bonus points it can effectively prevent people from gobbling up only the work they want to do and leaving the shit for everyone else.
If you try for an hour and it's still not done -- make a ticket.
There's nothing more annoying than seeing the same trivial task get shuffled around 4 sprint planning meetings, taking mental overhead from 8 people.
And nothing comes out of sprint planning with less than a quarter day allocated. You've turned a 20-minute task into a whole day of wasted effort.
Sure, but that doesn't mean you can't create a ticket for it. It just means that you have tickets which fall outside your sprint planning flow.
There's no need for a ticket for small tasks, unless you are being evaluated on number of tickets closed (which is a separate problem)
You can create tickets for every small thing, but it might not be very efficient.
The devs on my team are encouraged to move tickets around and plan their time however they want, but JIRA allows our product, design, dev, and qa teams to coordinate without being in the same room every day. It's just another form of async communication that helps us make sure we're shipping everything we promised, and fixing all critical bugs before the end of the week.
For us tickets are most important to track what gets included in releases and patches, and to tell QA to test our branches (and we almost always require QA to test our branches before they're merged).
Huh... you've never had 10 things that are worth doing that take less than an hour? Or did you just line them up and work 10 hours that day?
You need some way to prioritize and work against those priorities, typically measuring impact or some variation of ROI.
Bitching about legacy software is often necessary if you want something to change: pay off technical debt, additional time, migrate third party software to a newer version.
The difference, which I hope the original author was alluding to, is that experienced dev accepts that legacy software is a part of life that has to be accepted, and dealt with, and that fixing it / keeping it on life support is frequently the right answer. Whereas junior's see it and run screaming or say there's no hope and it needs to be rewritten from scratch even though they don't really know the details of what "correct" behavior is.
I hate this sentence so much. "Bad engineer"? Being a good or bad engineer doesn't come down to a single thing, ever.
A lot of organisations, like mine, which is a well known public entity, REQUIRE this sort of operational procedure.
In fact I can think of at least 10 sites in the alexa top 100 that don't have any tests.
For eg. One feature require backend & frontend work, after a week of work engineer says that this is done. So you ask him to demo, and it turns out he is doing a backend demo with some dev tools.
From a product perspective nothing has changed. Top engineers understand, that no one cares that only one part is working, they know the end user and will not bother managers/product owners with partial solutions.
Is this common outside of organizations where people are told to not work on anything that is not a JIRA task? And do people that do that not come mostly from such organizations?
* Read the source of upstream dependencies. Fix or fork them if needed.
* They're better at finding forks with solutions and gleaning hints from semi-related issues.
* Formulate more creative hypothesis when obvious lines of investigation run out. The best don't give up.
* Dig in to problems with more angles of investigation.
* Have more tools in their toolbelt for debugging like adding logging, monkey-patching, swapping parts out, crippling areas to rule things out, binary search of affected code areas.
* Consider the business.
* Consider user-behavior.
* Assume hostile users (security-wise).
* Understand that the UI is not a security layer. Anything you can do with PostMan your backend should handle.
* Whitelist style-security over blacklist style.
* See eventual problems implied by various solutions.
* "The Math."
Ah, a personal favorite of mine which often makes other people uncomfortable.
1. Users are like Marines, if it can be broken, it will be broken. If it's use is not clearly marked, it will be used incorrectly. If it can be fucked (literally or figuratively), it will be fucked.
2. Users are malicious and are actively trying to backdoor everything you do. Why? Because it's the first thing I do with a new product / what I do with the competitions products.
3. It is the developers responsibility to mitigate the above cases.
In my experience clear markings aren't enough to stop it being used incorrectly.
At the end of the thirty minutes one bowling ball was in a bunch of little pieces scattered all over the room and the other one was pregnant.
Can you elaborate?
A mid-skill engineer might start by trying to diagnose the problem, and usually will get somewhere, but occasionally they'll run out of ideas. They might assume it has to be one of the things they've seen before, but their list is not exhaustive.
A top engineer will start by looking at the big picture and generating hypothesis. They will usually be able to generate more hypothesis and have more ways to test them than less seasoned folks. Often this is because they've seen more things.
For example, off the top of my head, the slowness could be:
- n+1 query problems
- slow remote service calls
- streaming to slow clients
- object allocations
- loops in loops--bad big O
- resource limitation (memory, CPU, IOPS)
- database connection limits
- worker process/thread limit
- frequent cache misses
- noisy neighbor problem
- lack of indexing and data size growth
A top engineer will run through their own list, and for each, they have some ideas on how to check on that item or to rule out what is unlikely. Some of them are trickier than others. The key is they have more angles that they'll know off-hand to follow up on.
Can someone expand on this and explain this? I'm just starting to build my first API, and it's not clear.
The point here is great engineers make sure the API answers correctly even if the query is messed up.
The simplest example is probably using a Big O approach to view how to walk a large data structure. The math works out that certain approaches to walking it are cheap enough in terms of total operations at small scales, and incredibly expensive at large scales. By doing the math, I mean that you can both know when you can get away with sloppy approach, and when you have to be careful to not touch each object more than once.
I didn't just mean big O, though. You might do calculations like "if every user creates these structures in a database, every 5 minutes, we can expect that this table will have n records by time y. If that happens, one, is the size tractable, does it need an index, and do we want to reconsider this approach in favor of a cleverer design that can avoid this query? Things like that.
A recent example for me was researching max zookeeper writes per second and deciding if it can be used for super high volume writes in a system. The conclusion, based on some napkin math of the system needs, and some benchmarking of ZooKeeper was that a different tool needs to fill that spot in the architecture because it was too write-heavy for zookeeper.
Or otherwise put, knowing when to do things by the book, and when it's okay not to.
- knowing how to make the solution "the right level of good", as opposed to "academically perfect" or "unmaintainable hack".
- being able to design and implement a "good enough" solution that is still reasonably maintainable (if needed) much better and/or faster than others
Knowing where on the scale to set that mark requires being able to bridge speed of implementation, execution, maintainable, upgradability and the overarching business goals you're building for.
So really a broad range of understanding that only "excellent" senior developers will possess
* Reads the docs of dependencies rather than blindly googling.
* Happy to ask the uncomfortable questions early.
* Will ask technical questions proactively without caring about maintaining face.
* Has good discipline and communicates well.
* Multidisciplinary
* Quantitative
* Scientific
* Curious, skeptical
* Thorough
* Willing to abandon a bad idea
* Willing to advocate a junior colleague's good idea
As an add-on question: Which of the properties mentioned in this thread do your organization actively drive out of people?
I don't care how good you are, if your personality is hostile and toxic, you're not making the team productive. If you can't take honest feedback during peer review, or QA or even from the client, then you need to evaluate why.
The best engineers I know are humble. They don't freak out when you point out a bug, they look into it and figure it out, then they share with you what they found vs what you found in order to determine if it is indeed a bug. Then there's developers that think all their code is perfect and sacred. Nobody likes working with those kind of developers.
- Let people learn from mistakes by making sure they can be backed out easily. Do more prototyping, etc.
- Figure out how to make mistakes more visible to everyone, not just you.
These are also helpful when you are the one making the mistake.
I've met people who literally believe humility to be a weakness, I think a lot of people misunderstand what it means to be humble these days.
It is another thing to be a legitimate expert and to not voice your opinion to avoid conflict. I have seen smart people who avoid direct conflict at all costs. Even if that means working on something you know is a bad idea.
It opens up two new good paths: 1) the other person actually having important perspective you don't, and you learning that in a civil way, and 2) the other person recognizing the problem, adapting the plan accordingly, and still feeling ownership over the plan.
It also opens up a new bad path: 3) the other person being ashamed of not having this perspective and digging in on the bad plan.
But if you're seeing #3 regularly, that's a job you need to quit ASAP.
tongue in cheek, yes, but with a grain of truth, I'd argue.
2. Take code as documentation. This helps to debug things faster
3. Focus more on problem solving than language/tool priorities
4. Listens more and always towards exploring and experimenting new things. This improves breadth knowledge
Architecture is important, but organizations employing "software architects" tend to be bad at software.
The worst thing I remember is a web API where some call could fail but didn't tell you, it just gave you some kind of plausible looking inert data. The call to query system status was separate, so there was always a time of check / time of use problem. Also there was a transition period when the original call did return an error but the system status API didn't yet. Nobody (I hope) comes up with such a disaster while implementing and testing it.
They are strategically lazy, putting a lot of thought into how to simplify at all levels. Great engineers loathe complexity and indulge in it reluctantly. Solutions should never be more complex than what the problem domain demands.
A corollary to above: they use language features and constructs to solve problems, not to show off how smart they are by constructing the most "clever" bit of language gymnastics with which to waste the time of those who have to maintain the code later (including the author!).
They know assembly language and the basics of CPU architecture regardless of what language they use so they understand what is actually happening. They also have a grasp of other aspects of the system like networking and storage even if they do not do much with those directly.
They know the history of computers and computing and how things have been done at various points in the past. This helps them spot fads and rediscoveries of old things that have been tried already as well as generally deepening understanding.
They are skeptical of fads and don't instantly adopt whatever thing is trendy unless it's a genuine improvement.
#1 Rapidly Climb Learning Curves
The ability to quickly learn enough about new subjects to be useful. New technologies or APIs; new algorithms; mathematical or statistical subjects; and most importantly, your problem domain. Some of this ability is a skill, "knowing how to learn", which covers google-fu, reading comprehension, prioritization, time management, etc. Some of this ability comes from having enough aggregate experience that new information just clicks into place like jigsaw puzzle pieces. Some of this ability comes from the confidence of having climbed enough seemingly insurmountable learning curves that this next one is "just another day at the office".
A sign you're doing this wrong: "I need training!"
#2 Understand The Customer
IMHO, the best engineers are half product managers. You can easily get a 10X improvement in productivity by building the right features and not building the wrong ones. Yes, professional product managers are great, but technical limitations often impact product design. A great engineer knows when to push back or suggest alternatives. This requires empathy not only for the customer, but for the product management team. This ability is also tightly coupled with #1 - you need to quickly come up to speed on the problem domain, whatever that may be. If you wan't to be a great engineer, don't study algorithms (until you need an algorithm, of course), study the particular business that you're in.
A sign you're doing this wrong: "Whatever, just tell me how you want it and I'll make it that way!"
Absolutely agreed. I think this is part of the source of the endless fighting around "10x engineers". In most discussions where people are trying to "prove" their existence, they will usually bring up things that are outside of the scope of a traditional engineer, that involves some kind of outside/customers/business perspective on a problem/solution.
It's not that it makes you a bad engineer if you can't thrive in an imperfect organization. All organizations are varying levels of imperfect. Great engineers figure out how to be great anyway.
But I was mostly thinking of stuff that can't be found on Google, e.g. the last time I said I needed training was when I was going to do maintenance at some company, on some internal application that I had never seen. I didn't know the domain either. But I had heard that a two-day training course for users existed (also given by internal people). So I said I wanted that training (developers before me hadn't), people thought that was a good idea and it turned out to be very helpful.
Then some manager tells you, "we need Kafka, can you provide our solution for that early next week?"
THEN, you say "I need training!" (necessitating relief from other duties).
Some of the best ones I know dabble in things like art and music, and do it better than most of the people who are full time specialists. It reminds me sort of like watching sports, where a world class defender can attack better than a second division forward. Maybe they just have really outstanding soft skills.
Is there an implied caveat that this applies mostly to Frontend engineers? Or do you think this is something Backend engineers should also be good at? Or I suppose there is third option that great engineers should do both.
I think it's part of the learning process, where cross-discipline helps them learn a lot faster. Or maybe it's the attitude, where they work to learn as many things as possible rather than optimize for some high paying specialist role.
I find the pedantry of learning how to do the same thing over, and over and over... to be... pedantic?