Unusual as many years, there are junior developers in the world.
A few weeks ago at work we had a talk where old developers (including me) were invited to spend five minutes with our personal development philosophies. The idea is for us to share our years of experience with our greater junior developers.
After the session, I feel it’s worth writing my own thoughts, and add a little detail. So we’re here.
This list is a little different kind; It is not intended to be a meaningful exploration of the way in which I am developing the software. As well as, if you are a senior developer that is obviously you may be more familiar with some of them. Or disagree! Software development is a famous principal field. See you in the comments.
Avoid, at all expenses, arrive at a scenario where the ground-up reconciliation begins to look attractive
This is usually well understood that ground-up recoil can be an attractive and most dangerous prospect. The standard advice when part of the ground-ups again is “no, whenever”. But I want to go away from that.
At the beginning of the ground-up reconciliation as a good idea, The avoidable errors have already been. This is a scenario that you see from distance and you can, and need, active to flow from.
Signs of Warning Warning for: Compounding Technical Debt. Adding difficulty to make simple changes to code. Document / Commoping code difficulty. Difficulty with new developers. Dollar numbers of people who know what are particular codebase areas actually work. Bugs who don’t understand.
Collecting complexity should fight at a time. Alternate among the phases of expansion (new features) and consolidation.
Of course, a ground-up rewrite CAN actually worked. It can be a better choice that the alternative (keep your existing technical debt-laden-laden swamp-laden swamp to code). Together, it may be that of Choosing works – the project will be destroyed, and you just choose how it dies. The point is that there is a lot of danger to this situation … but the situation itself can be avoided, and that danger is avoided.
Aim to become 90% generated by 50% available time
There is a great proverbial software proverb – indeed, thinking about it, it can come from the software development – to go,
The first 90% of the job requires 90% of the time. The last 10% of the work takes the other 90% of the time.
It’s gentleness is fun and perfectly accurate. It is known, it is as far as possible to correct it.
Write the code, once, and get it to work, get a certain amount of time. If you have done this, you need to understand that almost half finished. Polishing code to an appropriate level of integration and maintenance, properly managed in case of failure, content exploration, “Last-servational” These things can be so much more time, and they also about your work.
Many of these things in theory Skippable. But to practice when you skip the things you end with a shoddy, incomplete side. And no one else goes back and end the job “smooth” after. There is always additional work. Do this three or four times and have a shoddy product.
Also, the writing code itself will leave unexpected roadways. It is recommended to try to figure out these road roads as soon as possible.
And if it makes it difficult you don’t need the extra time you planned? Well, time to implement some process repairs! Or pay some technical debt (see above)!
Automate good behavior
Sometimes there is a particular item that developers do to do with a project STARTS doing or stop done. There is a new best practice. There is a new tool we need to use regularly, everywhere; a new mandatory header in each source file; a check that should run; a method we have settled with no good use (even an internal approach or a third-party API). If it happens, there are two ways to get the developer base in general to change its behavior:
- This society. Tell each person, one at a time or the scrum or at team meeting. Sending emails. Add new wiki instructions, or to Reco Readme, or the abandoning request. Remind people to read documentation, always. Again to manually change each person’s changes for oversights, forever. Make sure you don’t forget! Add checklists, try to train everything to properly enforce checklists. Increase the mandatory peer review level. Remind everyone too. And again …
- It automates.
Add an automated attempt failed if the guidance is not followed. Or, if we can’t fix everything anywhere once, add a Ratchet. Failed fast, with a polite and taught warning, if the right thing is not done, or better, the problem will be fixed. Generally, carry out the best practice.
Automation is not a perfect solution or a universal solution or a precise state of the world for things like this. There are many requirements that are more than necessary and abstract technical requirements that are not automated, and it is possible to get certainly it’s annoying strict by introducing so much disapable The rules, and motivated developers often avoid automation in different ways. But if you find yourself speak people regularly, “you forgot to do XPlease note that often X“, maybe it’s time to automate X?
Consider pathological data
No one cares about the golden road. Cases in the room are our Full work. Think of the ways in which things can fail. Think of ways to try to make things rest. The code should be in charge EVERY possibility.
What if the request fails, or stalls for ever, or send a byete per second an hour? What if the table you shown has a million rows? A billion row? What if the name has a slash of this, or traveling white, or a megabyte length? I don’t believe you when you say you can prove that the string cannot be empty!
Usually there is a simple way to write this
If you break your time correctly (see above), you have time to go back and see if you can do better. Cf The old chess sayon, “If you see a great step, find someone better.” And another hard quote, “I apologize for writing a long letter, but I didn’t have time to write a short.”
Write code to try
This means good mean interfaces and minimal effects. Code to prove difficult attempts may not be properly covered.
Not enough for code correctly; It should be clear, obviously bad
Some code seems to work correctly in the accident, because circumstances can receive these bad inputs and fails to be ordered by the structure of another code that surrounds it. I don’t like it. Although the technical code can be free from bugs, re-changing other code is now difficult and dangerous.
This is true for security issues, or theoretical loss of security issues. It doesn’t matter that all callers in this specific internal function is reliable TODAY.
I have something else for this list but I don’t remember now.
2025-02-03 20:00:00
