Empower students by designing lessons that combine soft skills with programming. Soft skills are traits that describe a person’s work habits such as curious, logical, meticulous, persistent, creative, team player, and communicator. They include qualities that influence how a person approaches a task, solves problems, interacts with others, and resolves conflicts. Soft skills not only help a programmer do their job – they are transferrable to most school assignments, social situations, and workplace environments. Given their importance in this blog series, let’s explore essential soft skills and how you can target them within your programming lessons.
7 Essential Soft Skills Every Programmer Needs
A programmer needs to do more than write and debug code. If only it was that simple! Instead, their job is diverse. Throughout the work day they may partner with a co-worker to brainstorm ideas, track progress for a manager, field test a program, meet with clients to understand their needs, train users, or present a project to investors. No matter the task, these seven essential soft skills play an important role:
Encourage Your Students to Be Curious
Curiosity is a valued trait in a programmer. Curious people are eager to learn. This is extremely important when devising innovative coded solutions. After all, you can’t design something that has never been made before if you are unwilling to ask “what if? or “why not?” People who are curious:
- try something new
- welcome surprises
- take risks
- ask questions
- are not afraid to fail
- keep an open mind
Develop Curiosity – Combine Soft Skills with Programming Skills
Curiosity in education is valued in primary school as teachers celebrate exploration. Children wonder about the world, ask questions, and investigate to find answers. Over time the word curious loses its place within curriculum. It should not, as being curious leads to learning and new discoveries. This is why this soft skill is so valued in the workplace.
So how can you encourage your students to be curious? When teaching a programming unit, a good start point is to acknowledge the fear of learning something new. A programming language is something many students may have never seen before. At first glance, it may seem confusing and overwhelming. You need to create a safe space, where it is okay to take chances, experience failure, and struggle with the unfamiliar. In fact, you want your students to embrace the unknown.
To that end, discuss the word curiosity and talk about its meaning. Remind your students of how much they enjoyed being curious when they were young. Take a minute to have them reconnect with their inner child that is full of awe and wonder about everything new. This will create a positive attitude towards learning a programming language. Remind them that they don’t need to be good at writing programs right away and not everything needs to make sense. All they need to do is be curious.
Explore and Investigate
One way to promote curiosity is to design coding activities that have students edit an existing program to explore the meaning of code. They can add text, alter the output, or reorder steps. Each time, the program works – it is just a bit different. This investigation is a fun way to try something new. The focus is on discovering what if I do this or what if I do that, instead of worrying about writing perfect lines of code.
Predict the Output
The next step to developing curiosity is to have students guess the output for a code snippet. Have students type in lines of code, make a prediction, and then run them to see what happens. No matter whether they are correct, it is a nice surprise to view the outcome.
Extend Learning to New Situations
Another way to encourage curiosity is to provide an example and then have students code something similar. This technique provides a foundation of knowledge that can be transferred to a new situation. It makes it safe to take risks because the space between what is known and unknown is manageable.
Questions and the search for answers are the hallmark of a curious person. They become the catalyst for taking chances and discovering new ideas. For this reason, it is important to have your students pose questions throughout a programming unit. You may want to provide some question starters to get students wondering:
- What happens if…
- How do I…
- Who can I ask to find out…
- Which program has a snippet I can use to…
- How did that person make the program do…
As a class, make a list of resources or methods students can use to find answers. For example:
- trial and error
- ask a friend
- view other programs to get ideas
- study sample code that does a similar task
- copy and paste code from a working program
Break Code and then Fix It
Another approach to having students become curious is to intentionally add bugs to break the code. This activity creates a learning environment where it is okay to fail. When a person tries something new they will often be unsuccessful. This is especially true when programming. Writing a program can become frustrating because if there is an error in the code, then it will not run. Since this is a common occurrence, it is important to explicitly teach debugging strategies.
Provide students with a working program and then have them break it by adding bugs. Each time they run the code and it fails, they can then fix it. This reframes failure into a setback that can be overcome. Instead of errors squishing curiosity, they ignite it. Breaking a program has students wonder what will happen if I remove this or can the code still work if I move or delete that.
Track Changes in Ability and Attitude
Yet another task that supports curiosity is to monitor progress. This should include programming abilities as well as attitude towards coding. Reporting could take the form of a rating scale that students complete at different times throughout the programming unit.
This may seem like an odd technique to have students become curious. However, by students documenting what they can do and how they feel at the start, middle, and end of a task, it makes accomplishments noticeable. Students can reflect upon the change in themselves as they move from a novice to an expert. There is a shift from “I can’t do it” or “I don’t know” to “I can do it” and “I do know”.
This change highlights the need to keep an open mind when learning something new. Instead of judging the task and instantly concluding it can’t be done, students become curious as to what might happen if they try. Their past success paves the way to future achievements.
Combine Soft Skills with Programming
When planning a programming unit, consider the importance of soft skills. Unlike hard skills which are technical competencies and intellectual knowledge, soft skills are often difficult to teach. However, the suggestions above include many activities that will develop curiosity at the same time as they build programming abilities. It does not take much instructional time to target soft skills, and since being curious is important for learning new things and developing new ideas, it is well worth including in your lessons.
To discover even more ways to combine soft skills with programming, continue to follow this blog series. The next article is about being logical. Not only is this a valued trait in a programmer, but this way of thinking is an asset in any workplace or learning situation.
Aside from the reading the blog articles, check out the TechnoPython technology project below. It has lessons that explicitly address soft skills in a programming unit. Moreover, it includes everything you need to teach Python to beginners.
TechnoPython Combines Soft Skills with Programming
Soft skills are a focus throughout the TechnoPython programming unit. In this technology project students become game developers. Not only do they learn about the python programming language, but they also complete activities that encourage curiosity.
Specifically, in Session 1 students develop curiosity while exploring the Coding Jungle. The goal of this mission is to learn about Python. To start, the explorers are introduced to terminology by experimenting with code. Once familiar with the role of a programmer, they play a Python Hunt game and then edit the program to discover how it works. Afterwards, they break code in the Catch the Bugs game to develop essential debugging skills. Upon completion, students reflect upon how being curious helped them successfully finish the four-part mission.