Teaching Programming with Minecraft Education: A Reflection

Introduction

Integrating innovative tools to enhance learning is essential in the dynamic landscape of computer science education. This term, I embarked on a collaborative journey to weave Minecraft Education into a Programming 11/12 course. Our objective was to enliven the curriculum by presenting programming concepts in a more engaging and interactive manner. This reflection delves into our experiences, with a particular focus on the concept of functions.

Lesson Overview

Our lesson was carefully prepared to guide students through the fundamentals of functions in programming via the Minecraft Education platform. This approach aimed to convert abstract concepts into concrete, relatable experiences, thus making learning both enjoyable and impactful.

The session began with a simple introduction to functions in Minecraft Education using MakeCode, drawing parallels with real-life scenarios to demystify these concepts. The goal was to underscore the significance of reusing code efficiently. For instance, we showcased a function that could construct various parts of a structure, such as walls, roofs, and fences. This hands-on demonstration helped students visualize the workings of functions, deepening their comprehension.

Subsequently, we organized the students into small teams for a series of Minecraft challenges. Each group applied their newfound knowledge to construct farm elements using coded functions. Encouraging students to build barns, animal enclosures, and residential structures, this immersive experience was crucial in reinforcing the lessons imparted and empowering students to explore coding within the game environment. While the MakeCode IDE is freely available online at https://minecraft.makecode.com/,  it is important to note that witnessing the code’s execution within Minecraft Education itself requires a paid subscription for each student (which we lacked for this iteration).

Following the building activities, groups presented their projects, explained their code, and engaged in Q&A sessions. This exercise culminated in the creation of a complete farm ecosystem (with a small amount of manual intervention), facilitating peer learning and evaluating their understanding of the lesson.

The lesson wrapped up with a debriefing segment, which focused the role of functions in streamlining complex coding tasks. We also distributed surveys to gauge the students’ experiences with the lesson.

Reflections and Learnings

Reflecting on the teaching process, I’ve recognized the crucial need for thorough preparation ahead of each class. Although the lesson itself was effective, there are areas where we could have utilized our time more judiciously.

Time Management:

Our planning meetings often veered towards administrative topics, detracting from the core lesson content. This experience has ingrained in me the importance of arriving at meetings well-prepared and with preliminary research completed, to maximize our collaborative efforts.

Technical Challenges:

Establishing a connection to the same Minecraft world across various platforms, such as PC and Mac, presented significant hurdles. This impacted our preparations and underscored the necessity for preemptive compatibility checks for future sessions. The tightly controlled environment of Minecraft Education by Microsoft impeded remote learning, suggesting that Minecraft Education is best suited to in-lab settings. Remote functionality was unreliable, as indicated by non-descriptive connection error messages like “timed out,” and support from Microsoft was less than helpful. The trial version of the software, supposedly available to schools with Microsoft logins, also failed to work, potentially necessitating IT intervention.

Student Engagement:

The lesson garnered positive feedback and high engagement levels, with the practical application of programming concepts within a familiar gaming environment being a key factor in its success. Nonetheless, some students noted that the inability to run the code hindered the debugging process. Ensuring every student has access to the necessary software and hardware will be a priority for future lessons.

The Power of Interactive Learning:

A major insight from this endeavour is the profound impact of interactive learning tools such as Minecraft in teaching intricate subjects like programming. Students were more engaged and assimilated the concept of functions more thoroughly compared to conventional teaching methods.

Conclusion

Incorporating Minecraft into our programming curriculum has been enlightening for students and educators. It has accentuated the significance of preparation, flexibility, and the assurance of technical compatibility to facilitate a seamless learning experience. The positive student feedback and evident boost in engagement and comprehension underscore our conviction in the power of interactive learning tools. As we progress, we are determined to refine our methods, confront the technical obstacles, and seek inventive strategies to render education more captivating and effective.

The Role of ChatGPT in Introductory Programming Courses

Introduction

Programming education is on the cusp of a major transformation with the emergence of large language models (LLMs) like ChatGPT. These AI systems have demonstrated impressive capabilities in generating, explaining, and summarizing code, leading to proposals for their integration into coding courses. Aligning with ISTE Standard 4.1e for coaches, which urges the “connection of leaders, educators, and various experts to maximize technology’s potential for learning,” this post examines how ChatGPT and similar tools can be effectively integrated into introductory programming classes. It covers the benefits of AI tutors, insights from educators on their use, and current best practices and trends for deployment in the classroom.

The Current State of AI in Computer Science Education

The current integration of AI in computer science education is showing promising results. ChatGPT excels in providing personalized and patient explanations of programming concepts, offering code examples and solutions tailored to students’ individual needs. Its interactive conversational interface encourages students to engage in a dialogue, solidifying their understanding through active participation and feedback. Students can present coding issues in simple terms and receive a comprehensive, step-by-step explanation from ChatGPT, clarifying fundamental principles throughout the process.

Such dynamic assistance clarifies misunderstandings more effectively than static textbooks or videos. ChatGPT’s round-the-clock availability as an AI tutor offers crucial support, bridging gaps when human instructors are unavailable. According to research by Kazemitabaar et al. (2023), using LLMs like ChatGPT can bolster students’ abilities to design algorithms and write code, reducing the stress often accompanying these tasks. The study also noted increased enthusiasm for learning programming among many students after exposure to LLM-based instruction.

Pros of Incorporating ChatGPT into the Classroom

The rapid advancement of AI systems such as ChatGPT offers many opportunities and poses some challenges in computing education. ChatGPT’s conversational interface and its capability to provide personalized content make it an exceptional asset for adaptive learning in AI-assisted teaching. Biswas (2023) identifies multiple applications for LLMs in educational settings, including their role in creating practice problems and code examples that enhance teaching. Furthermore, ChatGPT can anticipate and provide relevant code snippets tailored to the programming task and user preferences, accelerating development processes. It can also fill in gaps in code by analyzing the existing framework and project parameters. Additionally, LLM-facilitated platforms help with explanations, documentation, and resource location for troubleshooting and diagnosing issues from error messages, streamlining debugging and reducing the time spent on minor yet frustrating problems.

Cons of Incorporating ChatGPT in Education

Despite the advantages of ChatGPT, there is concern that its proficiency in solving basic programming tasks may lead to student overreliance on its code generation, potentially diminishing actual learning, as evidenced by Finnie-Ansley et al. (2022) and Kazemitabaar et al. (2023). Finnie-Ansley’s research indicates that, while LLMs can perform at a high level (scoring in the top quartile on CS1 exams), they are not without significant error rates. Moreover, the benefits attributed to ChatGPT, such as code completion, syntax correction, and debugging assistance, overlap with features already available in modern Integrated Development Environments (IDEs).

Concerns extend to ChatGPT facilitating ‘AI-assisted cheating,’ which threatens academic integrity and assessment validity (Finnie-Ansley et al., 2022). To counteract this, researchers suggest crafting more innovative, conceptual assignments beyond simple coding tasks (Finnie-Ansley et al., 2022; Kazemitabaar et al., 2023). Educators in computing must adopt careful strategies for integrating ChatGPT, using it as a scaffolded instructional tool rather than a crutch for solving exam problems, to maintain a focus on in-depth learning.

Instructors’ Perspectives and Experiences

In a study conducted in 2023, Lau and Guo interviewed 20 introductory programming instructors from nine countries regarding their adaptation strategies for LLMs like ChatGPT and GitHub Copilot. In the near term, most instructors intend to limit the use of LLMs to curb cheating on assignments, which they view as a potential detriment to learning. Their strategies range from emphasizing in-person examinations to scrutinizing code submissions for patterns indicative of LLM use and outright prohibiting certain tools. Some, however, are keen to explore the capabilities of ChatGPT, proposing its cautious application, such as demonstrating its limitations to students by having them assess its output against test cases.

