diff --git a/blog/authors.yml b/blog/authors.yml index ecde17f..4e7320a 100644 --- a/blog/authors.yml +++ b/blog/authors.yml @@ -10,3 +10,8 @@ enigmalea: name: enigmalea url: https://enigmalea.neocities.org image_url: https://enigmalea.neocities.org/img/favicon.png + +ms_boba: + name: Ms Boba + url: https://essentialrandomness.com + image_url: https://essential-random.vercel.app/_next/image?url=%2F_next%2Fstatic%2Fmedia%2Favatar.a31caf31.png&w=1920&q=75 diff --git a/blog/senior-devs-howto.mdx b/blog/senior-devs-howto.mdx new file mode 100644 index 0000000..a469655 --- /dev/null +++ b/blog/senior-devs-howto.mdx @@ -0,0 +1,219 @@ +--- +slug: senior-devs +authors: ms_boba +--- + +# A survival guide to senior developers (for junior ones) + +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. + +:::tip + +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. + +:::tip + +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. + +--- + +:::danger + +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 + +--- + +![](https://media.discordapp.net/attachments/1015333622380773386/1015364055357210765/unknown.png?width=400&height=362) + +![](https://media.discordapp.net/attachments/1015333622380773386/1015373381752848484/unknown.png?width=448&height=298) + +[senior devs] + +- [stereotype]: this code I wrote is trash +- [reality]: this code I wrote is trash + +- https://xkcd.com/1053/