1. What are your great habits?
2. How did you inculcate them?
3. How do you follow them on a daily basis when things get hectic/busy?
- Make systems as observable as possible. Stuff will break, the easier it is to identify the cause, the better. Logging things at different program flow points helps immensely.
- Question every decision in the codebase you are working on, but thoroughly weigh any refactoring attempts
- Don’t fall in love with own code
- Prefer readability over performance (in most cases)
- Don’t follow trends blindly. More than likely your boring stack is the best way to go
- Allow room to recover from a malformed system state
- Don’t abstract prematurely. If you struggle with designing your abstractions, you are probably good with concrete case(s) for now
2. Provide in depth summary and explanation of the problem and solution in your PRs
Engineers can waste months or years of their collective time because they don't understand the problem they are trying to solve. They slap bandaids and fight wack-a-moles.
Both steps I listed above combat this issue.. the person(s) dedicated to solving the problem must understand the root issue with certainty. And when they explain their fix/solution it must be articulated well enough for other engineers or your future self to understand reliably.. else the mistakes of the past will be repeated.
Most engineers ask "why" to the surface level questions. E.g. "Why is the bug doing this instead of that?" A: "Oh, because this conditional does thing..simple, just fix this conditional. Solved!"
Then the issue pops up again... The engineer probably didn't ask why enough.
The should have investigated more... "Why did the original author choose this logic instead of the alternative? Was it purposeful, or was it a truly logical mistake?". If it was purposeful, why was this alternative not considered? What was Product's intentions here?" etc. etc.
Studies show the work takes about 1.8x the estimated time. But if you underestimate, then Parkinson's law fills out the time and the 1.8x rule still applies. The uncommitted item is there to combat Parkinson's Law.
2. Sketch a full plan before any code. Wireframe, which fields does this item fetch from, where is it stored in DB. Especially if you're either FE or BE, it prevents blind spots from either of you. You also want peripheral vision of the whole playing field and this is how you do it. Spend minimum time on this; all plans are meant to be thrown away. If you don't need it, it takes 5 mins.
3. (and to answer your q3) If you can't spare half an hour, then you need half a day. The more out of control things are, the more discipline you need. If you can't make it, then accept that you have lost and figure out how much ground you need to concede. Overextending is how you lose everything, burn yourself out and burn out your team.
- MR/MR contains a ref to the ticket, an explanation of the changes, proof of work or way to test the change.
- Know how to leverage your tools (git, editor)
- Be curious [other languages, tools (formal methods, fuzzing..), fields (web if you embedded, or the other way around), maths ... ]
Could you give me an example format of your notes? I would love to see the detail one can get from them?
- You can look up architecture decision record (ADR). There are plenty of good resources on google.
Depending on context, that might be comments written on the ticket, a notes file (that I delete when I open a PR), or todo notes (with my initials) that I either resolve or defer to another ticket before opening a PR (and I have a `git todo` alias to find them all).
Partly this is just so I don’t have to rely so much on my memory. Partly this is communication to the rest of the team.
Sometimes I leave a comment on my ticket at the end of the day saying what I’d say about it in standup the next day. Which is good for me when I come back after the weekend, and good for the rest of the team if I spend a day or two off ill. It makes it easier for someone to pick up where I left off in my absence, if necessary.
2. Review my own PRs before I ask anyone else to.
If I can fix all the obvious nits before someone else looks at it, that frees them up to notice more fundamental issues that I’m blind to.
3. Commit early, commit often. Especially if I’m having a bad brain day.
I'll give you my example, when I am driving to work I might realize something or during lunch. In that case, what do you do?
When I commute, I commute by train. Leave yourself a voice memo, if you’re driving?
- work that is not needed
- risky changes
- low value to effort
- changes that cause unnecessary noise in the codebase
the most important skill i have
is showing up every day