Why it is hard for developers to learn another language and how a professional training can help - Part II
In our last post in the series, we focused on how the dialogues in a group setting that a professional training provides are crucial for developing the mental model of a new programming language. The right mental model is necessary to be successful in the learning process. In the second part of this series, I will focus on how our process which combines lectures and hands-on exercises, supports the developer to develop the right mental model for learning.
A short recap:
We are regularly confronted with the fact that experienced programmers find Rust a language hard to learn. Research suggests that this is not only the case for Rust, but a general problem: If you already know one programming language, learning another comes with its own set of challenges. In this blogpost I will discuss the findings of the article Here We Go Again: Why is it difficult for Developers to Learn Another Programming Language? in the context of how a professional training can help to overcome the issues the authors raise.
The article identified three major sources of problems that make switching to a new programming language difficult:
1. Interference when learning a new language
When learning something new, we try to connect the new information to similar information that we already possess. The old information can help to integrate the new information, but it can also interfere with learning something new, because the similarities are too superficial, or the new information contradicts the old information.
2. Programmers apply opportunistic learning strategies and learn on their own.
“Just in time learning” is described as a learning strategy that is based on a need-to-know basis using online available resources while learning alone. Instead of learning a new language systematically from the ground up with a broad horizon of application in mind, the focus is often on a narrow skillset required to get a very specific task done.
3. Breaking of old habits and shifting mindsets becomes more difficult.
Learning a new language requires a mind shift, getting familiar with new tooling, possibly building a new mental model of what programming looks like in the new language. Using your old mental model as a sole guide to learning a new language can make it very hard to get into a new mental model, which is necessary to be successful in the new language.
How can a professional training help you save time and reach your goals more effectively?
Let’s take a closer look at opportunistic learning strategies
From our last post one can conclude that learning alone is inherently problematic and to be avoided. At this point I want to make clear, that being able to learn in a self-driven way is not only a great skillset to look out for in employees, but also a necessity for adapting a new language on a team.
But relying on this ability of individuals alone when up-skilling an entire team on a new technology is not very time effective and not the best use of this skill. A couple of things make a self-driven approach rather costly:
There are a growing number of good books and exercises out there that are great resources for learning Rust. But this is also where trouble begins: The process of selecting which ones are suitable, be it quality wise, or approach wise takes time at best and is frustrating at worst.
In a lot of materials, the connection between theoretical knowledge and practicing programming in the new language is weak or missing. Books explain the language but lack exercises tailored to the theoretical chapters, so the knowledge remains theoretical. Exercises have solutions but don’t explain how to get there, leading to memorizing patterns instead of developing strategies for problem-solving. The engaged learner bridges these gaps by themself, but this process requires time and a great amount of effort.
Old habits and persisting mental models are an additional factor that makes learning Rust -when learning alone- harder than it needs to be. We focused on this factor in Part I of this series.
To get anywhere in a timely manner, a systematic approach is usually abandoned in favor of the above described “just in time learning” that leads to fragmented skills that has little to do with idiomatic Rust.
The Solution: Stay on the paved way and leave it only when you must!
While Rust’s adoption in the industry is just beginning, the language has been around for quite some time, and we have been teaching it since 2015. Our significant experience in the industry has enabled us to figure out what works and what doesn’t so you don’t have to reinvent the wheel.
We regularly assess our trainings for effectiveness and the findings are integrated to improve our material and training approach. You’re benefitting from the experience we gathered from training hundreds of teams. A professional training like ours will lead you on a paved way to learn how to write idiomatic production code in Rust in a couple of days. This saves time for after the training, when your team needs to leave the well-paved way for when they apply the learned skills for your special use case. Starting this journey from a solid base makes all the difference.
We combine theoretical input and hands-on exercises.
Our training comes with lectures for the theoretical foundation but is also packed with hands-on exercises that focus on applying what has been learned in its context in a supportive environment. The exercises are a fundamental part of the learning journey: Only by applying the newly learned information is the learning process complete.
A typical scenario from lecture-based learning: The information presented makes sense in the context, it sounds coherent and does not contradict your previous knowledge, just adds up nicely to it. Overall, everything is comprehensible, you’re also able to repeat some of the facts. You think you understand. Back home you’re trying to apply the new knowledge, and you don’t even know where to start. The reason for this is that listening to the information and processing it is a different skill then applying it. Our training incorporates both and ensures that you are actually able to use what you just heard in the lecture.
A training is too short to change old habits, but our exercise-based approach can give an idea what old habits aren’t useful for Rust and what to do instead. A seemingly simple example, but one of the most effective interventions: Throughout our trainings we have to remind folks frequently to read the full error message and follow the suggested steps. Our participants are used to the limited helpfulness of error messages of other languages, so reading the messages from the Rust compiler and following the suggestion is something they are simply not used to and something one does not necessarily try if one doesn’t have the experience that this leads to success.
A professional training gives your team a head-start by avoiding opportunistic learning styles in favor of a systematic approach that combines theoretical and applied knowledge: This is the fast lane to up-skilling an entire team to be able to write production code in Rust.