During this past semester, I learned about active learning and how I could use it in the classroom. Oddly enough, I was already incorporating a lot of active learning in my classroom without even realizing it. In this article, I want to share one of my favorite active learning techniques which I jokingly named Democratic Synthesis.
Table of Contents
What Is Active Learning?
Before we dive into my technique, I should probably explain active learning. As the name suggest, active learning is any learning technique where students are engaged (i.e. any time the instructor isn’t lecturing).
Active learning techniques vary wildly. For example, asking students to briefly reflect on an activity or lesson would be enough to constitute active learning. Meanwhile, asking students to do something more involved like a gallery walk would also constitute active learning. The point of any active learning technique is to make sure students are engaged in the learning process.
Other common active learning strategies include:
- Quick Write: ask students to respond to a brief writing prompt
- Peer Instruction: ask students to respond to a multiple choice question, discuss their response with a friend, and choose a response again
- Jigsaw: ask students to break up into groups to learn about a topic, assign each student a subtopic to study, and ask students to regroup to share their new knowledge
In the following section, we’ll take a look at a common active learning technique known as Think-Pair-Share. Naturally, it forms the basis for my wild idea, Democratic Synthesis.
Think-Pair-Share (TPS) is an active learning technique which leverages student collaboration. As the name suggests, there are three parts to TPS:
- Think about the topic or question currently posed
- Pair up with a student
- Share thoughts
For example, you might ask a class to think about the merits of Medicare for All, a current hot topic in the United States. This allows students to bring in their own knowledge of the subject before introducing any new information. After thinking time passes, you can ask students to discuss their thoughts with a peer.
In many cases, the “share” portion of the activity can be opened up to the class. Perhaps pairs could report out on what they discussed, or maybe this discussion sets up a more rigorous activity. All that really matters is that students get a chance to thank about their response before they discuss it with anyone in the class.
In my experience, TPS works well in a Computer Science class, but I prefer to follow other active learning techniques like Peer Instruction (and Democratic Synthesis). That way, you can introduce a problem that students can solve together—rather than speculate. That said, it might be fun to use TPS in a more design oriented course like game development.
What Is Democratic Synthesis?
Democratic Synthesis, as the fictional name implies, is a teaching technique where students come up with an answer to a problem as a class. In particular, it takes Think-Pair-Share to the next level.
First, we introduce a problem to the students. For a few minutes, students will try to solve the problem on their own. When they come up with a solution, we’ll ask them to submit it to an online discussion tool like TopHat. Then, they’ll pair up and discuss their thoughts.
Once all the solutions are posted and the students have had a chance to discuss them, we ask the students to vote for their favorite solution. In other words, which solution do they think best solves the problem.
Once a solution rises to the top, we have a couple options. We can either tackle the “best” solution as a class and determine if it’s valid, or we can leave that task to another round of Think-Pair-Share.
In either case, we’ll want to arrive at a correct solution. Usually, that means finding errors in the “best” solution and modifying them until the solution works. This iterative process allows students to make mistakes and learn from them in a safe environment.
Democratic Synthesis in Action
At this point, I figured I’d share the exact activity I did with my class using Democratic Synthesis. Then, I’ll talk about how that activity could be modified depending on your needs.
Step 1: State the Problem
For this lecture, I was covering recursion. At this point in the semester, the students were already quite comfortable with recursion conceptually, but they didn’t know exactly how to write their own recursive functions. As a result, I figured I’d ask them to tackle a challenging example as a class.
To kick off this activity, I asked the students to write me a recursive power function. Of course, there were some challenges weaved in. For example, the function didn’t have a return type. Instead, they had to propagate the results onto a reference type parameter (i.e. NaturalNumber).
Step 2: Accept Individual Solutions
As students were working out their solutions, I asked them to submit their results to a discussion board on TopHat which I kept open at the front of the class. In other words, students could see solutions begin to roll in.
For this portion of the activity, I didn’t set a time limit. Honestly, I wasn’t sure how long it would take them to come up with a solution, so I patiently monitored them throughout the process. As students began veering off-topic, I moved onto the next step.
Step 3: Discuss Solutions in Pairs
Once enough solutions had been submitted, I asked the students to discuss their solutions with each other. Here, the goal was to get students to compare two solutions to see what they could learn:
- Was their solution correct? Could they prove it?
- How did their partner’s solution compare? Was it faster/slower?
- Did their partner try to solve the problem the same way? Is there more than one way to solve it?
Again, the discussions weren’t prompted in any way. I just asked students to get with a partner and share what they came up with. I’m not sure if prompting them with the questions above would be helpful.
Likewise, I didn’t time limit this portion of the activity either. However, it may be a good idea if time is a concern.
Step 4: Democratically Elect the “Best” Solution
After some discussion, I gave students the opportunity to elect the best solution in the class. In TopHat, this was as easy as telling students to “like” their favorite response. Then, I was able to sort the responses by “likes,” so we could crown a victor.
In my experience, students often pick an incorrect answer. For whatever reason, an incorrect solution will begin to get votes, and other students will see that. As a result, they will vote it up as well. Before too long, we’ll have a unanimous incorrect answer.
Step 5: Debrief
Now, this is my favorite part of the activity. In all this buildup, students will feel like they’ve really created something. As a result, we get to have fruitful discussions about the results.
When I first did this activity, my students selected an incorrect answer. At that point, I took the opportunity to go through the process of “proving” its correctness. For example, I tested a base case—it failed. Then, I asked students to share a fix. After some deliberation, we were able to adjust our code to handle the base case.
Again, I began the testing process. First, I tested the base case. Then, I tested the next smallest subproblem. After a few iterations, the students were confident that the improved solution worked.
To finish off the activity, I asked the students if there was anything they would change or do differently. Since everyone was satisfied, we stopped the activity.
Oddly enough, I did this activity again later. However, instead of testing the code myself, I asked my students to follow the same process I did in a round of TPS/Jigsaw. In other words, I picked the top five answers and broke the class up into five small groups. Then, I asked the students to test their group’s solution before discussing their findings. Ultimately, I asked each group to report out whether or not their solution worked and how they would fix it if it didn’t.
Observations and Caveats
After performing this activity twice, I felt like it was a huge hit. For one, students really enjoyed working through a problem like this with some structure. At no point were students overwhelmed, and failure was normalized. In other words, mistakes felt like an opportunity to learn rather than a punishment.
That said, there were definitely some concerns with this activity. For instance, the democratic vote might select a correct answer. In that case, what do you do? On one hand, you could go through the proving process anyway. Alternatively, you could select the top five answers, so you have a better chance of finding a solution that needs some work.
In addition, it’s important that students get a chance to solve the problem alone. Much like TPS, the thinking part is critical to ensuring that every student has something to bring to the table.
Finally, coming up with a good question is critical. Personally, I like to pick a question that is just out of reach for the students at their current ability level. In other words, think about what your students know and what you’d like them to learn by the end of the class. Then, work toward that goal organically with Democratic Synthesis.
Overall, I’m quite pleased with this activity, and I think other teachers might find value in it. I’m not sure how it would work outside of a Computer Science setting, but I’m sure it could be adapted just fine.
And with that, there’s nothing left to chat about. If you liked this activity, and you think you might try it in your classroom, let me know! I’d like to hear how it goes. Otherwise, how might you change or adapt this activity to your own needs?
In the meantime, stick around and check out some of my other teaching related articles:
- How to Improve Coding Comprehension Using Peer Instruction
- Looking Back on My First Year of Teaching
- How to Teach Arrays in Computer Science
In addition, if you want to see more articles like these, hop on my mailing list or support me on Patreon. Likewise, I occasionally generate teaching resources which you can find in on Patreon as well. Finally, help me grow my YouTube channel by becoming a subscriber. Otherwise, thanks for stopping by!
Recently, I was giving a lecture about Java's "common" methods (i.e., all of the methods of Object), and I had epiphany about how Java only has toString() while Python has str() and repr(). So, it...
Magic numbers are numerical constants that have no clear meaning in the code and therefore make code harder to read. Anything that makes code harder to read is something we can use to obfuscate our...