If you're diving into the world of programming for the first time, or making the jump from hobbyist to "junior professional", it's easy to get intimated by more senior developers. Indeed, while often well-intentioned, senior developers often forget how it feels to be a junior engineer facing their first challenges, or makes it hard for them to tailor their questions and replies to varying levels of experience.
If you're a beginner, this article is here to convince you of a simple (but sometimes hard to believe) truth: it's not you, it's them. I hope that, armed with this newfound knowledge, you'll be able to advocate for better-tailored help, and feel empowered to push back against non useful advice.
It's not you, it's them (I swear)
Self doubt is one of the greatest challenges you'll face as a beginner (and, alas, often beyond). Programming is, for better and worse, a vast and deep field, whose learning curve can be steep and overwhelming. Many tidbits of knowledge that people—you included!—pick up during their programming journey quickly become second nature, and in the longer term developers often lose the ability to separate what's common knowledge from what they've only learned after hours and hours of desperate Googling.
When you're getting started, it can be useful to remember these unfortunate truths:
- Programming tutorials will often omit necessary steps or required information.
- Even the most well-intentioned of senior developers may rely on terms and examples that are not beginner-friendly.
- Documentation may be outdated or straight-up misleading.
No matter how tempting the assumption that a lack of understanding means you're not made for "this whole programming thing" might be, the more likely explanation is that what you're reading is indeed unclear, or unwittingly relying on non-obvious knowledge. If senior developers or tutorial writers are not stating the "obvious", this is often not because it's, well, obvious, but because they forgot it didn't use to be obvious to them either.
When you find yourself confused, it's your right to ask for help with tutorials, or to request simpler explanations. Doing so has no bearing on your ability as a developer, or your future success as a programmer. If a senior developer makes you feel like the problem lies with you, it's more likely their own issue instead. Don't let them discourage you.
If you find a confusing explanation in an open source project (like this wiki), its owners will often be overjoyed to have some help fixing the issue! Clarifying documentation or adding missing explanations can be an excellent way to get started contributing to your favorite projects.
Developers are never done learning
No one has ever been (or will ever be) able to 100% programming knowledge. Even if one were to restrict themselves to a very specific branch of the many possible learning pathways a developer can take, it's highly unlikely they'll ever gain perfect knowledge of their chosen subfield.
While this may seem scary at first, knowing you don't have to know everything—and you shouldn't try!—can also be liberating. Indeed, your own goal when learning should not be to gain perfect knowledge of every programming term, every best practice, and especially every programming language; and when you see a senior developer eloquently field questions about their favorite topic, know they themselves may be hyperaware of how much they don't know about their own favorite subject.
If you're ever feeling discouraged, try asking a senior developer which topics they've given up on, or the latest buzzword they keep hearing but didn't have the strenght to look into yet (and never might)!
When a developer moves outside their comfort zone, they can also find themselves overwhelmed with new, unknown terms, and may often be as confused as beginners when "domain experts" talk among themselves. But even when they don't have experience in a specific subject, however, you might find that senior developers may effortlessly solve problems you had found unsurmountable. While this can feel discouraging, it has rarely to do with innate programming ability. Instead, here are a few tricks up their sleeves you might not realize they have:
Senior developer have often made that same mistake. Indeed, they probably have made that same mistake way more times than you have! They may even have done that same mistake that very same day. Indeed, being a senior developer is not about not making (sometimes basic) mistakes, but about being able to more efficiently spot and recover from them. The more mistakes you make, the sooner this will be true for you too.
Programming experience makes you better at parsing error messages. When you're just starting, error messages will feel overwhelming, unreadable, and confusing. While this may never stop being partially true, the more experience you gain with programming, the more you'll learn to extract the important information out of them, and to translate out meaning from sometimes-cryptic language. There's no substitute for practice here!
Senior developers know how and what to google. If you've found yourself spending hours on a search engine while desperately trying to figure out the solution to an error, I have bad news: that's an unfortunate part of programming that's unlikely to ever go away. There is also some good news, however: not only it will happen less often, but you'll be able to more easily discern what to search for, which solutions may or not be relevant, and—the hardest skill of them all—when to give up and try a different approach.
As a beginner, it can be helpful to ask a more senior developer how they arrived at a solution you found non-obvious.
Remember that the best attitude to approach programming with is one attitude of curiosity and commitment to continuous learning: if a senior developer belittles you for lacking "obvious" knowledge, they're showing your their limitations, not yours. Even among seniors, your expertise and contributions matter, and the perspectives—or questions!—you offer are valuable and deserve to be appreciated.
And, once you yourself become an expert, remember: acknowledging the limits of your own expertise can go a long way in helping others feel sure that is ok not to know everything.
Everything underneath here is a draft!
The double-edged sword of jargon
jargon makes explanations simpler for senior devs, but can make explanations harder for junior devs. Try to tailor your language, but regardless ask for explanations.
(seniors) Before using jargon, try ensure that the junior dev knows what that jargon means
(juniors) If the senior dev uses jargon you don't understand, and it's impacting your ability to follow the discussion, ask them to clarify cause they might not realize you don't (and it's ok that you don't)
as a senior dev I also feel bad being like, "do you know what a [basic concept] is?" too often, cause people can feel like you're asking because you think they aren't good enough to know [basic concept]? but there's a lot of basic concepts I also don't know as an expert
apple has a general bit of advice which is like "don't use jargon but do use terms of art" the dividing line is like, what would be most useful to search on stackoverflow
junior developers are in a vulnerable position because they can't counter your claims with their level or knowledge, so you need to be careful about explaining where your reasoning is coming from
Good code does not exist (only "better" one)
i feel like "opinions are important but clearly delineate them from facts" is a good bit of advice
it's fine to express an opinion and i think junior devs should respect those opinions but oftentimes i think they take them as stronger than they are, like if i do $x EVER that means i'm BAD and a TERRIBLE PROGRAMMER, no, it's in the language for a reason, it just has some drawbacks so maybe try this other way instead
- (junior dev) Senior devs often have strong opinions, some of which have been passed down to them by other senior devs, and some of which they have developed through the years. While there's a lot you can learn from these opinions, there can be a lot more depth and nuance to the issue than you (or even the senior dev) are aware of. It's fine to ask clarifications on the reasoning behind a statement, and to take even "widely accepted practices" with a grain of salt.
- remember that no one has written good code like ever
- industry standard != best practices, is the argument i recently got into lol
- here's more at play in a non-hobby environment that's gonna guide what's common and not. usually money and time are gonna be big factors, needing to hire a specialist might not be feasible but maybe hyperfocusing on something for 8 months straight is for someone with a cool brain. the industry standard is gonna prioritize and balance different things that a hobby coder maybe doesn't care about or that are irrelevant to them... so being transparent when giving advice is good. and being clear about what is and isnt important to you is as well
- "if someone makes general disparaging statements about programmers, that's most likely a they problem, it's not about you" or I guess "sometimes people make those strong statements in frustration, pls don't take them seriously"
- "you have the right to mess up, and actually you will mess up, so don't try to prevent that at all time cause no one can"
As a junior dev you have the right to push back and say "this isn't useful!"
It's all about your goals
Senior devs love to infodump
and I think many senior devs (or at least me, i'm super guilty here) love programming so they have a tendency to want to teach people good practices etc. cause they love talking about, and I think that's valuable but not for everyone
- (junior devs) It's ok to push back on too technical or too in depth explanations and say, "thank you, but I'm only seeking to [solve this specific use case? get this thing done then go play videogames?] today"
(senior devs) Before launching into a long-winded explanation with someone you have no pre-existing rapport with, try asking questions about their goals
I do think we should make some allowances there for "if someone is a regular and you know they love in-depth explanations you don't need to ask all the time"
(senior dev) remember that best practices in a professional environment might be overkill or not relevant to hobbyists. Consider the person's goals when you're giving advice.
for junior devs, part of me wants to say "remember that senior devs often come from industry, and that industry often optimizes for long-term maintainability, ability to grow to many users, and many people working on the same program. While you might want to learn about these practices, they might not be relevant to your personal projects. Feel free to ask the senior dev "do you think I should use my time on fixing this [for the project I'm doing now]?"
You are welcome here
- it is intimidating if people are talking shop and you're standing there like "can someone help me center this div? " and at the same time, you have all the problems of a regular discord server where people imagine cliques or that they're not welcome to join the conversation.
Goals of this article:
- Guide senior developers on how to keep discussions welcoming to junior developers
- Guide senior developers on how to effectively give advice to junior developers
- Help junior developers understand the blindspots senior developers might have during discussions
- Help junior developers feel confident asking for clarifications when needed
- Help junior developers feel confident setting boundaries when discussion isn't being helpful
[senior devs]
[stereotype]: this code I wrote is trash
[reality]: this code I wrote is trash