9

Coaching Your Coders

Unlike direct instruction and in-class scripted exercises, a primary feature of PBL is student flexibility in choosing their project focus along with independence and personal responsibility for developing it. In PBL the teacher takes the role of facilitator and coach, allowing students autonomy in forging their own learning paths, but always at the ready to provide support when needed. Providing support to many different ­projects, several of which will fall outside your areas of expertise, can present a significant challenge.

To provide this support, it’s important to be familiar with generalized, adaptable troubleshooting techniques as well as the common pitfalls software development is prone to. In this chapter, we’ll review how to mentor your students to work through technical and personal challenges, and educate them on habits of mind that will alleviate stress and improve tenacity. With these techniques, you’ll provide your students with toolkits for troubleshooting their code, staying productive, and keeping a healthy mind-set when facing adversity.

Technical Challenges

Programming is complex, and a great deal of time writing software is spent on researching how to accomplish specific tasks and troubleshooting when code doesn’t behave the way we want it to. Most of the problems students run into will be technical in nature. Educators should coach students through troubleshooting their code and finding answers in such a way that students will eventually learn how to work through technical issues independently, in preparation for when you won’t be around to provide them with tech support.

When providing any technical support, the first step is to ask the student, “What have you tried?” It’s important to set an expectation that students should first show they’ve thoroughly engaged the problem by giving an overview of what they’ve tried and demonstrating at least some understanding of the issue. This will later be expected of students when they seek help in online forums. Forum members often ask users requesting help to “show your work” to better understand the context of the issue or where the misunderstanding resides.

Having the student articulate the problem in detail also introduces them to what developers sometimes refer to as the teaching technique of troubleshooting. This technique was popularized by physicist Richard Feynman. He believed the best way to deeply understand an issue is to prepare to teach it to someone else. Using this technique, the developer explains or “teaches” their problem to someone who listens quietly and nods their head encouragingly. The developer explains what the code is meant to do step-by-step so the listener will understand. This exercise often results in an “Aha!” moment, where the problem becomes obvious to the developer without the listener needing to say anything. The technique is so effective it’s rumored that one university kept a teddy bear at their help desk, and students had to first explain their problem to the stuffed animal before they could talk to a human.

Once the student demonstrates how they thoroughly investigated the problem, you’ll have the background information needed to begin assisting them. There are two main categories of issues programmers tend to have. One is that they wrote code that isn’t doing what they want it to do. The other is that they don’t know how to program something in their code.

Figure 9-1 provides a flowchart of the troubleshooting process.

This is an iterative process that shows where to investigate and how to prioritize tasks. It’s a rough guideline, and you’ll find developers will customize it according to their personal styles and levels of expertise in the professional world.

As we covered earlier, your role in providing support begins with the student showing their work. Once the student demonstrates they’ve properly engaged the problem and can explain it using Feynman’s teaching technique, how we proceed depends on the kind of problem challenging the student. One path will be for existing code that doesn’t work as expected, and another path will be for when a student doesn’t know how to accomplish a task in code. In the next section, we’ll follow the branch for when a student’s code isn’t working as expected and prioritize the places to look when trying to understand why.

Troubleshooting Existing Code

In the Chapter 7 sample exercise where students evaluated multiple approaches to implementing a palindrome function, we noted that there aren’t always clear right and wrong ways to solve a problem. Similarly, when trying to understand code and why it might not be working the way we intended, determining the best approach to take can depend on the specific situation. Like coding styles, debugging styles can be a matter of personal preference.

As a best practice, students should understand that coding and debugging are iterative processes. Programmers should remember to code a bit, test a bit (CABTAB). If you write 100 lines of code before executing them, potentially that’s 100 lines of bugs. Conversely, if you write two or three lines of code and test them, you’ll have a much smaller portion to debug. When we follow CABTAB, if something goes wrong, we know that the first question to ask is “What did you last change?” Most likely, that’s where we’ll find the bug.

Again, personal preferences and experience come into play when debugging. How much is a “bit” of code? For a beginner programmer, it could be a few lines. For a veteran programmer, they might feel confident writing a few hundred lines of code before debugging. Confidence increases as programmers become more comfortable with the many troubleshooting tools available to them.