In contemplating the future, these educators showed greater willingness to integrate LLMs as teaching tools, recognizing their congruence with real-world job skills, their potential to enhance accessibility, and their use in facilitating more innovative forms of coursework. For example, they discussed transitioning from having students write original code to evaluating and improving upon code produced by LLMs—a few envisioned LLMs functioning as custom-tailored teaching aids for individual learners.

Pedagogical Strategies and Opportunities for Future Research

Designing problems that demand a deep understanding of concepts rather than the execution of routine coding tasks, which LLMs easily handle, is a vital pedagogical shift proposed by Finnie-Ansley et al. (2022) and Kazemitabaar et al. (2023). Utilizing ChatGPT as an interactive educational tool to complement teaching—instead of as a mere solution provider—may strike an optimal balance between its advantages and potential drawbacks. Given the pace at which AI technology is being adopted in education, there’s a pressing need for further empirical research to identify the most effective ways to integrate these tools and assess their impact on student learning.

References

Biswas, S. (2023). Role of ChatGPT in Computer Programming. Mesopotamian Journal of Computer Science, 8–16. https://doi.org/10.58496/mjcsc/2023/002

Kazemitabaar, M., Chow, J., Carl, M., Ericson, B. J., Weintrop, D., & Grossman, T. (2023). Studying the effect of AI Code Generators on Supporting Novice Learners in Introductory Programming. https://doi.org/10.1145/3544548.3580919

Finnie-Ansley, J., Denny, P., Becker, B. A., Luxton-Reilly, A., & Prather, J. (2022). The Robots Are Coming: Exploring the Implications of OpenAI Codex on Introductory Programming. Australasian Computing Education Conference. https://doi.org/10.1145/3511861.3511863

Lau, S., & Guo, P. (2023, August). From” Ban it till we understand it” to” Resistance is futile”: How university programming instructors plan to adapt as more students use AI code generation and explanation tools such as ChatGPT and GitHub Copilot. In Proceedings of the 2023 ACM Conference on International Computing Education Research-Volume 1 (pp. 106-121). https://doi.org/10.1145/3568813.3600138

Measuring Student Contribution in a Software Engineering Team

Introduction

In software engineering, there is very little consensus on how to measure an individual developer’s contribution. Although many measures have been proposed, their usefulness in the industry lacks validation, particularly from the perspectives of team leaders and managers (Lima et al., 2015). The lack of measurement also challenges educators (Gardner et al., 2003). This post will examine student developer contributions within the context of a software engineering project.

ISTE Standard 4.6 advocates for ed tech coaches to be data-driven decision-makers using qualitative and quantitative data to inform their decisions. Standard 4.6b states, “Support educators to interpret qualitative and quantitative data to inform their decisions and support individual student learning.” Techniques discussed in this article could be used to measure student engagement and fulfillment in a team project and give insight into where instruction can be altered in a software engineering course.

I will begin by examining the use of chat platforms like Discord to track individual student contributions. Next, I’ll discuss the role of peer evaluations in assessing team member input. Lastly, I’ll introduce repository mining techniques to quantify these contributions.

Live chat Activity

We’ll start with what I consider the least effective among the three metrics. In recent years, many modern developers have adopted Discord as a tool for real-time communication and collaboration in software engineering projects. Fundamentally, Discord channels serve as dedicated spaces for text, voice, and video communication. In educational contexts, these channels can be structured to reflect the various teams within a software project, facilitating organized, topic-specific discussions. Such channels can host various activities, from casual interactions and planning sessions to problem-solving discussions and code reviews, closely mirroring a real-world software development environment. Furthermore, Discord captures all these interactions, creating a comprehensive, searchable archive of every conversation and exchange.

Moreover, thanks to its bot-integration features, Discord is increasingly seen as an innovative tool for gauging student contributions in team-based projects. Analytical bots like Statbot offer detailed statistics on individual interactions on the platform, enabling the assessment of each student’s engagement. Chat histories also supply quantitative data on the quality of contributions in software engineering team projects.

However, while bots offer valuable quantitative and analytical insights, it’s important to complement this data with qualitative evaluations. Direct observations, feedback sessions, and individual discussions remain indispensable for grasping the subtleties of each student’s input. It’s also vital to address privacy concerns and uphold ethical standards in monitoring, ensuring clear guidelines and transparency from the instructor’s side.

Peer Evaluations

Gardner et al. (2003) conducted a study exploring the use of group member ratings to gauge relative contributions among students in a software engineering team project course. At the end of the project, students rate each team member’s contributions across four criteria using a five-point scale:

  • Attendance at team meetings.
  • Volunteering for and carrying out tasks.
  • Quality of work performed.
  • Effectiveness in communicating ideas.

The findings suggest that these anonymous peer ratings are reliable for ranking team members on their contributions. While students often rate themselves higher than their teammates, the relative contributions ranking remains consistent, which aligns with previous research (West, 2018, Ch.16).

This approach quantifies peer perceptions of engagement and effort. It motivates students to interact and collaborate and allows teams to self-manage contributions. However, limitations exist. Students may not accurately judge true contributions. Dominant personalities could influence ratings. Moreover, if grades hinge directly on these ratings, it might encourage score inflation.

Despite its limitations, peer ratings offer a systematic method to encourage and gauge participation in team projects. They represent the firsthand insights of teammates into individual efforts and team dynamics. Instructors should triangulate peer evaluations with other performance indicators to mitigate potential biases. When applied thoughtfully, group member ratings can be a scalable tool to enhance accountability and ensure equitable effort distribution within student engineering teams.

Using Git Repositories

While subjective peer evaluations are commonly used, analyzing data from git repositories provides an objective lens into individual contributions, revealing insights into aspects like collaboration patterns, subsystem ownership, and consistency of participation (Lima et al., 2015). Instructors can combine these repository-based metrics with subjective evaluations to assess student effort and engagement better.

A fundamental metric is examining each student’s number of commits over time, called code contribution (Lima et al., 2015). This helps reveal whether students contribute regularly throughout the project or make concentrated commits right before deadlines. Students with relatively few commits thinly spread across the weeks likely contributed minimally, while a student with a steady stream of commits each week demonstrates consistent engagement (Glassy, 2006).

Examining the content of commits also provides insights into contribution quality. The code complexity measure is also widely accepted as a good measure of contribution. The code complexity measure considers the complexity and difficulty of the sub-problem being solved. Complexity measures were proposed by McCabe in 1976 and are still widely used today to examine git repositories. The measures analyze code complexity before and after a team member has altered it. Low commit complexity suggests weaker contributions to the team’s software development processes.

A variation of the code complexity measure is the bug-related measures, which measure the contribution to bug introductions and bug-fixing. However, this measure has limitations because some bug fixes do not require writing code, mitigating the developer’s efforts (Lima et al., 2015). Also, advanced repository analysis can reveal collaboration patterns within student teams. Tools like FRASR and ProM introduced by Poncin et al. (2011) can extract event logs from student repository data (using FRASR) and subsequently analyze the development process (with ProM). This tool also incorporates developer roles and adherence to certain development models. 

Of course, reliance solely on git metrics has limitations. First, commits mainly represent coding contributions, overlooking other forms of participation like verbal collaboration and project leadership (Lima et al., 2015). Second, students can artificially inflate their repository activity metrics if they know the algorithm being used. Despite these drawbacks, analyzing git data provides valuable insights into individual participation on student software teams. Instructors should interpret repository metrics not as absolute contribution measures but as launching points for further investigation.

Conclusion

By balancing quantitative git data with qualitative peer evaluations, product assessments, and student interviews, instructors can obtain a more equitable evaluation of individuals. Nonetheless, there is a strong correlation between subject and objective measures of contribution to a project (Hundhausen et al., 2022). Software engineering courses require team projects, but assessing individual accountability remains vital. Combining subjective reviews and objective repository analysis helps reveal a more accurate picture of each student’s contributions and commitment.

