00:05:08.210
I’d like to encourage you all to read Freire’s work directly. There is an English translation, and the translation includes thoughtful notes on what the translators chose to translate and what they deemed untranslatable. The text can be quite dense, but the original work is worth the effort. David was discussing the importance of works by Freire this morning, and I have faith that with practice, we can understand the concepts he introduces.
00:05:33.600
In Freire's work, instructors wouldn't start by teaching people to read. Instead, they would ask students about the words they used. Instructors learned about the lives and subcultures of the people they were teaching in a participatory and active way, rather than relying on traditional anthropological practices, which were often observational.
00:05:59.200
Facilitating open-ended discussions about the words people used allowed instructors trained by Freire to connect language with thought. This approach indirectly encouraged adult literacy, making literacy a relevant topic for those Freire and his colleagues were teaching. In these environments, literacy became a tool to help individuals navigate their social systems rather than something imposed by outsiders.
00:06:40.120
The instructors showed respect for their students and connected the material to their lives, enabling them to teach effectively. Before Freire's work was interrupted by the military junta, he developed techniques that allowed adults to learn to read and write in less than two months.
00:07:15.580
Before we delve into the flaws of poor teaching, let’s explore the other side: what are the methods and motivations behind effective learning? People have many reasons for wanting to learn something. For example, they might wish to pass a math test, secure a job as a computer programmer, or simply learn about dinosaurs because they are fascinating.
00:07:27.250
However, as adults, the most significant reason we learn is often due to a pressing need—what feminist scholar Natalia Sisir terms 'emergency learning.' This is the type of learning that occurs when we realize there is something crucial we need to know. Most of us have learned how to unclog toilets on an emergency basis, but as developers, we engage in emergency learning frequently.
00:08:05.150
We practice emergency learning when we Google issues related to our code, frantically skim through documentation, or seek examples to solve styling problems. Many of these situations imply that emergency learning is inherently short-term, but that’s not always the case.
00:08:30.020
Someone might recognize a gap in their knowledge of databases and commit to a longer-term learning project like improving their SQL skills, or they may struggle with front-end skills and endeavor to learn React. While emergency learning is often prompted by immediate needs, it can also lead to long-term projects.
00:09:25.310
Emergency learning typically arises from specific goals. When someone faces issues like why their testing suite isn’t functioning correctly, it frames their learning in a reactive mode, which can limit their exploration of broader learning opportunities.
00:09:58.100
For instance, a developer working to improve their front-end skills may fail to seek out other resources or develop a holistic understanding of how HTML, CSS, and JavaScript integrate. They focus narrowly on their defined goals. This can be necessary and useful but also limiting. These goals arise from real problems that require solving, such as understanding why their tests are failing.
00:10:29.070
In programming, many developers experience emergency learning as they deal with urgent problems. However, often we forget that they already have valuable insight into the issues. When teaching others, we must acknowledge their context and provide learning opportunities that resonate with their specific goals and challenges.
00:11:04.880
This consideration is especially pertinent when we assume that individuals are ready and eager to learn. Let’s take a moment to contextualize this. Many of you may be familiar with Opti Rim, the creator of Ruby Tapas. He shared an anecdote from Ruby Dev Camp where he paired with a junior developer.
00:11:24.700
During their pairing session focusing on the Game of Life problem, his partner struggled with a particular function and repeatedly deleted and retyped the same lines of code. Opti offered his standard solution; however, his partner requested to first focus on passing the current test. When Opti looked up moments later, he noticed an elegant solution on the screen that he hadn’t seen before. This story illustrates how assumptions regarding skill levels and roles can skew collaborative learning.
00:12:12.620
Opti assumed the junior developer wouldn’t grasp a complex solution, yet the partner demonstrated a profound understanding. This example highlights that knowledge doesn’t exist on a binary spectrum, and recognizing our limitations can improve learning from one another, regardless of background or experience.
00:12:34.890
Regardless of experience level, developers can learn from each other. For the remainder of this talk, we’ll explore how to effectively collaborate with others, especially those earlier in their careers, and how to guide them towards adopting better practices without prevailing over their learning process.
00:13:03.130
Teaching new concepts to early-career developers may sound straightforward, but we often mismanage these situations by centering our own agendas. Instead of collaborating effectively, we may unintentionally frustrate our peers by asking patronizing questions or attempting to lead discussions in ways that showcase our knowledge.
00:13:34.660
This tendency to dominate dialogues can alienate our peers. We sometimes conceal our mistakes to avoid damaging our image as professionals, diverting the teaching focus back to ourselves instead of the person we’re mentoring. This approach diminishes the learning experience, making it more about us than about addressing the needs of those we seek to support.
00:14:03.180
When teaching early-career developers, we must avoid creating a dynamic that resembles a charity case rather than acknowledging their capacity as full-fledged developers. It’s crucial to maintain equitable interactions, ensuring we don’t overshadow their contributions.
00:14:38.820
To facilitate meaningful development, it’s vital to stop defaulting to teaching mode and recognize the mutual benefit as we exchange ideas and learn from one another.
00:15:05.260
When working with junior developers, pay close attention to their actions, read their code reviews, and ask for their opinions sincerely. This approach allows them to share their perspectives, enhancing both mutual understanding and connection.
00:15:30.760
Utilizing behavior-driven development when collaborating with newer developers can create productive feedback loops and help focus on manageable aspects of tasks, promoting a more organic learning experience. If you can maintain a balance and provide the necessary scaffolding for your pair to grasp their current challenge, both of you will benefit.
00:16:06.870
When issues arise, it’s crucial to help developers break down larger problems into manageable steps. This structure can guide the learning process without overwhelming them. Be transparent with your judgment and share your perspective openly, making space for your partner to manage their learning process effectively.
00:16:55.260
It’s also essential to model vulnerability by acknowledging your mistakes. When we portray a false image of flawlessness, it harms the newer developers we work with, causing them to internalize the notion that errors are unacceptable.
00:17:29.870
Letting them believe they are responsible for any confusion resulting from your mistakes is detrimental; instead, embrace your blunders and share them with transparency. By doing so, you normalize the learning process and create a more supportive learning atmosphere.
00:17:58.800
There are times when it's fitting to adopt a teaching approach when you notice a partner struggling against their knowledge limits. If you observe them repeatedly finessing the same few lines of code or expressing frustration with their work, it’s critical to approach instruction thoughtfully.
00:18:30.070
In such cases, frame your guidance as optional help. For instance, you might say, 'Can I show you a trick?' This formulation allows you to offer support without imposing solutions, focusing on collaboration and fostering an environment of shared learning.
00:19:12.750
When working with junior developers, their discomfort with unfamiliar techniques is a signal to tread carefully. While you might feel tempted to explain, remember that your primary goal is to create maintainable code, respecting their comfort level with techniques.
00:19:56.420
Be willing to adapt your approaches based on their preferences, even if it results in code that might not align with your standards. The most significant lesson for entry-level developers revolves around developing their technical judgment and confidence in their decisions.
00:20:35.210
These qualities are built through recognizing your opinions as personal rather than universal truths. Acknowledging your mistakes also enables them to understand that it's okay to learn from errors.
00:21:10.840
Committing to fostering trust and confidence in an entry-level developer's abilities—while genuinely engaging with their perspectives—multiplies learning opportunities for both parties.
00:21:48.640
Then, we’ll transition to teaching concepts to peers. The techniques we've discussed are still relevant, but the dynamics shift.
00:22:26.050
Your peers likely know more already and need to learn fewer concepts at once. Their existing knowledge allows for bigger leaps. As such, adapt your pace and listen more actively to their insights.
00:22:54.200
When working with peers, avoid making assumptions about what they do or do not know based on first impressions. Ask questions about their familiarity with specific technologies and never underestimate their existing competencies.
00:23:26.240
When introducing new concepts, understand that experienced developers will evaluate these through lenses formed by their existing experiences. Rather than assuming they will find value in something new, show genuine curiosity about their perspective.
00:23:56.160
If they express skepticism, listen earnestly; they may have valuable insights grounded in their experiences. Move towards collaboratively implementing solutions that address their concerns instead of trying to prove them wrong.
00:24:38.510
Now, let's pivot to encouraging early-career developers to adopt better practices. The secret lies in offering the same respect and space that we provide experienced developers. While this may require sharing additional context, it's essential to affirm their capabilities and guide them to develop their technical judgment.
00:25:10.610
It's important to trust their judgment, especially if they don't recognize the superiority of a specific method you’ve favored. The pathway to effective learning involves fostering an environment where their decisions have value and pertinence to their development.
00:25:44.000
Thank you for joining me today. I've recently stepped back to a board role at Cohere, and I'm open to discussing potential opportunities with those who resonate with these ideas. Cohere offers various courses, including 'Mastering the Object-Oriented Mindset in Ruby' and 'Debugging Downtime.' We also have a forthcoming course focusing on asynchronous JavaScript.
00:26:27.020
Every course emphasizes dialogue and engagement, encouraging active disagreement and conversation as a central learning strategy. Your ability to challenge ideas enables richer discussions that amplify the learning experience.
00:27:10.520
In today’s work environment, maintaining belief in what you do is paramount. If you're interested in pre-ordering the upcoming asynchronous JavaScript course, I assure you it will be worthwhile.
00:27:51.850
I appreciate your attention; thank you for being here to explore these ideas together. Let's continue the conversation.