For JavaScript programming, the web developer tools are the first place to go when code isn’t working right. Start by checking the web console. If any bugs are breaking the code execution in the browser, the related error messages will appear in the console. For example, if you enter the code in Listing 9-1 in a web page and load it, it will produce an error on the second line and fail to execute the console.log() instruction.

var myString;
myString.replace('Babbage','Lovelace');
console.log(myString);

Listing 9-1: Code that results in an error

Figure 9-2 shows what this error looks like in the console. In this case, it reads Uncaught TypeError: Cannot read property 'replace' of undefined at index .html:5. The index.html:5 part of the message is where the error occurs in the code, in this case line 5 of the .html page, so we know where to start looking.

If an error displays in the web console, it also provides a line number in the code where we can start looking. If the student doesn’t understand the error, have them copy and paste it into a search engine to see the results. But first make sure they strip out any variable and function names specific to their code to avoid confusing the search. They’ll almost certainly find lots of other programmers who at one time ran into the same issue and many others who are more than happy to explain what the error means in a variety of ways.

In the Listing 9-1 example, the issue is with the variable myString. replace(). This is a built-in JavaScript function we can execute from a string, like 'bot'.replace('o','i') to change “bot” to “bit.” Because we haven’t assigned a string value to myString, it’s “undefined.” Similarly, if we changed the first line in this code to var myString = 123; and refreshed the browser, we would get the error Uncaught TypeError: myString.replace is not a function at index.html:5. Because 123 is an integer variable type, it doesn’t have a .replace() function. These kinds of variable assignment errors are very common in JavaScript programming because of how it handles variables compared to other languages.

Different programming languages will have different rules concerning variable assignment and scope. JavaScript is a dynamically typed language, meaning a variable’s type is checked at the time the code is run. So your variable can be null at one point in the code, an integer later on, and a string even later. Although JavaScript allows this behavior, it’s a good practice to keep variable types static throughout the application for simplicity.

If the web console is error free, but the code is not doing what is intended, direct the student to the debugging options in the web development tools, as discussed in Chapter 7. Navigate through the code step-by-step as it executes, making sure each variable holds the expected value and each step goes where it’s intended. Often, students will find a mixed-up Boolean condition, such as an and operator where an or operator should be, a loop that runs too long or too short, or the wrong value assigned to a variable.

Sometimes stepping through the code with the debugger is unfeasible. Consider the minimax algorithm in “Recursion ” on page 114, where the program uses recursion to explore every one of the 255,168 potential tic-tac-toe games. It could take days to step through so many iterations. If the student does find an issue, they’ll be so buried in the process or stack they won’t understand why it’s happening. In such cases, it might be more convenient to have them add logging to their code to output specific information to the web console as the code executes.

The jumpingJacks() function in Listing 9-2 uses recursion to animate a stick figure, setting the animation to the jump frame on each odd number value for i, and includes logging to track the variable values as the code executes. Run this code in the web console to see each step in action.

var frame = '';
var timeOut;
function jumpingJacks(i) {
  //If i is an odd number
  if (i%2) {
    frame = '<pre> \O/ 
 _|_</pre>';
  } else {
    frame = '<pre>  O 
 /|\ 
 / \</pre>';
  }
  document.body.innerHTML = frame;
  console.log(i + " = " + i%2);
  //Recursively call jumpingJacks in one second intervals.
  timeOut = setTimeout(function(){jumpingJacks(i + 1);}, 1000);
}
//Stop any previous animations
clearTimeout(timeOut);
//Start our animation
jumpingJacks(0);

Listing 9-2: Recursive function animating a jumping character

This code will execute forever or until the computer runs out of memory. The ­console.log(i + " = " + i%2) function outputs the value of i and the output of i%2, which returns the remainder of i divided by 2. As a result, we can simultaneously watch the code run in the browser window and watch the console.log() values out­putted to the web console.

Another way to output values is the JavaScript alert() function. Replacing the console.log() call in Listing 9-2 with alert(i + " = " + i%2) will display a pop-up message in the browser with each iteration, pausing the code execution until the user clicks OK. This is very similar to using a breakpoint in the debugger. In fact, before developers had web development tools, they made heavy use of the alert() function to debug their code as it ran.

Although not a tool available to client-side JavaScript, note that many software applications use log files to monitor their applications. These text files log application errors, events, and the time they occurred. Similar to console.log() calls in JavaScript, the software writes various error messages and application details to a text file so the programmer can monitor the software’s operations. As a result, if a user experiences a problem after the application is deployed, the programmer can review the log for information on what might have happened.