References

Lima, J., Christoph Treude, Fernando Figueira Filho, & Kulesza, U. (2015). Assessing developer contribution with repository mining-based metrics. https://doi.org/10.1109/icsm.2015.7332509

Gardner, W. (2003). Assessing individual contributions to group software projects. In 8th Western Canadian Conference on Computing Education (WCCCE’03) (pp. 33-50).

Hundhausen, C. D., Conrad, P. T., Carter, A. S., & Adesope, O. (2022). Assessing individual contributions to software engineering projects: a replication study. Computer Science Education32(3), 335–354. https://doi.org/10.1080/08993408.2022.2071543

West, R. E. (2018). Foundations of Learning and Instructional Design Technology. https://doi.org/10.59668/3

Glassy, L. (2006). Using version control to observe student software development processes. Journal of Computing Sciences in Colleges21(3), 99–106.

McCabe, T. J. (1976). A Complexity Measure. IEEE Transactions on Software EngineeringSE-2(4), 308–320. https://doi.org/10.1109/tse.1976.233837

Poncin, W., Serebrenik, A., & Mark. (2011). Mining student capstone projects with FRASR and ProM. https://doi.org/10.1145/2048147.2048181

Teaching Computer Science with Minecraft

Introduction to Minecraft

Minecraft is currently one of the most popular games of 2023, boasting over 140 million monthly active users, according to searchlogistics.com. Despite this popularity, many players overlook that Minecraft offers an engaging and immersive environment for learning terminal commands, programming basics, computational thinking, and even artificial intelligence. ISTE standard 4.3a for coaches indicates that a successful coach should “Establish trusting and respectful coaching relationships that encourage educators to explore new instructional strategies.” So, in this blog post, I will delve into the educational benefits of Minecraft and explore the differences between the Java and Education editions.

While Minecraft is often regarded as merely a game, educators have recognized its potential as a valuable learning tool. At its core, Minecraft is built upon programming concepts. Players use blocks made of various materials to construct anything they can imagine, from simple houses to complex machines that require advanced knowledge of electronics, chemistry, and physics. This encourages computational thinking, creativity, and problem-solving as students work to bring their visions to life.

Concerning programming, Minecraft helps teach fundamental coding concepts, including commands, functions, variables, loops, and conditionals. Students can employ block-based coding or full-fledged programming languages such as Python and JavaScript to automate actions within the game. This hands-on approach to learning captivates students more effectively than traditional coding lessons, as Minecraft provides them with an imaginative space to immediately apply their newfound skills. Creating Minecraft modifications (mods) teaches students how to extend existing programs, a critical programming skill.

Minecraft Versions

Several versions of Minecraft are available for players to choose from, including Minecraft: Java Edition, Minecraft: Bedrock Edition, Minecraft: Education Edition, and Minecraft: Pocket Edition. However, for the specific purpose of our educational analysis, we will concentrate solely on the Java and Education editions. These two versions offer unique features and opportunities for learning that make them particularly relevant in an educational context.

Minecraft: Java Edition

The Java Edition is the original version of Minecraft developed in 2009 by Mojang Studios for Windows, macOS, and Linux, and maintains its popularity among long-time Minecraft players.

The Java Edition offers distinct advantages when teaching advanced computer science concepts due to its “mod-ability” and access to the source code of the game environment. The semi-open-source nature of the Java Edition allows for limitless customization through mods and plugins. Writing mods can illustrate a wide range of advanced programming concepts, including event handling, parallel programming, algorithms, data structures, debugging, and software design patterns. Developing mods not only imparts practical software development skills but also encourages students to show their creativity.

The Minecraft community has produced numerous mods that cater to various lesson plans. For instance, ComputerCraft introduces programmable turtle robots, while RedstonePlus enhances the game with advanced circuitry. The diversity of available mods supports a wide range of educational objectives, not only in CS but other disciplines.

Minecraft: Education/Bedrock Edition

Minecraft: Bedrock Edition was initially released in August 2011 and is particularly advantageous for classrooms with various devices. Bedrock Edition supports mobile devices such as iPads and Android tablets, which many schools already incorporate into their teaching environments. This enables students to start their Minecraft lessons on a classroom desktop computer during the day and seamlessly continue playing on their smartphones or game consoles at home.

However, Bedrock Edition offers less mod support and limited access to code customization. Minecraft Education Edition is a version of Bedrock specifically tailored for classroom use. According to Microsoft, it “typically runs about one full version behind the current Minecraft Bedrock production version” (FAQ: Game Features, 2023).

Advantages of Minecraft Education in the Classroom

One of the most significant advantages of Minecraft Education in a computer science course is its block-based CodeBuilder / MakeCode editor, similar to Scratch or Snap. This editor allows students to drag and drop commands to perform actions in the game. Younger students can learn coding logic and structure by creating houses, gardens, and machines using these visual blocks before transitioning to text-based programming languages like Python or JavaScript.

Another advantage of Education Edition is the teachers’ ability to implement special restrictions, such as limiting chat or preventing students from destroying blocks. These classroom controls create a safe environment for student exploration. Teachers can also switch to spectator mode to observe students and provide feedback; they also have the capability to build worlds and restrict access as needed. Here is a quick start guide for reference.

