Ask HN: Lessons you wish you knew when you were Junior developer?
I was wondering do you have some recommendation that would help along the learning path of Junior to become very good at what one does?
Some people can't be bothered to blog. Some people aren't allowed to blog. Some people are paid to write blog posts they know are bullshit bad advice.
I later realised, how daft it would be for any company to have a stringent demand for knowledge in framework / library without putting the general "getting-things-done" talent into the equation. The sheer velocity of the changing landscape makes it a horrible way to judge an engineer. Additionally, I wish I knew that soft skills in communicating well, giving feedback, and understanding business goals make up for more points than a breadth of tech skills.
Similarly, it's even more impressive to have a thorough understanding of what's under the hood of javascript, knowing WHY it has it's limitations, instead of just what they are.
Depth of a single, particular subject will never beat depth of an entire stack (before hitting the point of ridiculousness, of course).
Most of their listings include a "Must have 3 years of experience in Ruby on Rails".
Unless you're a developer with 10+ years of experience or something, and the company/job you are applying for overlooks your lack of knowledge in a subject area.
- Not checking code well enough when working in a new and unfamiliar language (I broke production)
- Not negotiating my salary (almost took a massively underpaid job)
- using an obscure technology when I should have used something mainstream
The list goes on...
I'm writing each of my mistakes up as a weekly email, so if you want to avoid all the mistakes I've made in 20 years of software engineering check out https://softwareclown.com
You need to clearly describe bugs for other developers, write documentation, explain why a particular technology / framework / pattern is the best choice, understand what a client / product manager is wanting... the list goes on. Eventually, you will hopefully be training and supporting other developers.
How much of your time will be spent coding and how much will be spent communicating with others about your code?
If I could send a message to my past self, it would be, "Empathize with coworkers, customers, and family. Everything else will follow."
Similarly, if the end-goal of a project is not clear, don't be afraid to stop things and ask.
Judge new tools by the quality of documentation and how possible it is for you to get a clear mental model.
In interviews, always as what their onboarding process is.
If someone asks for a time estimate and you don't know the answer, don't let them pressure you into lying. Hold your ground and say you don't know.
I.e make it a highest priority to build enough of a finical cushion that doing these things are even an option.
- Just because you can't reliably estimate a project doesn't give you an excuse to refuse to give an estimate. We get it, your estimate will be off. Whats important is that you communicate deadline changes early and often.
- Contrary to everything you hear, software projects can be finished on time. Most of the time we procrastinate at the start of a project and crunch at the end. Stop procrastinating at the start and more projects will be completed on time. Which brings me to...
- If you fail to complete a project on time and failed to communicate this impending delay early, this is 100% your fault. This isn't the fault of some stupid law, or book you read. You slacked off and as a result couldn't reliably see how much work was involved in the project and by the time you realized it was probably too late. This is on you.
'finished on time'.... This is the waterfall approach. Its broken in its core. So i also disagree with that.
This is the core of where I disagree. Giving estimates provide tremendous value to those who depend on your work. It allows them to plan and forecast future needs.
You're rarely ever working in some kind of bubble where your work is this mysterious thing that can be done tomorrow or in 4 years. I've never encountered a situation where there's so many unknowns that you can't come up with some number. Requirements change, timelines change, that's all fine. Businesses should be able to adapt to change. Being in the complete dark is much worse.
> 'finished on time'.... This is the waterfall approach.
I'm not sure what you mean by that? Things can't be late just because you're "agile"?
I think TeeWEE means that in modern practice a product isn't "finished", it is launched but continually improved afterwards.
Now imagine we go back in time before you started and I asked you: will this take closer to one month or 10 years?
Can you estimate that?
Many people don't get it. And if you genuinely don't know, then how is claiming you do anything other than writing a cheque against an account of unknown balance? If you feel like you don't have a good handle on how to estimate the project, that is an important sign that:
- The scope of the project is actually not well defined.
- The tools you are going to be using are ones you don't have a lot of experience with and you have a high probability of running into an odd bug that takes a long time to track down
- You haven't broken down the task enough.
- The task is large enough that you should actually be biting off a smaller piece of it and estimating that.
If you think that there is a significant chance of missing a deadline, you should indeed communicate that as soon as possible. That includes during the meeting where you give your estimate.
> Stop procrastinating at the start
If you find that you do actually have a bunch of time that you're losing at the start, ask yourself what the causes of that are and seek solutions to those causes.
- Consistently get good food every day and good sleep every night
- Use https://freedom.to/freedom to block HN and reddit.
- Make sure that you are clear on the projects' goals and the tools you are going to use.
- Make sure you know whom you can go to when you need to get clarification on things.
But be aware that there are other causes for deadline slip.
> this is 100% your fault
If you find yourself in on a software team or a state of mind where your top-of-mind question is "who's fault is this?" get out of there. Pointing fingers prevents organisations from making systems-level changes to avoid them.
Furthermore, if you get yourself into the mindset of "I failed and am behind on this project and it is my fault and I need to just buckle down, catch up, and fix it." then you will not do yourself or the project any favors. Take a deep breath (or even a brief walk), find a senior engineer that you trust, and ask for their help in thinking about how the project is structured and how it might be estimated.
But, when I was a junior developer, I had a tendency to procrastinate at the start of a project and cover up my procrastination by keeping everyone else in the dark. I learned, through time, that over communicating from the outset would help those that relied on my work plan ahead, and it'd also have the effect of helping keep myself on track. A form of personal accountability.
- horrible at negotiating and playing it safe
- biggest mistake was probably being afraid to read source code of third party libraries when the docs led me to a dead end. Always read the source
- stop trying to make everything DRY, duplication is better than obfuscation
As soon as I got over that and started inspecting the source of different projects I was using, I definitely became more confident in my own development skills by comparison, and I became instantly more valuable with the libs I was using because I had more control/understanding of what was actually happening behind the scenes.
I'm also mostly a .Net guy right now in a very .Net area, and they generally frown on that sort of thing until very recently. Not an excuse I know, but just for background.
I use them fairly often to parse things or make things more seamless, but is that the general way people go about solving problems? Is that wrong?
Implementing a OSS library yourself seems overkill, but at what point is it worth writing something yourself?
The main reason to write it yourself is if the libraries you find are crap, or you can't find any at all.
Learning to read code is a hell of a lot harder than learning to write it. It takes practice, patience and ultimately a language with a high quality working debugger. Once you learn to read code in one language it isn't hard to learn to read it in another.
Love your IDE/editor, and make sure that you have split views (viewing parts of the same file or two files at once). This feature is essential to being able to read code!
Figure out the difference between "I wouldn't do it that way" and "this code is bad". It isn't terribly hard to leap from one to the other.
Find a mentor! I can't stress this one enough. That guy (or gal though they are rare) pushing fifty who is still an engineer, they are that good, don't want to manage, love their craft, and have seen some shit. They will talk your ear off (probably) for coffee.
Lastly writing code is part of the job, once you have master that learn everything you can about your business. Spend time with accountants, CS people, Systems Admins, the IT guys... they are all going to teach you things that will make you better at your job.
If you get to five years in the same job, take a long hard look at yourself and check that you are actually still learning and still making yourself more valuable and still improving (which I would expect to really only happen if you weren't actually doing the same job as you were in the first of those five years).
Bugs show themselves quickly, along with which method is failing, so the fixes are fast and effortless when you break stuff. Massive refactoring doesn't scare you, and you sleep soundly with no fear of hidden breakages after each new release.
I would replace it with "Don't add a new framework or library unless you can get a clear mental model of it"
What the business needs, will never be the best way to become good.
By all means shove stuff out the door quickly at work, as you'll then be fully startup-ready.
Just spend your own time learning from first principles and actually understanding how things work.
"No one knows what he can do till he tries"
1) Accomplish things.
2) Gain one overarching-if-shallow view of a problem domain works
However, they can also be a pile of complexity that prevents you from understanding problems or moving forward. The question to ask is: Can you form a solid mental model from the documentation? If you can, then the framework is useful and can be a decent curated entry-point into understanding something.
You'll still want to take that shallow understanding and dive deeper.
In any case, I find it most distasteful. No one should accept it as a part of their job title for any length of time, other than out of pure, survival-driven necessity.
Is the complaint about "junior" implying age? I'm trying to understand.
[edit] further is the term "senior" developer also problematic?
adj. Low in rank; having a subordinate role, job, or situation.
n. One of less experience or inferior standing in his profession than another, who is called his senior; one employed as the subordinate of another, especially at the bar.
n. term of address for a disrespectful and annoying male
I'm cherry-picking these, of course (out of a body of mostly neutral variants), but the point is, these negative touches do carry across.
"Senior" is a bit different, somehow (mostly because it's no intrinsically defined in terms of negative attributes like "inexperienced" or "subordinate").
Every step of the journey informs the outcome and sometimes the destination. Code and logic change -- so learn to program in ways hat adapt to change.
---
Try new things and concepts in tiny single purpose projects.
---
Ask for help, programmers like to explain things.
---
Ask why from your business users. Multiple times, until you get the context. Once you have the context, you can create freely and come up with better ways to do things. If you don't position yourself in this way, you may end up with people trying to control you like they would a tool or a sock puppet. Having people's hands up your bum is no fun.
---
Fight for uninterrupted focused time. This is your spice and the spice must flow.
- There is no "silver bullet" for managing the complexity of user needs. Instead, (good) software is characterized by not a static state of "solving the problem", but a continuous refinement-- an existential struggle against incidental complexity.
- Have a very positive mindset, and inspire the same in your team.
- highly reliable websites for small companies: http://www.kalzumeus.com/2010/04/20/building-highly-reliable...
- Learn your debugging tools well: Get good at Chrome Debugging tools, pdb, visual studios debugger, or whatever the debugging environment is for your project.
- “… never consider your education complete or your opinion above questioning regardless of your title, your years of experience, your awards and accomplishments, or anything else that isn’t rational argumentation or evidence. Retaining a healthy degree of humility, constantly striving for improvement, and valuing objective metrics above subjective considerations will go a long way ..." (http://www.daedtech.com/how-software-groups-rot-legacy-of-th...)
- This is a marathon, not a sprint.
- Practical engineering advice: https://www.quora.com/What-are-the-best-kept-secrets-of-grea...
- Read books. I can especially recommend Refactoring by Martin Fowler and The Pragmatic Programmer as a more introductory text (affiliate links: http://amzn.to/2ekPnTL and http://amzn.to/2ekJQMK). Understanding why and how to do scrum effectively is really important too -- I waited too long to read a book that laid that out for me (http://amzn.to/2ekPxul)
- Good programming advice from Kent Beck: https://www.facebook.com/notes/kent-beck/mastering-programmi...
- Eventually, you will have to choose between engineering management and continuing to be close to technology. Trying to do both is a recipe for burnout. Some people might be able to do both simultaneously without trouble, but you're probably not one of them.
- Always be looking for ways to remove yourself as a bottleneck. This needs to be done both on a technical level and on an organizational level.
- Push back as necessary against demands of your time and energy that are not in harmony with your needs as a technologist.
- Good programming comes from good habits. (in that vein: copy-and-paste is the devil.)
- Seriously, read books. It's incredible how much good advice is out there.
Hardly.
Copy-and-paste is fine if you understand how and why it works. Magic is bad but forcing yourself to needlessly re-invent the wheel is a dumb idea in itself.
-- write code then reflect on it.
-- connect to like minded peoples.
-- communicate clearly and effectively to make sure your message is conveyed the way you wanted.