Article on fostering better senior/junior dev communication

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

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.
+
+<!--truncate-->
+
+## 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/