The Education Edition library offers hundreds of pre-made interactive worlds and lesson plans aligned with computer science curriculum standards (source: https://education.minecraft.net/en-us/resources/computer-science-subject-kit). Teachers can find lesson plans tailored to any grade level, making it much easier for educators to get started with Minecraft compared to building worlds from scratch.

According to research by Bile (2022), their study found that children aged 8 to 10 in a Minecraft education setting were able to solve abstract and complex scientific problems without prior prompting or theoretical knowledge. The game format also helped students retain knowledge better. Vostinar & Dobrota (2022) similarly found that in a primary school class, even though the majority of students had not programmed before in block or Python, they found the lesson enjoyable and easy. Furthermore, according to Nika Klimová et al. (2021), girls in grades 5-10 typically outperform boys in Minecraft education coding challenges, suggesting it may be a valuable tool for increasing diversity in computer science.

Disadvantages of Minecraft

As Vostinar & Dobrota (2022, p. 652) pointed out, there are significant disadvantages to using Minecraft in education. One such drawback is that Minecraft is not free and requires an additional cost per student, which, as mentioned in my previous post, raises ethical concerns about the practice of making students pay for educational software. Another disadvantage is that Minecraft may only appeal to a certain type of student, particularly those with a more creative inclination, potentially excluding students who do not have an affinity for the game.

Furthermore, teachers must become proficient in the game’s mechanics and capabilities to integrate it into the classroom effectively. Given the abundance of “cheats” in Minecraft, more experienced players may find trivial command-line solutions to problems if the teacher is unaware of their existence. Finally, as highlighted by Vostinar & Dobrota (2022), it’s essential to impose adequate constraints on the virtual world, especially when students collaborate, to prevent them from destroying the world with TNT blocks and other mining tools.

References:

Vostinar, P., & Dobrota, R. (2022). Minecraft as a Tool for Teaching Online Programming. 2022 45th Jubilee International Convention on Information, Communication and Electronic Technology (MIPRO). https://doi.org/10.23919/mipro55190.2022.9803384

Bile, A. (2022). Development of intellectual and scientific abilities through game-programming in Minecraft. Education and Information Technologies, 1–16. https://doi.org/10.1007/s10639-022-10894-z

Nika Klimová, Jakub Sajben, & Lovászová, G. (2021). Online Game-Based Learning through Minecraft: Education Edition Programming Contest. https://doi.org/10.1109/educon46332.2021.9453953

FAQ: Game Features. (2023, September 15). Minecraft Education. https://educommunity.minecraft.net/hc/en-us/articles/360047117692-FAQ-Game-Features

The Pros and Cons of Autograders in Programming Courses

Programming courses typically require assignments where students write code to fulfill specific specifications. In such courses, an autograder serves as an automated tool designed to assess student code submissions by conducting input and output tests. Autograders have been in existence since the inception of computer science as a field of study (Hollingsworth, 1960). More recently, with the increase of massive online programming courses hosting up to 500 students, autograders have gained popularity as an efficient means for grading programming assignments (Keuning et al., 2018). They are instrumental in student engagement (Iosup & Epema, 2014) and pivotal in providing students with constructive feedback (Keuning et al., 2018). However, like any educational technology, autograders come with their own set of advantages and disadvantages that warrant consideration. This post aims to explore the significant pros and cons of employing autograders for assessments in programming courses.

Several renowned proprietary programming autograders are currently available, including CodePost, CodeGrade, Codio, and Mimir. Each tool offers a wealth of academic programming resources, including built-in problems, user-friendly interfaces, flexible question setting, and code review capabilities. However, these companies impose a substantial annual fee on institutions, ranging from $20,000 to $100,000 CAD, for a standard school comprising 1000 students. Additionally, each student is required to pay a monthly fee between $10 and $50 CAD.

In my view, such pricing is excessive (and greedy) and contradicts the principles outlined in the computer science code of ethics, particularly when the software is intended to advance software development. As a result, many post-secondary institutions opt to develop and maintain autograders in-house, tailoring them to their specific preferences. This approach allows faculty to propose new features and enhancements, and students can also contribute suggestions for improvement.

Advantages of Autograders

One of the most compelling incentives for using an autograder is the significant time savings it offers instructors compared to manual grading. Studies indicate that autograders can assess assignments at least three to four times faster than human graders (Ihantola et al., 2010; Keuning et al., 2018). This substantial reduction in grading workload allows instructors to allocate more time to essential teaching tasks such as lesson planning, curriculum development, and providing student support and feedback. The time savings can be particularly substantial in large classes.

Autograders also benefit students by providing quicker feedback on their work. This is especially valuable in introductory programming classes, where receiving prompt results on smaller assignments can significantly enhance student learning and motivation (Keuning et al., 2018). Unlike human grading, which can take days or weeks, autograders can assess submissions within seconds or minutes and instantly inform students whether their code has passed or failed the test cases. This expedited feedback allows students to validate and refine their work much more rapidly than traditional grading methods permit.

A prevalent concern with human graders is the inconsistency in grading from one assignment to another, from one student to another, or even within a single assignment. Factors such as fatigue, emotional states, and biases can impact the quality of human grading, potentially leading to unfairness or errors. Autograders, by contrast, eliminate this subjectivity by applying uniform standards and tests to all submissions, ensuring consistent and equitable grading across the entire class, and thereby enhancing student satisfaction (Hagerer, 2021).

In courses that employ autograders, students quickly learn the necessity of writing code that meets all the autograder test cases to secure maximum assignment credit. While the efficacy of test-driven development (TDD) as a software testing methodology is debatable, this workflow provides students with experience in the TDD framework. Here, students continually run tests on their code to rectify errors and attain the desired functionality (Wang et al., 2011). Essentially, autograders compel students to consider testing as an integral part of coding, rather than merely striving to meet the minimal functional requirements.

Disadvantages of Autograders

A significant drawback of autograders, frequently cited in literature, is their inflexibility compared to human graders (Ihantola et al., 2010; Keuning et al., 2018; Wang et al., 2018). Autograders strictly apply identical test cases to all submissions without exception. Consequently, creative solutions that meet the assignment requirements but deviate from the expected implementation or output format are marked incorrect. Even a minor discrepancy such as a missing whitespace can be the difference between a pass and a fail. Unlike autograders, human graders can exercise judgment to accommodate alternative approaches.

Most autograders assess the functional correctness of student codes, evaluating output for given tests. However, programming courses also aim to instill good coding practices, such as readability, modularization, adherence to naming conventions, coherent design, and appropriate commenting, in students. Autograders do not adequately assess these crucial design and style aspects, leading students to neglect good design principles as long as their code passes the functionality tests.

Another concern is that while autograders are designed to offer students a structured means to advance their knowledge across multiple courses, achieving uniformity in their application across various courses is challenging, especially in larger institutions. Typically, post-secondary institutions employ autograders to maintain consistency across different courses, enabling students to track their progress effectively. However, in institutions where numerous faculty members teach diverse courses with varying requirements, achieving universal acceptance and use of autograders is complex. Faculty members may prefer different tools they are more comfortable with, and some might choose not to use autograders. This results in a lack of uniformity in tool usage from one course to another, creating a disjointed student experience.

Relying exclusively on autograders poses the risk of students learning to pass test cases without acquiring a deeper understanding of programming concepts and problem-solving skills. The emphasis on meeting the autograder’s criteria can lead students to adopt a procedural approach, focusing on achieving the correct output rather than understanding the underlying logic. Some might resort to a trial-and-error method, tweaking their program until it gains autograder approval. While this approach may secure the desired grades, it does not foster genuine understanding or long-term retention of knowledge. Baniassad et al. (2021) introduced a submission penalty at the University of British Columbia to discourage over-reliance on their in-house autograding tool. This adaptation exemplifies the flexibility of modifying tool requirements, a possibility uniquely available when the tool is developed in-house.

Finally, like any web-based software system, autograders can experience technical issues that lead to grading failures and student frustration. The UC Berkeley incident highlights the “single point of failure” risk where an autograder disruption blocks all grading capabilities. Unlike distributed human graders, a centralized automated grader represents a vulnerability to technical problems. Some may fail to meet deadlines through no fault of their own. Furthermore, if instructors refuse to make accommodations for autograder malfunctions, students can feel cheated and that the grading is unfairly disconnected from actual instruction. This speaks to larger concerns around over-reliance on algorithmic systems in education. Automated aids like autograders should not be seen as the sole means of assessment.

Conclusion

The existing body of research on autograders underscores that they are not a panacea for replacing human graders entirely. Instead, to optimize their advantages and mitigate their limitations, autograders are most effective when thoughtfully integrated into a course assessment strategy, complemented by manual grading where it is most beneficial. Below are some best practices for incorporating autograders effectively:

  • Employ autograders for basic functionality testing, while manually reviewing selected assignments for flexibility, creativity, and design.
  • Utilize autograders to assess the correctness of core logic, and rely on human graders to evaluate structure, style, and readability.
  • Complement autograder evaluations with human feedback on prevalent mistakes and areas requiring enhancement.
  • Impose penalties for excessive submissions to discourage over-reliance on the autograder.

Proper integration of autograders aligns with technology integration frameworks like SAMR, enhancing existing processes without entirely transforming the grading in programming courses. It also redefines the manner in which students engage with programming, introducing a more gamified approach. Like any educational technology, the value of autograders is derived from their strategic utilization within well-defined goals and contexts.

References

Hollingsworth, J. (1960). Automatic graders for programming classes. Communications of the ACM3(10), 528–529. https://doi.org/10.1145/367415.367422

Keuning, H., Jeuring, J., & Heeren, B. (2016). Towards a Systematic Review of Automated Feedback Generation for Programming Exercises. Proceedings of the 2016 ACM Conference on Innovation and Technology in Computer Science Education. https://doi.org/10.1145/2899415.2899422

Iosup, A., & Epema, D. (2014). An experience report on using gamification in technical higher education. Proceedings of the 45th ACM Technical Symposium on Computer Science Education – SIGCSE ’14. https://doi.org/10.1145/2538862.2538899

Ihantola, P., Ahoniemi, T., Karavirta, V., & Seppälä, O. (2010). Review of recent systems for automatic assessment of programming assignments. Proceedings of the 10th Koli Calling International Conference on Computing Education Research – Koli Calling ’10. https://doi.org/10.1145/1930464.1930480

Hagerer, G. (2021). An Analysis of Programming Course Evaluations Before and After the Introduction of an Autograder. (n.d.). Ieeexplore.ieee.org.

 Wang, T., Su, X., Ma, P., Wang, Y., & Wang, K. (2011). Ability-training-oriented automated assessment in introductory programming course. Computers & Education56(1), 220–226. https://doi.org/10.1016/j.compedu.2010.08.003

Baniassad, E., Zamprogno, L., Hall, B., & Holmes, R. (2021). STOP THE (AUTOGRADER) INSANITY: Regression Penalties to Deter Autograder Overreliance. Proceedings of the 52nd ACM Technical Symposium on Computer Science Education. https://doi.org/10.1145/3408877.3432430

Reflecting on a Study of Competitive Programming and Cultural Inclusion

Length of Study

The study is designed to take place over two academic terms, which provides adequate time to collect meaningful data. The inclusion of an initial summer term without competitive programming establishes a baseline for comparison. The second summer term incorporates competitive programming using standardized questions, allowing assessment of this pedagogical approach. The fall term offering adds the dimension of culturally relevant questions, enabling analysis of their impact. Extending the study over multiple terms enables more robust data collection and analysis.

Promoting Active and Engaged Learning

The core content is delivered through weekly lectures focused on programming concepts. The competitive programming contests complement the lectures by providing opportunities to practice applying concepts. Weekly competitive programming contests foster active learning in several key ways. Students must apply conceptual knowledge to solve concrete programming problems. This process reinforces their understanding and helps identify knowledge gaps. The contest format adds an engaging gamification element through scoring, feedback, and peer comparison. Using standardized questions initially assesses whether baseline content needs are being met.

Introducing culturally relevant questions aims to promote better integration of concepts by relating them to students’ cultural knowledge and experiences. Having students co-create contest questions in the fall term further activates learning. They must think critically to develop culturally relevant problems that integrate with the content. This approach promotes deeper engagement with the material and encourages collaboration with classmates, allowing students to take ownership of their learning.

Addressing Teachers’ Needs

The study aims to provide teachers with insight into using competitive programming and culturally relevant pedagogy. The data collected will help determine the effectiveness of these approaches in an international educational setting. Instructors will gain an understanding of how competitive programming engages students versus standardized practice problems. They will also see whether student-created culturally relevant questions increase participation and motivation. The study addresses teachers’ needs for effective and inclusive instructional strategies. They will gain practical knowledge from the comparative data on different contest designs.

Promoting Collaborative Participation

Collaboration is encouraged through the group development of culturally relevant contest questions. Students can brainstorm and build on each other’s ideas, which fosters teamwork. Producing questions from diverse cultural perspectives requires working together. Students are also given the choice of problem-solving in teams. Students can motivate each other and strategize in groups for the competitions. Their scores are tracked on a collective leaderboard which reinforces the collaborative element. The shift from individual to team contest creation necessitates and enables productive collaboration.

The multi-term study design, interactive contest format, customized problems, and collaborative elements demonstrate an interesting pedagogical approach that promotes engaged and inclusive learning. The results should provide valuable insights for computer science educators.

Leveraging GitHub Co-pilot to Enhance Programming Education

Overview

Introductory programming courses are the foundation for students to gain fundamental coding abilities and analytical thinking skills required for various fields. However, programming poses unique challenges for beginners, like struggling with syntax, grasping complex concepts and developing logical reasoning. As computer science education continues to evolve, AI-powered tools like GitHub Copilot are emerging that can augment programming instruction for novices.

This blog post explores how GitHub Copilot could be effectively integrated into introductory programming courses to enhance student outcomes. Relevant education literature is drawn upon to support the recommendations.

An Introduction to GitHub Copilot

GitHub Copilot is a relatively new AI pair programmer that suggests complete lines of code, functions, and entire code blocks based on comments and the code context. It is powered by Codex, a large deep-learning model trained on billions of lines of public code from GitHub repositories. Copilot employs natural language processing, neural code synthesis, and semantic code search to generate helpful code recommendations tailored to the programmer’s intent. Copilot is a Visual Studio Code extension that integrates into the coding workflow. At its core, it transforms a natural language problem statement into executable code. It aims to boost programmer productivity by reducing boilerplate code and suggesting subsequent lines. Here’s a quick demo:

Advantages of Using Copilot for Introductory Programming Education

Copilot has several characteristics that make it well-suited for enhancing student outcomes in introductory programming courses.

Firstly, it assists with syntax. Beginners often struggle with syntax rules and tedious boilerplate code, such as import statements, which slow learning. Copilot speeds development by handling repetitive code, allowing students to concentrate on higher-level problem-solving.

Secondly, Copilot provides varied examples. Giving several possible output suggestions for a piece of code from a comment enables students to select the best code required, much like a built-in multiple-choice question. Exposure to diverse examples aids conceptual understanding according to constructivist learning theories. The numerous code suggestions from Copilot illustrate varied programming approaches, which require students to analyze each one to fit their needs, thereby promoting language learning.

Many CS curriculums fall short due to little attention given to debugging and problem-solving. As of this writing, the beta version of Copilot chat has features that fix broken code (/fix command) and explains a block of code (/explain command). This is incredibly useful for finding bugs and suggesting changes, keeping student motivation high by mitigating frustrations from debugging errors. The explanation feature helps students work comfortably with legacy code, i.e., code that is undocumented and generally difficult to read and understand. Acting much like a virtual teaching assistant increases the learning rate.

Plagiarism Concerns

Lau & Guo (2023) present findings from interviews with 20 instructors across 9 countries in early 2023, right after ChatGPT’s public release. This captures a unique snapshot before best practices have converged. In the short-term, many instructors are concerned about cheating and have reacted by banning AI tools, weighing exams more heavily, or exposing students to AI capabilities/limitations. Most agree that in the longer term, CS educators must learn to embrace these tools opinions diverge on whether to resist or embrace AI tools by integrating tools into courses to prepare students for using AI in future jobs. New assignments could have students collaborate with AI.

In my testing, I have found that manual intervention is still needed to produce functional code (as you can see from the video above). Nguyen & Nadi (2022) found that out of 33 programming problems from LeetCode, a popular competitive programming practice site, Copilot produced a correct answer 57% in Java, compared to only 27% of the time in JavaScript. This means proper tool use requires students to learn and apply the language’s nuances. We should note that this tool is made for the programmer to lessen their workload. Tools like Intelli-sense and extensions for specific languages already exist that do similar things. It is important to remind students that the goal is to learn the language; this tool will help them get there. It is still essential to learn things like modularization, design, and other programming abstractions as a CS student. Copilot is a great tool to give students a close enough answer and for them to figure out the rest of the code. This requires an understanding beyond what can be taught in the classroom.

Strategies for Productive Use of Copilot in Introductory Programming Courses

I believe Github Copilot should not be used in assessments in first-year courses due to its ease of use for basic programming problems. However, in later courses, once students become more familiar with language syntax and proper software design techniques, it can be used to solve more elaborate problems. I think Copilot will allow students in upper-division courses to express what they’ve learned rather than getting bogged down by syntax.

Still, to leverage Copilot effectively, instructors should provide guidance on integrating it into the learning objectives. Here are some best practices. First, let Copilot provide hints, not complete solutions. Encourage students to trace through Copilot code proposals line-by-line manually to build understanding rather than passively accepting suggestions. Second, students must refine and improve upon Copilot’s recommendations and learn to identify any incorrect suggestions. This practice enhances critical thinking and reinforces good practices. In teaching, we must balance Copilot usage with understanding documentation. Lastly, it’s vital to underscore that Copilot is an assistive aid, not a replacement for foundational coding skills.

Conclusion

GitHub Copilot has significant potential to be a transformative tool in introductory programming education. It offers a variety of functions that can significantly benefit beginners. Used strategically and under close supervision, Copilot can become an asset in a novice programmer’s toolkit. It can provide help and immediate feedback to increase comprehension and build confidence, much like a virtual tutor. However, it’s essential to recognize the delicate balance between assistance and over-reliance on AI tools. The challenges faced in integrating GitHub Copilot into programming education are reminiscent of those faced by mathematics educators when determining at what grade level a student should be allowed to use a calculator. Just as a calculator can aid in complex calculations but should not substitute for understanding basic mathematical principles, Copilot can be a valuable tool for code suggestions and error corrections but should not replace a solid understanding of programming concepts.

References

Nguyen, N., & Nadi, S. (2022). An empirical evaluation of GitHub copilot’s code suggestions. Proceedings of the 19th International Conference on Mining Software Repositories. https://doi.org/10.1145/3524842.3528470

Lau, S., & Guo, P. (2023). 16. https://doi.org/10.1145/3568813.3600138

Culturally Responsive Computing Approaches

Introduction

Culturally responsive computing (CRC) is an approach to designing technology education programs and tools that responds to the cultural contexts of learners and represents an intersection between computer science, education, and sociocultural understanding. It has roots in the extensive and well-studied area of culturally responsive teaching (CRT), which argues that empowering diverse students requires building on the cultural assets they bring to the classroom. CRC translates fundamental principles of CRT to computer science education and ensures that the cultural experiences of learners, particularly those from underrepresented groups, are valued and used to enhance their learning experience. In this blog post, I will uncover some examples of research that has established the critical role CRC plays in promoting inclusion, diversity, and equity in the computer science classroom.

History of CRC

Foundational concepts for CRC were established between the early and mid-1990s. Henderson (1996) argued that instructional design models for teaching technology must consider diverse learners’ cultural orientations. Henderson proposed the Multiple Cultural Model for instructional design, which sheds light on the various dimensions that influence how diverse cultural groups interact with multimedia learning environments. For instance, some cultures might lean towards cooperative learning, while others favour competition.

In 1999, McLoughlin outlined features necessary for culturally appropriate online learning for Indigenous Australian students, emphasizing participatory tasks and problem-based dialogue. Subsequently, Lee (2003) presented a framework designed to ensure that computing tools and environments respond effectively to the prior knowledge, perspectives, and motivations of minority learners. This framework was shown through software that facilitated literacy development among African American students, thereby demonstrating the effectiveness of this approach.

Limitations of the CRC Framework

Drawing on their programs, Scott, Sheridan, and Clark (2014) implemented their unique CRC programs, critiquing the limitations of traditional asset-based approaches and advocating for direct cultural responsiveness. Their arguments highlighted the following points:

  1. All youth possess the capability for digital innovation, thereby challenging deficit perspectives.
  2. Learning environments should promote transformational uses of technology.
  3. Paying attention to intersectional identities can foster innovation in computing.
  4. Students should utilize technology to reflect on their complex identities.
  5. Success should be defined by creating for community benefit rather than merely acquiring skills.

They provided examples such as critiquing biased media representations and encouraging students to create media that affirmed their identities. The implications of their arguments include the need to revise methods and measures, conduct intersectional research, and promote collaboration between computer experts and communities. CRC can potentially address digital equity through innovation, especially when implementations consider students’ multifaceted identities.

Culturally Responsive Computing Tools

Reflecting on these limitations, Morales-Chicas et al. (2019) conducted a comprehensive study on the tools and strategies employed in K-12 computing education for CRC. They identified the following emergent themes:

The first was sociopolitical consciousness-raising, which pertains to lessons that address real-world issues and promote activism. For example, COMPUGIRLS is a CRC program for adolescent girls of colour from underserved communities. Drawing on principles of culturally responsive teaching, including asset building, connectedness, and reflection, the program equips girls with the technological skills needed to research and address community issues. Participants reported increased confidence, the development of identities as technology innovators, and a feeling of empowerment from creating projects that address social justice issues.

Another theme is incorporating heritage culture through artifacts, like designs and symbols. Examples include programs encouraging student-created media to challenge stereotypes and software that builds on cultural practices, such as hair braiding patterns (Eglash & Bennett, 2009). This builds community connections, which involve community members sharing cultural knowledge and motivating students to engage actively.

Vernacular culture employs local cultural practices that are relevant to students. An example is the American Distributed Multiple Learning Styles Systems (AADMLSS), a programming tool designed to engage African American students using math and characters representing their vernacular culture. Studies have shown a surge in youth engagement due to the high cultural relevance of this approach.

Lastly, the theme of lived experiences connects to students’ identities and real-world contexts. For instance, Scott & White (2013) argued that CRC should consider students’ lived experiences and encourage self-representation, evidenced by a youth exercise in COMPUGIRLS on identifying gender biases in avatar creation. Also, by introducing personalized elements into a course, students can analyze this aspect of the computing experience critically, further enabling the customization of computing projects.

Conclusions

Studies have scrutinized the implications of the developments in CRC. For assessment, this necessitates a move beyond narrow measures such as grades or test scores to capture complex identity outcomes (Scott & White, 2013). From a methodological perspective, it requires attention to intersectionality, considering how factors such as race, gender, and class shape technology experiences (Scott, Sheridan & Clark, 2014), more research is required to understand its effects on diverse populations and domains. In practice, CRC should adopt a multi-disciplinary stance, adopting collaboration between communities, social scientists, and computer scientists (Eglash et al., 2013).

Therefore, we call on computer science educators, tech companies, and community organizations to take the following actions:

  • Allow greater curriculum flexibility for CS instructors to adapt courses to their students’ cultures and identities, to discover the intersects for each student.
  • Develop alternative metrics focused on identity development, community impact, and equitable outcomes to complement skills-based measures.
  • Increase engagement of families and communities as partners in developing computing programs.
  • To exchange knowledge, Foster collaboration (through incentives) between tech companies, social scientists, and CS educators.

References

McLoughlin, C. (1999). Culturally responsive technology use: developing an on‐line community of learners. British Journal of Educational Technology30(3), 231–243. https://doi.org/10.1111/1467-8535.00112

Lee, C. D. (2003). Toward A Framework for Culturally Responsive Design in Multimedia Computer Environments: Cultural Modeling as a Case. Mind, Culture, and Activity10(1), 42–61. https://doi.org/10.1207/s15327884mca1001_05

Henderson, L. (1996). Instructional design of interactive multimedia: A cultural critique. Educational Technology Research and Development44(4), 85–104. https://doi.org/10.1007/bf02299823

Morales-Chicas, J., Castillo, M., Bernal, I., Ramos, P., & Guzman, B. (2019). Computing with Relevance and Purpose: A Review of Culturally Relevant Education in Computing. International Journal of Multicultural Education21(1), 125. https://doi.org/10.18251/ijme.v21i1.1745

Eglash, R., & Bennett, A. (2009). Teaching with Hidden Capital: Agency in Children’s Computational Explorations of Cornrow Hairstyles. Children, Youth and Environments19(1), 58–73. https://doi.org/10.1353/cye.2009.0024

Scott, K. A., & White, M. A. (2013). COMPUGIRLS’ Standpoint. Urban Education48(5), 657–681. https://doi.org/10.1177/0042085913491219

Scott, K. A., Sheridan, K. M., & Clark, K. (2014). Culturally responsive computing: a theory revisited. Learning, Media and Technology40(4), 412–436. https://doi.org/10.1080/17439884.2014.924966

Incorporating Competitive Programming into a Beginner Programming Course

Introduction

Driven by the increasing automation and digitalization of virtually every workflow, programming has become an indispensable part of our lives. As a result, introducing programming at the earliest stage of education has become a hot topic of discussion among educators and academics alike.

A particular area of interest is the concept of competitive programming (CP). Long viewed as a niche domain, a small group of enthusiasts often pursue CP to challenge their coding capabilities; many faculty have challenged the area as an unnecessary part of computer science. However, recent research underscores the potential of competitive programming as a useful pedagogical tool, especially in the context of introductory programming courses. This blog post will discuss the results of various studies that have been conducted on incorporating CP into a beginner’s programming course. I’ll review existing studies on integrating CP into intro-level programming courses, examining its effects on learning outcomes, student engagement, and skill acquisition. In addition, I will also propose some areas of CP that require further research.

Understanding Competitive Programming

Competitive programming is a mind sport, like chess and bridge, that involves participants competing to solve algorithmic problems as quickly and efficiently as possible. The ACM ICPC (Association for Computing Machinery – International Collegiate Programming Contest) is one of the world’s oldest, largest, and most prestigious programming contests, which started in the 1970s. Today, it has grown to involve tens of thousands of participants, attracting the world’s top Computer Science universities.

Several elements define each problem in the contest. First, there’s a problem statement describing the issue the team needs to solve. Next are the input and output specifications, which explain the type of data the team’s program should accept and produce. Thirdly, sample inputs and outputs are given to help the team understand the problem. Finally, constraints are provided to outline the maximum size or other limitations of the inputs and the required efficiency of the solution.

The contest is scored based on the number of problems solved and the time penalty. The number of problems solved is the most critical factor; the more problems a team solves, the higher their rank will be. Teams are primarily ranked by the number of problems they have solved. To break ties among teams who have solved the same number of problems, the ICPC uses a time penalty calculated from the beginning of the contest to the time of the first correct submission, with an additional penalty added for each incorrect submission. The team with the shortest total time is ranked highest.

The Impact of Competitive Programming on Beginners

Studies such as those conducted by Moreno et al. (2018) and Bandeira et al. (2019) employed this scoring system and contest setup to engage first-year students in programming classes. Both studies found that students introduced to competitive programming in their first year demonstrated a superior understanding of programming principles compared to those who did not. These students exhibited faster problem-solving abilities, improved code efficiency, and an increased capacity to work under pressure. Additionally, these students reported higher retention of material and reduced difficulty in grasping programming concepts.

However, not all studies concluded that CP led to improved performance. Coore and Fokum (2019), facing a lack of teaching assistants and quality feedback in first-year programming courses, employed a system of weekly competitive programming competitions to reinforce the week’s material. Their study found that while using competitive programming in assessments did increase student engagement and interest, it did not enhance the overall performance of the first-year students.

The Challenges

While CP introduces students to the rigours and excitement of coding under constraints, it’s important to recognize that CP cannot address every aspect of introductory programming. Also, certain facets of CP, such as its pace and competitive element, may only suit some learners.

Astrachan (2004) has pointed out that competitive programming only allows students to delve into key areas such as Object-Oriented Programming (OOP) design principles and enhancing code quality. CP emphasizes speed and efficiency, often overlooking the importance of well-structured, maintainable code, a crucial aspect in real-world development.

While competitive programming can inject a sense of competition into the classroom, it’s important to remember that it’s not a one-size-fits-all solution. The competitive aspect of CP may be intimidating for some students, leading to heightened anxiety and stress. This could, in turn, hinder learning and deter participation. Moreover, the pace of competitive programming, which requires swift comprehension of problem statements and speedy code implementation, may only cater to some learning styles. Some students may require more time to thoroughly grasp concepts and develop robust solutions, which could make the fast-paced environment of CP feel overwhelming.

Given these characteristics of CP, it’s clear that it should not be used as the sole determinant in course assessments. Relying too heavily on CP for grading could inadvertently favour students who possess abilities unrelated to computer science, such as high reading speed and fast typing. These intangibles can be advantageous in a competitive programming environment but have little relevance to a student’s understanding of computer science principles or their potential as a programmer.

Future of Competitive Programming in Classrooms

Although much research has been done involving introducing competitive programming into the classroom, little work explores the impact of cultural relevance in problem-setting, the role of artificial intelligence (AI) in integrating CP, and how CP interacts with various cultural and social intersections in the academic sphere.

The classroom is often characterized by a variety of cultural and social intersections. Incorporating CP in such a setting prompts us to consider how it might affect the likeability, acceptability, and academic performance across these intersections. Is CP equally appealing and accessible to students of different cultures, genders, or social backgrounds? How might the competitive nature of CP impact the dynamics of these intersections? Delving into these questions would allow us to devise strategies to ensure a more equitable and inclusive learning environment.

A unique feature of competitive programming is its creative liberty in problem-setting. This opens the possibility of integrating culturally relevant problems. Introducing programming problems referencing students’ home countries or cultures could make the learning experience more relatable and be a powerful tool to increase engagement among international students. However, the impact of such an approach is yet to be fully understood. How might culturally sensitive problems influence students’ interest and engagement? Could they enhance learning outcomes, or could they unintentionally alienate students who do not share the same cultural background?

Artificial Intelligence offers exciting possibilities in CP. For instance, large language models such as ChatGPT can assist in problem setting, which is typically a significant demand on an instructor’s time. AI-based tools could also serve as programming partners for first-year students, providing personalized assistance such as debugging help or hints for specific problems during a contest. This could supplement the responses from auto-grading judges, which is currently limited to categorized feedback that can sometimes be vague. This approach increases access to individualized learning support and mitigates common challenges associated with competitive programming, such as anxiety and intimidation. However, areas that require further exploration include the effectiveness of such tools and the best strategies for integrating them into the learning experience.

References

Moreno, J., & Pineda, A. F. (2018). Competitive programming and gamification as strategy to engage students in computer science courses. Revista ESPACIOS39(35).

Bandeira, I. N., Machado, T. V., Dullens, V. F., & Canedo, E. D. (2019, October 1). Competitive programming: A teaching methodology analysis applied to first-year programming classes. IEEE Xplore. https://doi.org/10.1109/FIE43999.2019.9028518

Astrachan, O. (2004). Non-competitive programming contest problems as the basis for just-in-time teaching. https://doi.org/10.1109/fie.2004.1408553

Coore, D., & Fokum, D. (2019). Facilitating Course Assessment with a Competitive Programming Platform. Proceedings of the 50th ACM Technical Symposium on Computer Science Education. https://doi.org/10.1145/3287324.3287511

Computer Science Curriculum Integration for K-9 Teachers

Introduction

With a rapidly advancing world and integrating more technology into life, it has increasingly become evident to parents, teachers, and students alike that technological literacy is essential to primary education. Parents are pushing for increased computer science instruction in elementary schools as they realize how vital this knowledge will be in preparing their children for success beyond grade school.  According to code.org (Computer Science Education Stats, n.d.), 90% of parents want their children to study computer science, but only 53% of high schools offer it in their curriculum. Research has also shown that students who take computer science courses in high school are 17% more likely to pursue higher education, with even higher percentages observed among traditionally marginalized populations such as females and Black and Latino students (Brown & Brown, n.d.).

While computer science courses provide fundamental skills like coding and web design, their significance extends far beyond that. Understanding technology equips students with data analysis capabilities and problem-solving skills applicable across various fields, extending beyond digital work environments. Consequently, many believe it is crucial to prioritize teaching computer science concepts. This post outlines my efforts to understand the computer science curriculum’s current needs and promote computer science education among elementary school teachers in British Columbia.

Assessing Current Needs

According to Dr. Shannon Thissen, Regional Administrator for Educational Technology and Computer Science Teaching and Learning in Capital Region ESD 113 in Washington, integrating computer science concepts into the curriculum poses significant challenges. Dr. Thissen mentions that many untrained teachers express concerns and seek guidance. The primary obstacle is teachers’ fear of the unknown, and overcoming this fear is crucial. Several programs, including those offered by code.org, provide free resources for teachers. However, the participation of schools in these programs in British Columbia remains limited. Dr. Thissen also highlights that teachers may hesitate to incorporate such programs into their curriculum if they are not mandated.

In a previous post, I discussed the inconsistency of computer science programs in grade schools across British Columbia, particularly emphasizing the needs of interior and rural areas. While I faced difficulties connecting with schools that desired my services, I recently connected with a Programming 11/12 teacher in Kamloops. I had the opportunity to speak to her class, providing valuable insights into the needs of both teachers and students. Students showed great interest in game development and 3D animation. Despite being a beginner-level class, students had diverse backgrounds in the subject, with some having significant experience with Unity while others struggled with the early stages of block programming. However, their shared enthusiasm for the subject validated studies showing that a majority of students enjoy computer science (Computer Science Education Stats, n.d.). This highlights the need for increased promotion of computer science in the earlier grades to nurture this enjoyment.

Currently, I am collaborating with John Knox Christian School, which is revamping its computer science and technology curriculum. Working with the Director of Curriculum and Computer Science, we are developing a series of workshops to assist K-9 teachers in integrating computer science into their classrooms. This collaboration is an excellent opportunity as John Knox controls its curriculum from K-12, enabling longer-term assessment of student success through the workshops with the same group of students.

Project Design

The central portion of the project is divided into four phases: Assessing Needs, Planning and Foundations, Integration, and Reflection.

Assessing Needs:

To ensure alignment with the school’s desired outcomes and address the specific needs of K-9 teachers, a survey will be created and distributed to all K-9 teachers. The survey aims to gather information on teachers’ objectives, knowledge levels, and areas of interest in computer science. The survey includes choices for dedicated topics such as programming, computational thinking, artificial intelligence, game development, and computer hardware. The project will tailor its objectives and content to meet the needs and interests of the teachers. The survey will be sent out during the first week of summer break.

Planning and Foundations:

This phase involves conducting a workshop covering computer science fundamentals, including vocabulary, problem-solving, and demystifying computer science. The workshop will also focus on integrating hands-on activities for teachers to experience and practice computer science concepts firsthand. Teachers will be guided in designing activities that promote problem-solving, collaboration, and critical thinking skills. Additionally, resources such as coding platforms, educational apps, and lesson plans will be provided to support teachers in implementing computer science activities beyond the workshop. By the end of the workshop, teachers should have a plan to incorporate computer science concepts into an existing lesson. This workshop is scheduled for the first professional development day in September 2023.

Integration:

Teachers will execute their plans to integrate computer science concepts into the classroom during the integration stage. One strategy for this stage is to have coaches co-teach a computer science lesson alongside the classroom teacher. Initially, the director and I will act as coaches, but the plan is to train coaches for future iterations. Co-teaching allows the teacher to observe and learn from the coach’s expertise and experience, helping teachers gain confidence and deepen their understanding. The coach can help guide students through hands-on activities and will provide positive reinforcement, celebrate teachers’ achievements, and acknowledge their efforts in integrating computer science concepts. In addition to co-teaching, coaches will observe regularly and provide teachers with constructive feedback. Classroom observations, either in person or through video recordings, will be conducted to assess the implementation of computer science lessons and the effectiveness of teaching strategies. Coaches will then provide feedback, highlighting strengths and offering suggestions for improvement. This feedback loop will enable teachers to reflect on their practice, refine their instructional techniques, and make continuous progress in integrating computer science effectively.

Reflection:

Integration is ongoing, and teachers require continued support beyond the initial stages. Follow-up meetings, workshops, or online forums will be organized to facilitate knowledge sharing, questions, and further guidance. These support mechanisms will help sustain the momentum and provide teachers with ongoing professional development and collaboration opportunities. Coaches will curate and share relevant resources, including lesson plans, coding activities, and best practices, to further support teachers’ integration efforts. This stage is scheduled for the third professional development day in November 2023.

Analyzing the Design

Using Adria Steinberg’s (1998) six A’s of evaluating project design, my proposed project aligns with these principles, ensuring the successful integration of CS into K-9 classrooms.

Academic Rigor: The project emphasizes challenging and intellectually stimulating CS content. It provides opportunities for students to engage in practical problem-solving, critical thinking, and analytical reasoning. The project also encourages teachers to adopt a different mindset when teaching CS.

Authenticity: The project provides real-world contexts and experiences that connect CS concepts to students’ lives and interests. It includes relating CS to authentic scenarios, which enhances student motivation and engagement in other subjects. By establishing these connections, the project makes CS more relevant and meaningful to students.

Applied Learning: The project emphasizes the hands-on application of CS knowledge and skills. It encourages teachers to apply CS-related skills to different activities in the classroom. This approach allows students to experiment, problem-solve, and apply CS principles in real-world contexts.

Active Exploration: The project encourages students to explore CS concepts through inquiry-based and self-reflective learning. It creates an environment that nurtures teachers’ and students’ curiosity, exploration, and independent thinking; this fosters a sense of ownership in their CS learning journeys.

Adult Relationships: The project recognizes the importance of fostering supportive and meaningful connections between students and adult mentors or educators. By incorporating coaches or mentors into the framework, the project provides students (and teachers) opportunities to interact with CS professionals, experts, or mentors. These interactions offer guidance, share real-world experiences, and serve as role models for students.

Assessment: The project includes an assessment plan to evaluate student learning and program effectiveness. It incorporates post-integration surveys and other assessment strategies to measure the impact of CS integration on student learning outcomes. Gathering feedback from stakeholders informs program improvements and ensures ongoing effectiveness.

Next Steps:

To effectively integrate computer science into K-9 classrooms, conducting one or two workshop iterations is needed. This allows for refinement and improvement of the workshop content and delivery based on feedback and insights from the initial sessions. During each iteration, it is important to collect feedback from participating teachers. Assessing the teachers’ comfort levels with integrating computer science concepts and their perceived efficacy in implementing the learned strategies in their classrooms will help gauge the workshop’s effectiveness. Additionally, student learning outcomes can be evaluated through pre- and post-workshop assessments to measure students’ knowledge growth, skills development, and attitude toward computer science. Comparing these assessments will provide evidence of the workshop’s impact on student learning.

Once the initial iterations of the workshop have been conducted and evaluated, the next step is to engage rural area schools with a more concrete plan. Building on the lessons learned and feedback from the initial workshops, it is essential to develop a targeted approach specifically tailored to the needs and challenges of rural schools. Further changes to the workshop may include solutions to overcome unique barriers such as limited resources, infrastructure challenges, or teacher training opportunities. Designing the workshop to accommodate these conditions will increase its relevance and effectiveness in rural settings.

If the workshop successfully enhances teacher comfort levels and promotes student learning, developing a Professional Development Program (PDP) at the university is an excellent opportunity. A PDP would offer a more structured and comprehensive training program for teachers seeking to integrate computer science into their K-9 classrooms. The Education Department can collaborate with the School of Computing Science and instructional design experts to design a robust PDP curriculum. This curriculum should address the specific needs of teachers, providing them with theoretical knowledge, practical skills, and ongoing support to integrate computer science concepts into their classrooms effectively.

References

Computer Science Education Stats. (n.d.). Code.org. https://code.org/promote/stats

Brown, E., & Brown, R. (n.d.). The Effect of Advanced Placement Computer Science Course Taking on College Enrollment. http://www.westcoastanalytics.com/uploads/6/9/6/7/69675515/longitudinal_study_-_combined_report_final_3_10_20__jgq_.pdf

CS Journeys Resources: Mentorship and community. (n.d.). Code.org. Retrieved June 3, 2023, from https://code.org/beyond/mentors-and-community

Steinberg, A. (1998). Real learning, real work : school-to-work as high school reform. Routledge.

K–12 Computer Science Framework. (n.d.). K12cs.org. https://k12cs.org/