Moses' Blog

Introduction to Interactive Learning in Programming

Introduction

Programming, a cornerstone of computer science, equips individuals with the ability to solve complex problems through computational thinking—a skill defined as systematically breaking down challenges into algorithmic solutions (Wing, 2006). Far beyond writing code, programming fosters innovation across industries by streamlining processes, automating tasks, and creating scalable systems. For example, platforms like DoorDash revolutionized food delivery by replacing fragmented, manual coordination with real-time logistics algorithms, boosting efficiency for businesses and customers alike. Such innovations underscore programming’s societal impact, as it bridges gaps between ideas and executable solutions.

A common misconception is that programming is limited to “tech” fields. In reality, it drives advancements in healthcare (e.g., diagnostic algorithms), education (e.g., adaptive learning platforms), and environmental science (e.g., climate modeling) Naur (1985). Another misunderstanding is that programming requires innate mathematical genius; however, it prioritizes logical reasoning and iterative problem-solving over advanced math.

This discipline is central to academic majors like computer science and software engineering, where students learn to design systems using languages like Python or Java. Research emphasizes that programming literacy enhances cognitive flexibility, enabling learners to adapt to evolving technological demands (Wing, 2006). The text exemplifies a constructivist learning approach by emphasizing active knowledge construction through real-world problem-solving and experiential learning.

Course Outline

This module provides an introduction to programming, emphasizing core concepts such as computation, coding syntax, and problem-solving through programming. The course is structured as follows:

1. Introduction to Programming
  – Understanding the importance of computation and programming
  – Real-world applications of programming
  – Overview of programming languages

2. Fundamental Programming Concepts
  – Variables and data types
  – Functions and their significance
  – Control structures (loops and conditionals)

3. Hands-on Coding Exercises
  – Writing basic Python programs
  – Running code and debugging errors
  – Interactive problem-solving

4. Assessments and Evaluations
  – Multiple-choice quizzes to reinforce learning
  – Algorithm design and problem-solving exercises
  – Final feedback and improvement suggestions

Target Audience

This module is designed for high school students with little to no prior knowledge of programming. It introduces fundamental programming concepts in an accessible and engaging manner, ensuring that students can grasp the basics before progressing to more advanced topics.

Inclusive Learning

Various learning styles are implemented to support learners who may face hardships with learning concepts. Visual aids such as diagrams and flowcharts to make it easier for learners to digest concepts. Lectures and discussions can also be incorporated to explain information. For Kinesthetic learners, who learn best through physical movements, hands on activities and coding exercises can be provided to engage them. Our lesson plan ensures that no additional software needs to be installed, allowing it to be more accessible to every learner.

Learning objectives

By the end of this course, learners will:

1. Describe the necessity of computation and programming languages by addressing: “Why are algorithms and syntax critical for translating human ideas into digital solutions?”

2. Identify programming’s real-world impact through: “How does code power innovations in unexpected fields like agriculture or journalism?”

3. Explain computation’s universal utility by exploring: “What makes computational thinking a foundational skill for both technical and everyday problem-solving?”

4. Write basic programs (e.g., loops, variables) while reflecting: “How does debugging a ‘Hello World’ error teach precision and persistence?”

5. Apply programming logic to non-technical careers by asking: “In what ways could automating repetitive tasks reshape your current work or hobbies?”

Starting the lecture

Programming is the art of transforming everyday English language that describes procedures into something readable by a computer; at its core, it’s a manner of transforming data. Turning easily describable processes in English into code can often be challenging, it requires a level of precision we may not be used to and may require a different way of framing the problem. To understand this concept further please watch the following video. (What is Coding?)

A fundamental concept in programming is the variable, a placeholder that allows us to perform procedures on some kind of “unknown.” To illustrate this, consider the rule reminiscent of something you may have seen in school: we describe a rule “add_one” as follows, for some unknown x, add_one(x) = x + 1, so no matter what x is, add_one will add one to it 

Ex. 

• add_one(x) = x + 1
• add_one(5) equals 5 + 1 = 6