Throughout the debugging process, the student developer shouldn’t hesitate to run web searches on any new function or error message they encounter. The acts of coding and troubleshooting will constantly expand their debugging knowledge. They’ll gradually gain a deeper understanding of the system and become fluent in tackling common bugs and behaviors.

All of these methods, from looking at the last change students made to reviewing the web console, using various techniques for debugging, and searching the web, are different ways of looking at a problem. Usually, using these approaches will be enough to figure out most issues, especially because they’re the same issues other developers have encountered and sought help on many times online.

But what do you do when the student has hit a wall and simply can’t solve the problem, even with your help? As a last resort, you can submit a question to an online forum like Stack Overflow (https://stackoverflow.com/) and start a conversation with the community for help. We’ll explore web searching and community forums in more detail in the next section on approaches for when a student doesn’t know how to accomplish a specific task.

Another effective idea is to take a break from debugging the problem. Walking away from a challenging problem doesn’t mean you stop thinking about it. The problem will likely continue to run as a background process in the student’s mind. Often, IT professionals will hit upon solutions or new areas to investigate when they’ve taken a break from it. This can be difficult to do when you’re working under a deadline, so the break could also mean having students focus their efforts on a different part of the software.

Now that students know how to troubleshoot code they’ve already written, in the next section we’ll explore strategies for when a student doesn’t know how to code a solution at the outset.

Finding How to Solve a Problem

The second kind of problem developers run into is figuring how to do a task in code. Beginner coders will lack the robust cognitive toolkit of programming techniques and solutions from which they can tackle different kinds of problems. Part of the problem is that inexperienced programmers might not know which tasks are hard to do in code and which are easy. Distinguishing between computationally complex and simple problems is itself a complex problem.

As with debugging code, the first step is to have the student explain their understanding of the problem and the solutions they’ve researched to solve it. Then ask whether the student can decompose the problem further. If the problem is too complex to solve, breaking it down into smaller, more specific problems and solving those one by one might break the impasse and help the student make progress.

As an example, let’s revisit the “Mandala Factor Finder” exercise in Chapter 1. Suppose we want to reproduce such a computational artifact in code. Figure 9-3 shows what this might look like.

If a student researches how to draw this specific figure, they won’t find any information. Producing this drawing with code requires solving multiple problems. But if they break down the elements of this image into individual problems, they can solve each of them and iteratively create this image.

For example, the first problem we might want to solve is how to draw numbers on an HTML canvas element. The first 12 numbers are positioned at the same points as on a clock face. If the student can find someone online who has drawn a clock face, they can adapt that code to position their numbers. As the numbers go around in circles, they follow a spiraling line. Students can then find code to draw a spiral and adapt that to position the numbers so they radiate outward. In addition, this mandala shows prime numbers in boldface, so a function to identify primes is necessary as well.

For each of these smaller problems, the student would find numerous examples and approaches to solve them. But to find those examples, they might need some guidance on web searching. Here are a few tips for students to find what they need using a search engine:

Include the programming language in your query If your question involves JavaScript, add the word “JavaScript” to your query (for example, “how do I set text to lowercase in JavaScript”). If your question involves styling, include “css” in your query (for example, “how do I make purple text with css”).

Use natural language Using natural language is the difference between searching for “JavaScript replace” and “how do I replace dashes in a string with JavaScript.” The first query will point you to a technical document about the JavaScript replace() function. The second query will point you to friendly, easy-to-understand results with code you can likely copy and paste right into your project from a forum where someone was trying to solve the same problem.

Refactor your query If a search failed to turn up what you need, review the suggestions that did come up. See what kind of results appear, and then refactor the query to more clearly define what you’re looking for.

Many of the search results will be from coding forums. In Chapter 7, we completed an exercise where students evaluated different programming solutions to the palindrome function to practice talking about code and articulating why they preferred some solutions instead of others. In the forums, they’ll see that many programmers have these same debates. Students will benefit from reading these discussions as examples of how to talk about code.

Online Forums

Online forums are collaborative discussion sites, and when a student can’t figure out answers to problems after exhausting other avenues, they might need to turn to these helpful communities. Posting to a forum should be the last step for two reasons. First, it can sometimes take a while for other users to answer the post. Second, when the student posts their question, they need to show that they’ve thoroughly researched the issue by providing a detailed explanation of the problem, what they’ve tried, how they understand it, and possibly an MWE. Posting the question online should come after thoroughly working through all other options.

In addition to seeking help, your students might also reap the benefits of providing help on these online forums as extra credit or as a class activity using anonymized classroom accounts. We’ll explore this topic in the next chapter on community building at your school.

For a deeper dive into problem-solving techniques in programming, I highly recommend Think Like a Programmer by V. Anton Spraul (No Starch Press, 2012). In this book, the author provides many kinds of troubleshooting techniques, from generalized strategies for solving puzzles to specific ways of troubleshooting arrays, recursion, and other kinds of data structures and controls. Spraul introduces educators to many ideas and methods they can pass along to their beginner coders in the classroom.

Beyond technical challenges, students can face many personal challenges. In the next section, we’ll look at a few common challenges software developers talk about online; you can make your students aware of and provide practical strategies for coping with them.

Personal Challenges

In the professional world, IT personnel can face many personal difficulties that impact their productivity or burden them with additional stress. It’s important to know the difference between an issue for which you can provide coaching and those you should refer to a professional counselor. Here we’ll cover a few common challenges that even professional coders experience and some practical coping mechanisms they use to stay productive. Coaching coders to recognize personal challenges so they can stay on task will benefit them greatly in their professional lives.

Difficulty Staying Focused

For the younger generations, there is a deleterious myth of the digital native in education. The idea is that because students grew up with technology, they’re inherently more proficient with it than older generations and better at using computing systems for productivity and learning. One dimension of this stereotype is that digital natives are expert multitaskers: they can text, chat, listen to music, and play video games simultaneously. But research shows that everyone, even digital natives, are more error prone and less efficient when they try to multitask. Multitasking is harmful to learning.

This is especially true in programming. Coding is like reading or studying. It requires deep focus. You can’t code and watch a video at the same time. You can’t code and check your email every few minutes. Doing so breaks your train of thought, and it takes time to rebuild in your mind the complex system you are coding.

That said, it’s important to recognize how hard it is to stay focused with so much easy entertainment at our fingertips. It’s hard to power through debugging a complex function when we’re just a few clicks away from chatting on social media, streaming videos, and playing online games. It’s easy to tumble down a rabbit hole of distractions only to later climb out and realize how much time we’ve wasted.

Students need a metacognitive awareness of how they’re spending their time and attention. They need to be mindful of their distractions and focus. If they recognize how they’re being distracted, they can implement coping mechanisms to regain their attention.

One popular strategy for productivity is the Pomodoro Technique, where you set a timer on your desk and commit to focus on a specific task in 25-minute sprints. If you think of other tasks or items you need to follow up on during the sprint, you jot them down on a piece of paper and refocus on the main task at hand. After each sprint, you take a five-minute break, check email, access social media, or read an online article. Every four sprints, you can take a 15- to 30-minute break.

The technique is highly effective in that it only demands focus for short sprints and offers the reward of a well-earned break at the end of each sprint. It’s also effective for the way it promotes flow: students might find themselves immersed in a coding task the same way they become immersed in a game or social media, losing track of time with their singular focus. The technique also gamifies focus as the students keep track of how many sprints they complete in a day and try to beat their records. Many phone apps with timers and sprint-logging features are available to help them use this technique.

Another option for improving focus is to install productivity software. Some of these programs allow you to configure how much time you can spend on specific sites per day or between certain times of day and block access to those sites when the time limit is up. Students might find it quite revealing to learn just how much time they spend on their distractions when they try to restrain their access to them. Along these lines, it’s also a best practice to have content-blocking software running on your school’s network to prevent students from accessing sites that are time wasters or otherwise inappropriate.

Complexity Challenges

Another common productivity challenge is analysis paralysis, where developers become so overwhelmed with a task or project’s complexity they don’t know where to start. As mentioned earlier, decomposing the project into a subset of easier-to-solve problems is the best way to start mitigating this challenge. But it’s important to realize when this overwhelming feeling of project complexity comes from the project scope.

As stated in the previous chapter, it’s essential to recognize and rein in student-led projects that are so ambitious the student might despair at the amount of work to which they’ve committed. In the creative world, the concept of idea debt is where the artist spends all their time envisioning an amazing finished product, perhaps an epic novel or film, but never commits to the effort of making it a reality. Similarly, in the professional world, there are times when an organization envisions a comprehensive, feature-rich software solution that meets every imaginable need but fails to build it due to the exorbitant cost and scope to create it. Projects can also fall prey to scope creep, where a solution starts out simple but becomes unmanageable as the organization dreams up more and more features to add to it.

One strategy for tackling idea debt and scope creep is to scale back the project to a bare minimum implementation or minimum viable product. Try to determine how the student can just get to a proof of concept. Let’s say the student wants to construct a 20-question game to guess a species to teach biological taxonomies. This is a potentially hefty task for a single person to configure from scratch with 8.7 million species in the world. As the student realizes this, they might become overwhelmed and despondent. Instead, have them start with just the domains and kingdoms. Once this smaller project is accomplished, they can better estimate the scope and effort required to expand the game into phylum, class, order, family, genus, and even species. By doing so, they achieve a short-term win, and the project can grow organically as the student iteratively expands the scope.

Analysis paralysis is like writer’s block, and just as the best cure for writer’s block is to write something, the cure for analysis paralysis is simply to start coding. Narrowing and simplifying the project scope can make it easier for the student to start coding. Once they start coding, the process starts to flow more easily as they begin tackling one small task after another.

Resource Challenges

Today, the computer is the encyclopedia set, cable TV, VCR, vinyl record collection, video game console, and every other media we once had to budget into our lives all rolled into one. Because of this easy access to so many digital resources, personal computers have great potential as social equalizers. Unfortunately, access to computers and high-speed internet connections is not evenly distributed. As a result, there are digital haves and have-nots in schools and communities around the world.

For your classroom, the strategies and exercises covered throughout this book are meant to involve students in computational thinking and coding at minimal financial cost. When teaching computer science concepts to young children, we don’t even need to use computers; instead, we can use games to teach them. When introducing coding, we don’t need to install new software on the school computers. Instead, we can use the tools built into the web browser and in online environments so students on any computer with access to the web can continue their projects at home or at the public library.

But when your students leave the classroom, their computer access is beyond your control. A student who can continue working on their software project after school on a home computer will have a significant advantage over a student who can’t. Be aware of the programming environments students can access at home and direct them to places like libraries that provide public access to the internet. If possible, extended access to computers at your school could provide a valuable resource for students to continue pursuing their programming passions. Equitable access to information technology is a moral issue that demands inventiveness and persistent advocacy to address.

Imposter Syndrome

Many professional programmers experience a persistent feeling that they lack the skills and expertise of their peers. Even after graduating college and spending years or decades coding, many see themselves as lacking sufficient technical skills and fear being revealed as a phony. This very common and natural way of thinking is known as imposter syndrome, and it can cause developers a lot of stress.

Many students can fall prey to this self-perception and feeling that they don’t belong in programming. Students with resource challenges might be more prone to these feelings of inadequacy if they see their peers who grew up with computers in the household exhibiting a natural familiarity with them. The concern for these students is that the increased feelings of stress that come with imposter syndrome could cause them to abandon computer science. This result is especially disturbing today because the field is seeking more engagement with underprivileged groups and the unique perspectives they bring to the field.

As the coach, your praise means a lot to your students. Make sure you find ways to encourage them and promote their self-confidence. Recognize that computer science is an intimidating subject and openly acknowledge that with your students. That’s why several coping mechanisms are explained in this chapter to address the many ways to handle this complexity.

Another coping mechanism is to recognize that our feelings of inadequacy likely stem from a rational humility. In psychology, a phenomenon known as the Dunning-Kruger Effect is where the more a person knows about a complex subject, the more they doubt their expertise on it. Conversely, the less a person knows about a subject, the more confident they feel talking about it. We should try to be like the self-questioning expert rather than the overly confident novice.

Chapter 3 covered the extensive complexity that took centuries of innovation to amass into our modern computers, so no one can hope to know it all. Approaching the subject of computer science with a humble awareness of this complexity should promote sensitivity and respect when interacting with our peers. Remember that we question ourselves when we know enough about a subject to know how much we don’t know.

So, instead of reacting to feelings of inadequacy, we coach students to cultivate a healthy sense of humility. It’s often better to coach students on beneficial mental habits instead of simply reacting to problems as they arise.

Cultivate Healthy Metacognition

Throughout this chapter, we’ve covered ways to respond when students encounter challenges. In this section, we’ll touch on two specific areas of metacognition (thinking about our thinking) you can coach them on that will improve how students respond to challenges.

Growth Mind-Set

A growing body of recent research is finding that teaching students the growth mind-set, that their brains are plastic and can grow stronger through hard work, improves their resilience. This contrasts with the fixed mind-set, the idea that some people are born smarter or that individual intellectual ability is ultimately limited. Depending on their mind-set, students can have very different responses to the challenges they face.

When students who have a fixed mind-set fail, they believe it’s because they’re innately flawed and lack the intelligence to overcome the obstacles they encounter. In contrast, students with a growth mind-set understand the scientific fact that intelligence is malleable and that they can grow smarter if they work harder. When these students fail, they recognize the failure as a learning opportunity. The fixed mind-set student responds to stress with fatalism, whereas the growth mind-set student responds to stress as a natural temporary challenge to work through.

A common metaphor for the growth mind-set is to think of the brain as a muscle that responds to stress by growing stronger. Just as anyone can grow stronger by lifting weights or run faster by jogging daily, we can get smarter through mental challenges. Making sure student minds are open to improvement means making them aware that intelligence and talent are fluid attributes we can enhance when we face and overcome our challenges. In this way, we strive to be smarter today than we were yesterday.

Along these same lines, there is evidence that students whose personal goal is to master the subject matter in computer science, as opposed to those who want to get better grades than their peers, will get better grades in a computer science class. Encouraging self-improvement and striving for mastery in understanding computer ­science concepts will increase students’ likelihood for success academically in addition to their self-improvement.

Resilience

Once your students understand that they’re capable of growth, you can begin coaching them to start growing. Growth requires tenacity to progressively overcome problems and challenges. As noted in Chapter 2, software development requires tenacity to work through the inevitable challenges we’ll face.

A draft report from the Department of Education Office of Educational Technology identifies “grit,” “academic tenacity,” “agency,” “academic perseverance,” and “persistence” as terms used by prominent scholars to describe the exertion of will to achieve goals and the tenacity to persist when facing adversity and setbacks. This stick-to-itiveness can be more important than cognitive factors for student academic performance. Being resilient can be more significant than being talented.

Research suggests that willpower is a limited resource that can be depleted in the short term. But it also suggests that willpower, like other mental attributes, works like a muscle that can grow through challenges to go longer and stronger. Coach your students on this fact to improve their perseverance. Remind them that if they’re feeling frustrated, it means they’re about to learn something.

A Sense of Wonder

In this chapter, we’ve reviewed many strategies to help students not lose hope when they face obstacles. One very important aspect for supporting your students is providing an enjoyable learning environment that cultivates a deep appreciation of the subject matter. Computer science has many awe-inspiring elements to it, and we can lose sight of the wonder when we’re down in the weeds solving problems.

Set the stage at the beginning of each class with a provoking question, impressive demonstration, or cutting-edge development in the field. Find ways to give your students “wow” moments. Take time to refresh your excitement for the subject and share your enthusiasm with students. Nothing promotes flow and tenacity better than cultivating a passion for programming.

Summary

This chapter covered many strategies and techniques for supporting your students through the various challenges they’ll inevitably encounter when coding and learning computer science. Most commonly, students will need help with technical issues. In these situations, you should set the expectation that they must first work on the problem independently before you guide them through the process of debugging code and helping them find answers online. Students should also participate in online forums, once again showing their work, to seek help and observe how their fellow programmers talk about code.

We also covered some of the personal challenges your students might face and practical strategies for coping with issues, such as problems focusing, tackling complexity, limited resources, and feelings of inadequacy. These are the same personal issues that afflict professional developers. So when coaching your students to cope with them, you’re prepping them for handling common workplace stresses.

Finally, we explored ways of thinking that you can proactively encourage in your students to respond to challenges in a healthy way. By reminding your students that they’re capable of growth through challenges, students will respond with more persistence to overcome the obstacles they encounter. As the educator, you should also be mindful to refresh your own love of computer science and communicate your appreciation of it to your students to increase their interest and engagement with the subject.

In the next chapter, we move from using techniques for supporting students individually to creating a supportive environment through community-building efforts you can lead in your school involving computer science. These exercises, projects, and programs will bring visibility to your program while simultaneously delivering important educational experiences and support services to your students.