What I would say to myself if I could travel to my past.
Today I wrote a tweet asking for recommendations to junior developers
I got a lot of very interesting answers. I will group them down here.
Tweets are textual, I chose the more representative, corrected some typos and abbreviations and added some references.
I’m not a Jr Dev, yet. But if I had the experience, my advice to a Jr. Dev and to my future self is; be a student for the rest of your career. Listen to every dev no matter the age and experience. Stay humble, that will make people relied on you and reliable means stable job.
- Learn your tools deeply.
- Delete everything and start again after you've gone through the tutorials. If you can't, you won't trust yourself when things stop working (eventually they will).
- Learn TDD; it makes for better code. Senior devs will want to help you more.
Learn to listen and watch what the others do. Then combine what you learned into your own personal framework. 😊
Try to find a solution by your own first before asking a question
Take the code as waste. Don't get sentimental about it, and always strive to trash it away.
If you focus on solving customer requests and business problems, the frameworks and patterns can help you. If you focus on using frameworks and patterns, they will actually get in the way of solving business problems.
Know your stack, sure, but it's equally important to develop your habits and approach.
Be confidant. Your first thought about a project should be, "We can do this." NOT "Maybe we can 'lift it and shift it' to the cloud?"
Do not follow twitter roadmaps or "how to become a xxx developer". Often, they are misleading, extremely simplified and wrong.
keep your head cold when debugging ..and know that every error you'll face is caused by some kind of typo or wrong reference path ..remember to take a day off every week
Learn and practice, practice, practice TDD
Never think of yourself as a “junior”. Do what you care about and do it well. Don’t go after “promotions”. If you do what you care about well they will come.
Build things. Write something everyday, even its its one line.
You’ll never stop being a jr dev, even when you are a sr dev. You should always have in mind you need to keep learning all the time
- Don’t be afraid to ask questions
- Don’t stop learning
Enjoy the experience and strive to a little get better every day.
Empathy and communication are the two most important developer skills.
Work diligently to minimize the imperative shell.
Don't seek perfection, seek progress.
Be persistent. Always take some walk when you feel exhausted.
Persistence trumps all.
I would add to that, in order to have persistence you have to enjoy the process. You have to love that feeling of satisfaction you get from solving a difficult problem, or when you get your "aha!" moments.
There is no such thing as a silly question. Ask. Don’t ever stop asking. Don’t ever stop learning. You will do great things.
Contribute to open source
Consistency applied over time wins...consistently coding (even if just a short amount) over time will build the experience you need. Bonus if you keep up on the latest trends in languages.
Stop labeling yourself
You need to be motivated and have a drive! The BEST dev's I have had the pleasure of working with are constantly learning new ideas and technologies. They are builders. They enjoy building new things. They do these things bc they love it! Not bc their job asked them to do it.
It’s oka to sleep sometimes.
you shouldn't be afraid to ask about everything
Always be Building Something.
Follow your interests and never stop learning.
It’s a going to be one hell of a journey.
Every good thing takes time, don't let anyone sell you an overnight success
I’m not in a position to give advice but Maybe Take all the time you need don't rush it or u gonna lose it all in a sec
Don’t give a fuck about the negatives you will get in interviews. Don’t give up, you just need to be accepted by one company.
Yep composition over inheritance as the default approach to follow
Focus on communication skills (listening, assertiveness, moderating, asking questions... ) the rest will follow.
Always be curious
Always use interfaces.
Don't give up and if you want to then find a senior developer
Don't code anything that you don't understand why is needed and how it works
Embrace knowing nothing. Everyone feels it, the sooner you just accept that you're going to ask silly questions, the better because silly questions stop silly mistakes and are how we all learn. Ask your seniors questions and find a mentor to bounce questions off of if you can.
Provide motivation to have a high curiosity and love of programming. So that they can be comfortable at the beginning and easy to upgrade skills to grow and adapt
- Compete with yourself
- It's ok to do mistakes
- Don't repeat your mistakes
- Ask questions if you don't understand
Learn how to unit test and refactor
Go easy on the tutorials, go hard on the projects. Doing > reading about doing, majority of times.
Find a seasoned mentor.
Never give up
Find a mentor!
Try and try a lot times, you will learn and improve the main skill, later keep the focus it in there
master fundamentals before moving to advanced stuff, don't hurry for the shiny thing
If you are stuck, ask either a fellow teammate or Google.
Go at the speed that’s right for you. You don’t need to know everything library, framework or language to bring value.
Love programming and practice daily.
- Do framework intro tutorials for all new frameworks. You learn a ton. Don't just 'make it work'.
- If using Pluralsight, do it with the class.
- Read co-workers check-ins. Look at how/why they did stuff.
- Know the business that you code for well.
- Don't ignore devops.
- Look at major code files in your app and read their histories.
- Record Zoom meetings w/ permission when getting mentored on something. Watch it later.
Find a good senior developer and ask as many questions as humanly possible!
Some things do come only with experience, but you wanna avoid as many pitfalls as possible
Following your passion has rewarding side effects!
read some of the classics, but beware: nobody has found the holy grail of software development. Classics? The Pragmatic Programmer, Code Complete, Refactoring, Clean Code, Design Patterns to name only few, peek into the domain you write SW for, try to get an understanding of it.
On any project, dont underestimate whatever has to be done before the actual coding.
Don't forget, code is a tool,not the solution. Code is only necessary, as a hammer to a nail. Find projects, challenges that demand your code. Find your nails.
Break everything down into small bite sized pieces. -> keeps you from feeling too overwhelmed and gives you small wins to accomplish as you go
Keep a solid separation of concerns. More separate. No, even more.
Don't be afraid to speak up and ask that question!
Ask for help, document, discuss concepts with your seniors
Write test first.
1- don't do it alone if you can help it! Review your peers' code, read through open source code and really strive to understand it, pair program if you can. Being a professional dev is a social endeavor and you should learn that early
2- learning your first language will be hard. Learning your second is likely to be harder. From #3 onwards you stop caring too much about nitty gritty details and think about the structure of your code
3- get something to production. Do it at your pace, but do it. Learn to build a pipeline, deploy, log, and get to the point where you can claim that people - even if just a half dozen - can access some value from your code anytime anywhere
Googling code is not a crime
Take responsibility of the task given to you!! Always explore and learn news things.
Get Early feedback, write test cases.
Just forget title as "junior", and stick with basics of tech all time. Frameworks come and go but basics of tech remains same.
code in the langage that you love, not in the languages that are available in the business markets. And never stop learning.
Find out quickly what learning strategy fits you best. Find mentors. Have faith in Google and Stack Overflow. Grit and technical communication are more important than your algorithmic know-how.
Aim to write good, well tested code. Not perfect code. Build relationships and never throw them away. Failure is a valuable resource, but not if you don't listen or learn from it. Be passionate about your work but don't try to make it your life.
Look for a new job? :-) Just kidding. Maybe never give up trying to get things right!
well.. learn the importance of previously released programs really helped for me (quake, stuff like that), do basic projects (memory allocators), learn what languages suit your needs
Explore, explore, explore. Do not just follow the trends, find what you like and stick to it. You don't need to know everything, expanding on what you enjoy doing is the key.
Don’t be afraid to challenge the status quo and never stop learning!
Never stop learning. Even those of us who have been doing this for over a decade are still learning new things.
Don't kill your personal life to do so, of course, but set aside at least a little bit of time to learn new things. Or deeper into what you're doing now. Either way.
If others tell me "Don't dare change that! It's impossible!!!"
I know what I want to work on next.
And, believe me, I'm going to refactor it to "within an inch of its life." Diablillo
Break up your work into small pieces. A login feature might be a lot but breaking it up into features such as:
- Email text field should be visible
- Password text field should be visible
- Email text field should register text events.
Will make your life easier.
Don't just start typing codes... imagine a problem and start solving. Helpers in that area will always be available when u get into hooks. Be CONSISTENT.
Assume you know next to nothing about how things are done in the real world.
Learn the “why”, not just copy and paste or do something because it’s the cool thing. Why is this method better than that? What is the goal of this task, and why is this language/framework/database better for this task? Why did this bug happen?
Maximize what you don't need to know right this second
Languages are tools. Nothing more. Learn the fundamental principles, data structures, algorithms.. Learn Problem Solving.
Then pick the best tool for you for the job at hand or that you specialize in.
Build small projects and document your learning in tutorials.
This will help it all sink in and will be a great reference for yourself and other aspiring developers.
Also, join a community to connect with like minded people.
build projects and practice everyday
Once you get OOP under your belt, learn a functional language.
Set out realistic, time-based goals
Stay consistent with burning desires
Share your goals with others to hold yourself accountable.
Celebrate every little wins. It is what amount to greatness!
Keep breathing & keep coding
Practice practice makes perfect
Assume nothing. Question everything.
Learn a language, then another one, then another one... stick with the one you like the most. Ignore language bashing from toxic sources.
Find a mentor & learn debugging
Don't be afraid to ask.
Be it because you don't understand something.
Or to learn more.
Or to get further directions.
Create. Create and learn. Then Create more.
Set realistic goals
Exception handling is of utmost importance. Don't disregard it.
Don't touch ctrl+v
study hard & find a mentor
Mistakes are ok, coverups are not.
Keep coding, and keep learning
Start early learning TDD
Just because you are not getting a concept right away, doesn't mean you are not "good enough".
Certain concepts in #SoftwareDevelopment are tricky and it simply takes time to wrap your mind around them.
In short: Don't give up!
It's okay to ask questions.
Always give it your best shot, but don't be afraid to ask if you get stuck or need clarification.
Most other devs will be happy to help and guide you on the right path, especially if you've already tried your best and respect their time
Look back at old projects, serves as a good resource to show you how much you have improved.
Also go and redoing a old starter project can be a real boost to your confidence and validate your effort.
Be an information sponge. Take as many notes as possible digitally, so it's easy to search them. Learn as much as you can from people around you. Look for a job where people do 100% pair programming to help you learn quicker. On day 1 of a job, ask about the system architecture.
Study, study and study again
Debugging is an art which will come with experience. Don't give up on debugging too soon.
Remember that other people know much less than you think
Learn Git before anything else
- Understand the business logic
- Don't be afraid of bugs.
- Be open to asking for help, no-one is going to judge you.
- Jot down the logic on a piece of paper before using the machine.
Learn to accept that you don't know something.
Don't worry about learning too much syntactic knowledge (programming languages). Instead, try to learn semantic knowledge (design concepts, paradigms, concepts, etc)
Syntactic knowledge is easy to get when you have a good semantic knowledge base.
You can do anything but you can't do everything, more so at once.
You are not a coder. You are a human who codes and solves problems. Our identities and worth are so much more than our jobs. Also, ask any and every question regardless if you think people will judge you. All our learning journeys are different.
Don't think of frameworks and libraries like some magic black box of voodoo mumbo jumbo. I notice a lot of beginners don't seem to realiize that we all use the same tools to build the same stuff, even Google, Microsoft and whatnot. They all put their pants on one leg at a time.
LEARN TESTING, it is essential in every development job. The one thing not usually covered in college or tutorials. It's what got me my first jobs is knowing how to test the code I wrote.
- take breaks
- celebrate small achievements
- don’t get stuck in a problem for more than 3hrs, seek for help
- sometimes a pencil is good enough
- google is your best friend
- always start by reading the documentation
Don't be paralyzed by the feeling you don't know the best way to solve a problem; just design and code something. Writing bad code is not a waste of time; you'll gain domain knowledge that you can use to do it better later.
Design -> Code -> Learn -> Repeat
Learn to use tools. Lot of people struggle to do things manually and go off track. While there are high chances that entry level tasks already have wonderful tools.
Expect egotistic employees to give you irrelevant coding tests during employment interviews.
Don’t give up, and remember all code sucks.
That non of your screw ups are your fault. Senior developers are supposed to catch your mistakes before it goes to production. Just keep learning. Guilt free.
Understand the fundamentals of computer hardware
Always add some extra time when giving deadlines
Learn Python now!
Most importantly, improve the ability to search accurately on search engines.
The more accurate your keywords are, more quickly you will get to the solution.
Document and unit test your code.
Know. The . Hardware !!!
Gut instincts get you run over
Universal applications make money, and kill people at the same time
Get great at search query syntax.
Use a pencil and paper. Draw simple diagrams before starting to code
Learn about CSS specificity, and keep your selectors as shallow and simple as possible.
Get a haircut and get a real job
Always read official documentation.
- Never jump to code before thinking the edge cases or before asking the requirements properly
- Before you go with a doubt to a senior make sure to have searched in so ,gh and medium articles
- Don't try to recreate which is already present
- Hone problem solving skills
YouTube and Stackoverflow are your best friends from now.
if it works don't touch it
Prepare yourself for so much working for free.
Document everything you do.
Finalise and review your approach before you write a single line of code.
As you can see, many of the advices are related to soft skills and developing fundamentals. This is not correlated to what junior developers do, focus on trendy tools and languages.
We, as more senior and experienced people, must guide and mentor them to avoid the mistakes we made and to escape from the misleading calls from the industry.