Such rules are often called functions, similar to those you may have encountered in math class, and in programming, functions are often named using English words just as variables are. This simple notion has produced incredibly powerful tools in many areas of human inquiry, with the concept of variables dating back to 1500 BC and functions emerging in the 17th century. 

1. Variables – Storing Information

Consider a variable as a container in which we store data. Imagine it as a box with a label that you may use to store and retrieve information as needed. Programmers may effectively manage and alter data with the help of variables. Python assigns a variable’s type automatically based on its value, so you don’t need to explicitly define it.

2. Functions – Reusable Instructions

A function is a reusable block of code designed to perform a specific task. Programmers can define a process once and invoke it as needed thanks to functions, which eliminate the need to write the same set of instructions repeatedly. Code is more readable and effective when it is organised using functions. Functions have the ability to take parameters as inputs and return outputs. Programmers can write code that is clear, effective, and reusable with the aid of functions.

What do you think the output of this code will be?

3. Loops – Repeating Tasks

Loops allow us to repeat tasks without writing the same code multiple times. Loops assist in performing a repetitive task without having to manually input each time. In this instance It allows us to print numbers from one to 1-6.

4. Conditional Statements – Making Decisions

Conditional statements allow programs to make decisions based on given conditions. It evaluates whether a condition is true or false and executes different code accordingly. This is useful in scenarios where a program needs to take different actions depending on the input or situation. Python provides if, elif, and else statements to handle conditions.

Interactive Learning

To further understand these concepts and to develop your programming and logical skills to practice through hands-on exercises. The following exercises reinforce the concept taught in the lecture. As you move forward, you will be able to write a simple code which you can run in your browser.

(https://www.w3schools.com/python/python_syntax.asp)

Pair up with peers if you can and try solving each exercise to develop your programming knowledge and skills.

Interactive Assessment Plan

Quiz 1: Introduction to Python

​​Python Fundamentals 

Objective: This quiz is to assess and reinforce learners’ understanding of Python syntax, variables, data types, and operators.

​Format: 10 multiple-choice questions.

Quiz 2: Python Programming Constructs

Objective: This quiz aims to evaluate comprehension of loops, conditional statements, and user input handling.

Format: 10 multiple-choice questions.

Assessment 3:  Average Calculator Algorithm

Average Calculator Algorithm
Objective: Learners will design an algorithm that takes 5 different numbers as input, calculates their sum, and computes the average. The program will keep accepting inputs until 5 numbers have been inputted. The algorithm will be showcased in a flowchart and use lucidchart.com to create it.

Learners should use the following blocks to make their flowchart:

Once the learners have finished creating their flowchart, they can compare it with the correct solution here:

Feedback and Course Evaluation

To continuously improve this course we have created a structured feedback form using google forms where we can evaluate the effectiveness of the course. It will provide valuable insights from students about their learning experience, helping us identify strengths and areas for improvement. By collecting and analyzing student responses, we can refine their teaching strategies and enhance the overall learning experience.

References 

Indently. (2021, May 26) Learn Python in Less than 10 minutes for Beginners (Fast & Easy) [Video]. Youtube. https://www.youtube.com/watch?v=fWjsdhR3z3c 

Naur, P. (1985). Programming as theory building. Microprocessing and Microprogramming, 15(5), 253–261. https://doi.org/10.1016/0165-6074(85)90032-8

TeXplaiNIT. (2015, November 15). What is Coding? [Video]. Youtube. https://www.youtube.com/watch?v=N7ZmPYaXoic  

W3Schools.com. (n.d.). https://www.w3schools.com/python/python_syntax.asp

Wing, J. M. (2006). Computational thinking. Communications of the ACM, 49(3), 33–35. https://doi.org/10.1145/1118178.1118215

https://en.wikipedia.org/wiki/Variable_(mathematics)

https://en.wikipedia.org/wiki/Function_(mathematics)

Blog #1

Commenting on Marc Yeo’s post (link): Very interesting story about your upbringing Marc, and I agree it unfortunate that the vast majority of students have to subscribe to the school system that is rigid and could probably be more productive. The problem still remains how could this be changed though and how practical would executing it be. The fact of the matter is that those who grow up in more nurturing environments are more likely to be successful in whatever they choose to pursue and I hope our goal is to bring this perspective to our own kids one way (if one chooses to have kids).

Blog #2

Commenting on Taralyn’s post (link):

Love how you tied cooperative learning to your group’s work Taralyn. Using the jigsaw method to become experts totally mirrors real classroom collaboration. You nailed why it’s so powerful for differentiated learning: letting students lean on each other’s strengths while building empathy and inclusion. The mix of theory (like positive interdependence) with practical examples (visual/auditory tasks) makes it feel actionable, not just abstract and seems like it can be incorporated into a classes curriculum.

Blog #3

Commenting on Tianya’s post (link):

I like your focus on intentional design for inclusivity Tianya, and how it shines through the mix of adaptable formats and learner autonomy. Letting people choose written, visual, or discussion-based engagement respects their comfort zones, especially with a topic as personal as mental health. The asynchronous structure paired with accessibility tools removes barriers for those juggling schedules or needing tech support. You create safe spaces for both introverted and collaborative learners to contribute meaningfully. Prioritizing choice in expression (writing vs. dialogue) avoids a one-size-fits-all trap, which I think is a good choice when discussing sensitive issues.

Blog #4

Commenting on Conrad’s post (link):

Hey Conrad, I like how your design thoughtfully layers reflection, research, and collaboration to combat food misinformation. I like how Siegel’s video primes students to question historical myths, then pivots to modern diet trends, bringing together both the past and present in a way that grounds critical thinking in real-world relevance. The post-video activity is smartly structured: asking learners to trace a trend’s origins and confirm its credibility sharpens the inner skeptic. Pairing peer feedback with instructor evaluation creates accountability and community, ensuring students test their analyses against multiple perspectives further strengthening the evidence at hand. By closing with self-assessment questions, you reinforce metacognition, helping learners internalize how their media literacy has evolved a subtle but powerful way to cement long-term skills and very well thought out I would personally say.

In designing an interactive coding lesson around a beginner-focused instructional video, the emphasis lies on cultivating active engagement through multifaceted interactions. The video integrates designed interactivity by prompting learners to pause and practice concepts in real time, such as writing functions or troubleshooting errors, fostering foundational skills through hands-on application. While the video does not enforce direct responses, learners often self-direct their engagement by taking notes, experimenting in coding environments, or reflecting on prior knowledge—actions that strengthen learner-content interaction. Following the video, a structured activity challenges students to create a basic program, like a calculator, using online platforms to submit their work. This nurtures logical reasoning and problem-solving abilities, while collaborative digital tools facilitate peer sharing and idea exchange, embedding learner-learner interaction into the process. Feedback is optimized through automated assessments for foundational checks and peer evaluations guided by clear criteria, supplemented by instructor guidance via comments or live discussions. This layered approach ensures timely, scalable support while nurturing a collaborative learning community.

To prioritize inclusivity, the design incorporates accessible features such as closed captions, text-based summaries, and adaptable submission formats (e.g., pseudocode for learners without specialized tools). Choice-driven activities—like debugging tasks or open-ended projects—accommodate diverse skill levels and learning preferences, aligning with universal design principles. By emphasizing platform-neutral collaboration, the model underscores the importance of peer interaction in technical education, mirroring broader pedagogical strategies. Balancing automated feedback, peer engagement, and accessible design reduces instructor workload without compromising rigor, creating a scalable framework suitable for both intimate and large-scale learning environments. This approach aligns with models prioritizing interaction and learner agency, fostering an inclusive, dynamic educational experience that adapts to varied contexts and needs.

Designing an interactive learning resource for coding with inclusion at its core means embracing Universal Design for Learning (UDL) principles. To meet diverse needs, the resource will offer multiple means of representation, such as video tutorials with captions, visual flowcharts for complex logic, and text-based guides with adjustable font sizes. This ensures learners with varying preferences—auditory, visual, or textual—can access content effectively. Drawing from the GPS metaphor, learners can choose pathways: beginners might follow scaffolded exercises with step-by-step hints, while advanced students tackle open-ended projects. Tools like live coding platforms with real-time feedback and error highlighting mirror video game scaffolds, providing timely support without taking away autonomy. Additionally, inspired by the Google Docs transcript example from the reading, integrating collaborative coding environments allows learners to view peer solutions or use translation features, reducing barriers for multilingual students. Formative assessments will let learners demonstrate mastery through varied expressions—writing code, creating diagrams, or recording explanations—aligning with UDL’s emphasis on multiple means of action and expression. By embedding flexibility, the resource avoids the “one-size-fits-all” trap, ensuring neurodiverse learners, those with disabilities, or individuals balancing competing responsibilities can thrive.

To reduce barriers in the coding learning environment, the learning environment must proactively identify and dismantle barriers, much like replacing a solid fence with a transparent one. A key barrier in coding is cognitive overload. To address this, lessons will be chunked into micro-modules with self-paced progression, preventing frustration from prolonged focus. Technical barriers, such as inaccessible IDEs, are mitigated by offering cloud-based tools compatible with screen readers and keyboard navigation. Social-emotional hurdles—like fear of failure—are eased through low-stakes practice environments and peer mentorship channels, similar to the community spaces mentioned in the original text. Time constraints are addressed via flexible deadlines, acknowledging learners’ varied schedules. Additionally, eliminating jargon heavy instructions and providing glossaries with audio definitions supports those with language barriers. By applying UDL’s multiple means of engagement, the environment fosters motivation through gamified challenges and real-world projects, inviting learners to solve problems relevant to their interests. Just as curb cuts benefit more than wheelchair users, these adjustments—like clear documentation and modular content—enhance usability for all, reinforcing that inclusive design isn’t just equitable—it’s universally effective.

Constructivist pedagogy, with its emphasis on active knowledge construction and social learning, offers a robust framework for teaching coding. This post explores how constructivist principles align with coding education while addressing potential gaps and considerations. Constructivism asserts that learners build understanding through experience, reflection, and collaboration. 

Key characteristics include:

• Learner-centered design: Instruction adapts to students’ prior knowledge, interests, and cultural contexts.
• Active learning: Students engage in hands-on tasks, problem-solving, and experimentation.
• Social collaboration: Peer interaction and guided scaffolding deepen understanding.
• Critical inquiry: Learners analyze processes, reflect on mistakes, and revise strategies.

Coding education does well under constructivist principles when framed as a creative, iterative process. For instance:

• Learner-centered coding: Students tackle projects aligned with their passions, such as designing games or apps, fostering intrinsic motivation. Personalized pathways allow beginners to start with block-based coding while advanced learners use Python or JavaScript.
• Active learning through experimentation: Coding inherently involves trial and error. Debugging code on a program mirrors constructivist learning by doing, where mistakes become opportunities for growth. Project-based assignments, like building a website, require students to apply concepts in real life contexts.
• Critical inquiry and metacognition: Reflecting on code results or debating algorithmic choices helps analytical skills. Students learn to question assumptions, such as why one loop structure is more optimal than another.

Despite synergies, misapplications of technology or pedagogy can hinder alignment:

• Rote memorization of coding syntax without contextual projects contradicts active learning.
• Isolated learning environments: Solo coding exercises without peer interaction neglect social constructivism’s collaborative ethos.
• Access barriers: Inequitable access to devices or high-speed internet excludes marginalized learners from participatory coding experiences.
• Automated grading tools: Systems that prioritize “correctness” over creative problem-solving may stifle experimentation.

Constructivist pedagogy and coding education are highly compatible when coding is taught as a dynamic, socially embedded practice. Educators should prioritize project-based learning, collaboration, and reflective practices while advocating for easy accessibility to tools. Technology should act as a mindtool for critical thinking – principles that resonate deeply with teaching coding from a constructivist perspective. By framing coding as a process of exploration and co-creation, educators can encourage learners to become adaptable, innovative problem-solvers.