Abstract
Computational thinking (CT) uses concepts that are essential to computing and information science to solve problems, design and evaluate complex systems, and understand human reasoning and behavior. This way of thinking has important implications in computer sciences as well as in almost every other field. Therefore, we contend that CT should be taught in elementary schools and included in every university’s educational curriculum. Several studies that measure the impact of teaching programming, analytical thinking, and CT have been conducted. In this review, we analyze and discuss findings from these studies and highlight the importance of learning programming with a focus on the development of CT skills at a young age. We also describe the tools that are available to improve the teaching of CT and provide a state-of-the-art overview of how programming is being taught at schools and universities in Colombia and around the world.
Computational thinking (CT) is a way of approaching everyday situations and solving problems by utilizing concepts that are fundamental to computer science. As Wing (2006, p. 1) stated, “Computational thinking is reformulating a seemingly difficult problem into one we know how to solve, perhaps by reduction, embedding, transformation, or simulation.” This process not only prepares students in the field of computer science but also provides students with tools and skills to approach and solve a wide range of problems in different areas of knowledge (Werner, Denner, Campe, & Kawamoto, 2012). Nowadays, CT influences fields related to the natural and social sciences and facilitates the acquisition of skills to solve problems, design systems, and understand the power and limits of human and machine intelligence.
In this review, we begin with a section that describes our literature search strategy. Next, we include a section in which we discuss how programming can be used to develop skills related to CT in students from school to higher education, and we highlight the importance of peer-based collaborative environments and concept maps and how these tools enhance a meaningful programming experience. In the third section, we review the impact of programming in diverse fields of study as well as the issues faced when teaching and learning programming in higher education. Last, we provide a state-of-the-art overview of how programming is being taught in schools. In this final section, we address the challenges faced by early programmers and describe the tools that are available to improve the teaching process of CT at schools worldwide.
Method
To obtain an overview of the state of the art of teaching and learning programming in educational institutions, we made an extensive, worldwide search of papers in journals and proceedings of the Association for Computing Machinery Digital Library, as well as in journals specialized in education of computing or programming (e.g., Review of Educational Research, Computer Science Education, Education and Information Technologies, Computers in Mathematics and Science Teaching, Journal of Virtual Worlds Research, Educational Technology & Society, among others). Several key words and key phrases were used throughout our search. Among these were “teaching/learning programming,” “issues in teaching/learning programming,” “challenges for novice programmers,” “programming in schools,” “programming in higher education,” “coding for children,” “woman in computing,” “coding in the 21st century,” “programming in the United States/Europe/Asia/Latin America,” “approaches to teaching/learning programming,” “collaborative teaching/learning in programming.”
Subsequently, we searched for literature that might not be published in indexed journals or proceedings. We performed an open search in Google Scholar using the same key words and key phrases to gather information from associations of teachers and individual initiatives in the field. Given that these references were from unindexed sources, we decided to restrict the search to associations of teachers in leading countries in this area. Additionally, we gathered information from nonprofit organizations that aim to encourage the teaching and learning of programming at any age.
We ended up with 92 references, including journal articles, reviews, proceedings, short communications, and governmental standards from established associations of teachers in the United States, the United Kingdom, France, and Germany. No restrictions regarding the date of publication were taken into account. However, information published in the last 15 years was the most relevant for this review. A deep and careful examination was conducted with each of the references found. The most relevant information related to the processes, practices, tools, and experiences in teaching and learning programming both from K–12 and in higher education, was retrieved.
Results
Programming as a Tool for Mind Development
Several lines of evidence exist to support the implementation of CT in schools as well as in higher education. First, children are now, more than ever, exposed to considerable amounts of data, sometimes not curated, delivered in several formats, and most of the time, not interconnected. CT can provide children with the tools to extract the knowledge that might be hidden in the data. Second, we are used to teaching reductionist science (i.e., isolated mechanisms or metabolic pathways), but need to start teaching the systems as they are: complex. Most of the times, because of the lack of time, teachers do not ask or guide their students to make connections between the materials they receive. Third, CT helps enhance the thinking abilities as individuals can superimpose and combine multiple layers of abstraction as a computer programmer does when developing algorithms.
To understand the complexity and importance of teaching CT, it is important to differentiate among specific key terms: computer programming, computational thinking, and algorithmic thinking. We define computer programming as the process through which a person is able to provide a set of instructions that will communicate, as specifically and accurately as possible, a procedure, method, practice, or task to a machine. This set of instructions must be coded using a specific programming language (Vihavainen, Airaksinen, & Watson, 2014). We define CT as a way of reasoning that compiles several high-level skills and practices that are at the heart of computing, but applicable to many areas far beyond computer science. The distinction between CT and algorithmic thinking in the literature is somewhat unclear. However, in this review, we define algorithmic thinking as a way of obtaining a solution through a series of steps. Thus, CT, as defined by Syslo (2015), is a broader term that involves among other skills, algorithmic thinking, logic, abstraction, generalization, decomposition, and debugging.
In theory, teaching programming is the best approach to teach CT. Programming is initially taught by introducing the student to a programming language. Yet very soon after the course begins, the student is faced with several challenges including problem-solving situations, debugging, program design, and implementation. For a long time, teaching to program was considered the best tool for developing minds. However, by the mid-1980s, results of several studies suggested that teaching to program failed to catalyze the development of higher-order thinking skills (Sleeman, 1986). The reasons for this failure are complex. Whereas some authors argue that the way programming was taught was to blame, others blame the nature of programming itself (Sleeman, 1986).
Several studies have shown that students who take programming classes perform better on logical reasoning and problem-solving skills (Tu & Johnson, 1990). To be successful in developing a critical mindset, a computer programming course must (a) specifically define the learning and teaching objectives (including problem solving as an objective), (b) include appropriate educational tools and strategies such as the design and use of concept maps, and (c) consider and understand the differences between novices and experts in programming (specifically differences in their levels of abstraction). Nowadays, technology is ubiquitously present in students’ life and the fear of interacting with the physical machines has diminished. Werner, Denner, et al. (2012) showed that middle school students who had more access to computers and/or more confidence with them, performed better in their problem-solving exercises and algorithmic thinking. However, as noted by Saeli, Perrenet, Jochems, and Zwaneveld (2011) and supported by studies performed by both Kurland, Pea, Clement, and Mawby (1986) and Papert (1993), teaching programming can be a very difficult task. Therefore, suitable educational tools and strategies must support programming courses, so that any individual may become proficient in programming and may further develop their thinking abilities in a reasonable time.
Programming must be seen as a tool to develop concepts and skills related to CT and computer science (e.g., resourcefulness, problem solving, abstraction, algorithmic thinking), rather than a human–machine communication tool, related to the information and communications technology field (ICT; French Academy of Sciences, 2013). Thus, instead of teaching students solely how to write code, programming courses must include the development of skills related to CT as a learning objective. Students who are exposed to CT through programming, develop algorithmic thinking, problem solving, logic, and debugging skills. Hence, the programming that is taught in computer science should be focused on the development of CT skills. Furthermore, computer science must be considered an essential discipline (on a par with mathematics, for example) that every person should learn from primary school onwards. According to Jones, Mitchell, and Humphreys (2013), computer science comprises foundational principles as well as widely applicable ideas and concepts. This discipline incorporates techniques and methods for solving problems and advancing knowledge (such as abstraction and logical reasoning), and a distinct way of thinking and working that sets it apart from other disciplines.
Concepts within computer science have longevity (most of the ideas and concepts from 20 or more years ago are still applicable today) and every core principle can be taught or illustrated without relying on the use of a specific technology. Therefore, teaching fundamentals and concepts in programming as the core for an entire discipline, instead of solely training students in the details of specific programming languages—which might become useless with time—is crucial for the development of CT skills (French Academy of Sciences, 2013).
Peer-Based Collaborative Environments and Concept Maps
Peer-based collaborative environments have shown to significantly stimulate and enrich educational programming (Jakovljevic, 2003). In these collaborative environments, students are able to use web-based conferencing, desktop videoconferencing, and instant messaging to develop their tasks in a collaborative virtual team. Despite the availability of online tools and tutorials, hands-on instruction and guidance from peers or instructors is crucial for students to be able to rapidly solve their inquiries so that they can increase the quality of their projects and solidify what they have learned. Furthermore, there is evidence that peer-based collaborative environments help engender enthusiasm for programming among students and help students complete projects with grander goals in less time (Chase & Okie, 2000).
In parallel with collaborative environments, concept maps have also been shown to enhance a meaningful programming experience for learners at a higher education institution (Jakovljevic, 2003). Concept maps are graphical representations of the knowledge that helps the learner organize the information, analyze it, and then relate and connect it to create new structures that can be applied to any subject (Novak, 1991). This educational tool is considered a metacognitive tool, that is, a strategy that helps learning or understanding knowledge (Novak, 1990). In the field of education, concept mapping was developed in 1972, but it was only in the late 1980s and early 1990s that it was identified as a tool for building powerful knowledge structures by engaging the students in a meaningful learning experience (Cardellini, 2004; Novak, 1998).
Concept maps can guide a student from lower to higher levels of thinking as depicted in the Bloom’s taxonomy. Furthermore, they can help represent all domains of learning, the cognitive, the affective, and the psychomotor (Novak, 1990). Previous studies have shown how the implementation of concept maps has enhanced learning in mathematics (Cardemone, 1975; Novak & Afamasaga-Fuata’i, 2009), genetics (Bogden, 1997), engineering (Turns, Atman, & Admas, 2000), chemistry (Pendley, Bretz, & Novak, 1994), physics (Moreira, 1977), and programming (Jakovljevic, 2003). Novice programmers can use concept maps to design their programs, to help them think about what the program will do, and to describe how they will execute a task. Also, concept maps can help novice programmers organize basic concepts of programming to then use them correctly in their programs (Novak, 1991). The importance of pedagogical tools in programming courses used to achieve the goals of CT will be more thoroughly developed in the fourth section.
Teaching and Learning Programming in Higher Education
Over the last decade, computer science and programming have grown remarkably and have permeated several fields, such as biology, chemistry, physics, medicine, engineering, art, music, and social sciences. Furthermore, new subfields such as bioinformatics, internet security and ethics, gaming, artificial intelligence, among others have been created (Kay, van der Hoek, & Richardson, 2005). As shown in Table 1, computer programming focused on the development of CT skills is an ability that is very useful and can be very rewarding for students in numerous disciplines (Piteira & Costa, 2012). However, teaching programming languages in higher education has proven to be an extremely difficult and challenging task for professors and a difficult subject for students to learn (Mow, 2006). Therefore, experts in this area have been analyzing the difficulties faced by novice students taking introductory programming courses, especially as studies indicate that programming places a heavy cognitive load on freshmen students (Ahmadzadeh, Elliman, & Higgins, 2005; Flowers, Carver, & Jackson, 2004). It is important to underscore the fact that most freshmen students have had no programming background knowledge or experience (Tuugalei & Mow, 2012). According to Flowers et al. (2004), even after 2 years of learning programming, many students are still struggling to be proficient.
Fields in which programming and computational thinking (CT) can be directly applied
Programming requires memorizing a wide range of information and displaying several skills at the same time. A student must think about the details of syntax and semantics of the programming language used, elaborate some mental model of how to solve each problem, and be able to distinguish between solving the problem and specifying the solution in a way that a computer would be able to execute it (Pane & Myers, 1996). Consequently, a student must be capable of using abilities related to CT such as algorithmic thinking (in order to obtain a solution through clearly defined steps), evaluation (ensuring that an algorithmic solution is a good one), decomposition (splitting the situation in several parts), and abstraction (in order to basically make problems or systems easier to think about by removing unnecessary complexity and details; Curzon, Dorling, Ng, Selby, & Woollard, 2014).
Numerous problems associated with the learning of programming have been described for several years. Lahtinen, Mutka, and Jarvinen (2005) stated that novice programmers are typically limited to the surface knowledge of programs, often using a “line by line” programming approach instead of meaningful program structures involving CT skills. This approach most likely leads to a failure in terms of applying the knowledge they have obtained. Additionally, it seems that students may know the syntax and semantics of individual statements, but do not know how to combine them into valid programs, as they lack detailed mental models, and are thus unable to solve problems in an efficient way (Winslow, 1996). Moreover, most students present several issues when they have to understand notions about loops, conditionals, arrays, and recursion (Robins, Rountree, & Rountree, 2003) as well as pointers and references, finding bugs from their own programs, structured and abstract data types, and error handling (Lahtinen et al., 2005; Piteira & Costa, 2013; Tuugalei & Mow, 2012).
In addressing these problems, diverse strategies have been tested in freshmen students. After an extensive survey of both students and professors, Lahtinen et al. (2005) reported that practical sessions in computer rooms were rated as the most useful strategies. On the Internet, students encounter a significant number of examples of codes (executable), programming tutorials, educational videos, and contents available on educational platforms such as Moodle and Blackboard (Piteira & Costa, 2013).
Vihavainen et al. (2014) conducted a literature review to learn about the different intervention approaches to address the concerns. The authors grouped interventions into four different categories. The first category was Collaboration and Peer Support. This category included (a) Peer-Led Team Learning activities in which team-based learning is provided to help the students in introductory programming courses (Lasserre & Szostak, 2011); (b) Pair Programming Activities in which two students with specific roles work collaboratively at one computer on the same design, algorithm, code, or test (Williams, McDowell, Nagappan, Fernald, & Werner, 2003); and (c) Cooperative and Collaborative Practices in which an undergraduate student co-teaches the class as the students are organized in cooperative groups (Chase & Okie, 2000). The second category was named Relatable Content and Contextualization. This one included (a) Media Computation in which design, audio, and web page programs are used to facilitate teaching programming (Tew, Fowler, & Guzdial, 2005); (b) Real-World Projects in which a set of lab exercises based on real-world problems are used by the teacher with the class (De La Mora & Reilly, 2012); and (c) Courses involving games in which using game maker platforms students are encouraged to design a game as desired (Rankin, Gooch, & Gooch, 2008).
The third category was named Course Setup, Assessment, and Resourcing. This group of interventions included (a) Adjusting Course Content so that which students’ bottlenecks are analyzed and then the requirements are adjusted (Shaffer & Rosson, 2013) and (b) Changing the Grading Schema so that all assignments are evaluated in a way that would increase the pass rate and consequently generate a better atmosphere in the class (Nikula, Gotel, & Kasurinen, 2011). Finally, Category 4 was named Hybrid Approaches. This category combines the methodologies applied in the previous three categories, including Media Computation with Pair Programming, Peer-Led Team Learning, and Collaborative Learning with Relatable Content.
At the end of their review, Vihavainen et al. (2014) concluded that, on average, using these types of interventions improves programming courses pass rates by nearly one third compared with a traditional lecture and lab-based approach. These authors also concluded that courses with relatable content (e.g., media computation) and cooperative elements (e.g., pair programming) had increased pass rates and intrinsic student motivation, whereas courses that relied exclusively on a single approach resulted in students performing poorly.
We want to highlight a specific example at the Universidad de los Andes (Bogotá, Colombia). For at least a decade, the Systems and Computing Engineering Department has been conducting surveys and working on some of the most common problems related to teaching and learning programming. These include (a) motivational problems (i.e., finding that some students have the impression that success depends on something beyond their control regardless of the understanding of the theory, algorithmic skills, or the time spent working on a program), (b) lack of congruence between the concepts and skills taught in introductory courses and the ability to write specific programs to solve a problem in an efficient way, and (c) methodological problems in teaching programming. The instructor expected that students would be able to learn on their own by going over examples presented in class and are then expected to design their own programs (Villalobos, Calderon, & Jimenez, 2009; Villalobos, Casallas, & Marcos, 2005).
In order to address the issues with computing courses described above, the Systems and Computing Engineering Department at Universidad de los Andes has been working on a robust interactive platform called Cupi2 (http://Cupi2.uniandes.edu.co) since 2006. This interactive platform encompasses an extensive set of resources that include lectures, workshops, books, articles, lab examples, concept maps, tutorials for students and teachers, as well as reports about class schema and student performance on every programming course taught at the university (Vega, Jimenez, & Villalobos, 2013). Cupi2 was developed as an initiative to tackle major challenges in teaching and learning programming. The main goal was to design learning strategies that use problem-based learning (PBL) and bottom-up approaches to introduce simple concepts (data types, operators, and expressions) and then lead students toward more complex concepts such as control structures, methods, parameters, vectors, and collections in a Java environment (Villalobos & Casallas, 2006).
An introductory course to programming called APO I (algorithms and object-oriented programming) is taught every semester at Universidad de los Andes. This course uses the Cupi2 interactive platform and is taken by students in any of the undergraduate programs from the School of Engineering, the School of Sciences (except for students in biology and microbiology), and some students in the music department, reaching more than 1,000 students per semester. Each class has fewer than 26 students (to improve the one to one interaction between students and teachers) and is divided into six levels, which reflect the difficulty and skills required. In Levels 1 to 5, students are taught the main concepts related to object-oriented programming through lectures and examples included in the textbook written by professors associated to the Cupi2 interactive platform. Furthermore, students attend lab sessions where they have the opportunity to practice problems that are partially solved in a java environment called Eclipse (http://www.eclipse.org/), using the resources available in the Cupi2 platform. Through CupiTaller, which stands for “CupiWorkshop,” students from all academic programs taking APO I or APO II (the course that follows APO I) may access a physical space where they may receive personalized tutoring to strengthen their programming abilities.
At the end of the course (Level 6), students are challenged to solve a complete exercise using all the tools, syntax, and skills learned throughout the semester. These efforts have resulted in an improvement in the success rates and motivation of the students. A nearly 50% decline in the number of students failing the course has been observed as well as a consistent reduction in the number of students that drop the course. Moreover, questions related to the students’ perception of the course showed a 20% increase after the introduction of Cupi2 (Villalobos et al., 2005). Around 25 universities in Colombia work with and develop materials for Cupi2 each year, creating a large and diverse community for teaching and learning programming (Villalobos et al., 2009).
Unfortunately, regardless of all the efforts done to overcome the difficulties associated to learning programming (i.e., Cupi2), a substantial number of students are still challenged by abstract programming concepts and logical reasoning. Responses to the end of semester surveys of the APO I course indicate that students in Level 1, particularly, believe that they could have learned more if they would have had prior experience with programming before taking this first-semester course. In short, the lack of prior experience limits the skills and syntaxes that can be taught, thus hindering the learning of specialized languages such as C, C++, Matlab, Python, Arena, Strata, ArcGIS, and other useful programming languages. To address this concern, we contend that high school students should learn skills related to CT and algorithmic logic, so that it will be easier for them to learn and adapt to new programming languages as well as different software during their undergraduate studies. High school students should be exposed to the development of logic, abstraction, decomposition, and evaluation as well as the comprehension of basic algorithmic design, in order to facilitate the learning of programming in higher education.
An unpublished study at Universidad de los Andes provides support for this claim. Briefly, we retrieved data from all students who took APO I between the spring semester of 2010 and the spring semester of 2015 and identified the high school that the students had attended. As the total number of high schools was more than 900, we selected 61 schools that represented more than half of the students. Each school was contacted directly to assess if programming was taught at any level. Analyses were conducted on a total of 3,855 students using R (R Development Core Team, 2008). Results indicated a significant difference in the average final grades between students who had been previously exposed to programming in high school and those who had had no prior exposure to programming (p value = 2.53 e–08). Students who had been exposed to programming in high school obtained an average grade of 4.5 out of 5.0 (SD = 0.76), and students with no prior experience in programming obtained an average grade of 3.9 (SD = 0.79; dcorrected = 0.77).
Introducing students in elementary and higher school to algorithmic thinking, abstraction, evaluation, problem solving, decomposition, and debugging will most certainly help develop critical skills before college. These skills may result in an easier transition from school to university, and allow professors to focus their undergraduate programming courses on teaching useful features of specific programming languages, as well as reinforcing, but not developing, CT skills. This idea will be further discussed in the following section.
Teaching and Learning Programming in Schools
Barr and Stephenson (2011) argued that today’s students will live and work in a world that is heavily influenced by computing principles. In the midst of this trend, CT has become a prerequisite skill for many endeavors of the 21st century. It is a skill that empowers students and thus it is highly beneficial for them to be competent in CT (National Research Council [NRC] 2010). Given that CT is permeating several fields in which most of the students will develop an undergraduate program, it is important to introduce these concepts in schools. Specifically, CT concepts should appear as early as in elementary school, and continue through secondary school and beyond (Qualls & Sherrel, 2010). In this section, we will discuss the different strategies that have been proposed to teach CT in an effective way (using programming as the central core of computer science) to elementary and high school students.
Three psychological theories have been put forward to explain the most effective ways of teaching: objectivism, cognitivism, and constructivism (Luo, 2005). Briefly, objectivism describes the world as an environment made up of objects and proposes that learning is grounded in observation, a process to create corresponding representations of these objects in the minds of learners (Lakoff, 1987). Cognitivism focuses on how human memory works to promote learning. It considers learning as “involving the acquisition or reorganization of the cognitive structures through which humans process and store information” (Good & Brophy, 1990, p. 187). Finally, Ben-Ari (2001) contended that the dominant theory of learning in all the areas of knowledge, including CT, is the constructivism. This theory proposes that knowledge is actively constructed by the student using experiences and previously acquired knowledge, and not passively absorbed from textbooks and lectures. Furthermore, the Ben-Ari claimed that in terms of CT, passive learning will likely fail because each student brings a different cognitive framework to the classroom, and each student will construct knowledge in a different way. Thus, learning must be active; the student must construct knowledge assisted by guidance from the instructor and feedback from other students.
Based on a constructivist approach, programming has been suggested as the main strategy to address CT in schools (Hromkovic, 2006; Wing, 2006). Although CT is broader than programming, the latter is a central process for CT. Programming encourages creativity, logical thinking, precision, and problem solving, and helps improve the personal, learning, and thinking skills required in the modern school curriculum (NRC, 2010). Generally, programming is taught using programming languages; nevertheless, teaching programming to elementary and high school students can be extremely difficult. Linn (1985) stated an ideal chain for learning computer programming, which gradually goes from program comprehension and ends with program generation, based on lectures and practical exercises. The chain has three main links: Single Language Features, Design Skills, and General Problem-Solving Skills (Saeli et al., 2011). According to Linn, the ideal chain should start with the understanding of the language features, knowledge that can be assessed by asking students to reformulate or change a language feature in a program so that the program does something different (Saeli et al., 2011). The second link of the chain consists of design skills, which are a group of techniques used to combine language features to form a program. The third link of the chain is useful for learning new formal systems. Asking students to solve problems using an unfamiliar formal system such as a new programming language can help transmit problem-solving skills (Saeli et al., 2011). Although this chain of cognitive accomplishment requires an extensive amount of time, it forms a good summary of what could be meant by deep learning in introductory programming (Robins et al., 2003).
Even if the previously mentioned approach to teach programming has been well-described and widely used, introductory courses of programming in schools, called CS0 (Computer Science 0) and CS1 (Computer Science 1) may have as high as a third of the students failing the course when only using lectures and lab-based exercises (Bennedsen & Caspersen, 2007). A recent study showed that despite the advances in pedagogy, research, and application, students still fail in trying to learn programming, and more important, the course failure rates are not yet, substantially influenced by aspects of external teaching context, such as the programming language taught in the course (Watson, 1997). In other words, the problem might not be the language used to teach programming, but the teaching intervention approach used to reach the attention and interest of the student as well as the support provided in the process.
Challenges Faced by Early Programmers, Programming Languages, and Pedagogical Tools Used in Schools
Over the past 15 years, in most of the schools where programming is taught, programming languages that are professional in nature (such as C, C++, and Java) are used as the main tool for teaching based on the availability of engineers able to teach the course, online material, and third-party vendors who provide support around the world (Costa & Aparicio, 2014; Grandell, Peltomaki, Back, & Salaskoski, 2006). However, these languages have extensive and complex syntaxes, leading to great difficulties for beginners (Jenkins, 2002). The methodology involves traditional teaching methods, normally based on lectures and specific programming language syntaxes, in combination with guides and computer lab sessions (Bennedsen & Caspersen, 2007). Nevertheless, these approaches often fail in motivating students and in getting them involved in deep programming activities (Lahtinen et al., 2005; Schulte & Bennedsen, 2006).
One of the difficulties faced by novice programmers include dealing with the verbosity in specialized programming languages, which makes it harder for them to learn algorithmic thinking (Grandell et al., 2006). Novice programmers have to deal with abstract concepts. They need to understand a given problem, identify the steps to approach such problem, and be able to design a solution. Students should know how to subdivide a given solution into easy and simpler pseudo-code and ought to be able to conceive hypothetical error situations in order to test their programs and find possible missteps (Esteves, Fonseca, Morgado, & Martins, 2008). Furthermore, novice programmers have difficulties understanding even the most basic concepts in programming such as variables, data type, machine structure, and functioning, given that there are no real-life analogies related to these concepts (Lahtinen et al., 2005; Miliszewka & Tan, 2007). Last, even after understanding the basic concepts in programming, programmers must learn the specificities of the programming language they intend to use (Lahtinen et al., 2005; Winslow, 1996).
Another important fact that should be considered as a major challenge in learning and teaching programming is the low enrollment and interest of women in computer science courses and programs. Researchers have identified a variety of factors that may contribute to this issue. These factors include concerns about the computing culture, lack of encouragement from peers (Kelleher, Paushc, & Kiesler, 2007), lack of motivation, and gender stereotypes (Doube & Lang, 2012). Extremely strong school stereotypes are held in STEM (science, technology, engineering, and mathematics) fields, including computer science, where females have a lower self-concept of ability than males ranging from an early age (Denissen, Zarett, & Eccles, 2007) to postgraduate studies (Cohoon & Asprey, 2006), despite an equivalent and sometimes higher level of achievement (Eccles, 2007).
In the STEM field of computing, females have significantly less confidence than males in their ability to learn and succeed (Singh, Allen, Scheckler, & Darlington, 2007). Furthermore, there is a widespread perception that computer experts are socially isolated “geeks” or “nerds” obsessed with technology, a way of living that does not match with most women (Margolis & Fischer, 2002) who tend to be more socially oriented (Herring, Christine, Ahuja, & Robinson, 2006). Doube and Lang (2012) showed that when a course related to computing was removed from the School of Science and placed in the School of Humanities, not only was the female enrollment higher but women also reported enjoying the course and finding applicability to their careers. These authors concluded that there is a psychological aversion in females due to male stereotyping in computing discipline, which is also observed in mathematics, science, and other disciplines (Lang, 2002). Furthermore, females in high school have indicated that their disinterest in computing disciplines arose from their classroom experiences, where they faced isolation, low confidence, felt underrated, and extremely anxious (Pau, Hall, & Grace, 2011). To address some of these issues, students from Computer Science and Information Technology, have developed educational videos that enhance learning experiences related to computer programming in a friendly and familiar environment for women (Ali, 2016; Ali, Raza, & Ali, 2016.).
Despite the difficulties associated with learning programming in school, which are not easy to solve, we strongly agree with Jeannette Wing’s (2006) vision that CT is an extensive framework of concepts, abilities, and skills that young people should learn in schools. We also agree with Serafini (2011) that learning programming on an adequate level of abstraction is a very effective didactic approach to CT, independent of the age of the learners. Hence, we decided to gather, classify, and describe below the most powerful and useful tools available to start the immersion of novices in programming.
Virtual approaches: Logo, scratch, and python as alternative languages for beginners
Logo is a mini-language, and in contrast to general-purpose programming languages, it was explicitly developed for teaching programming (Hromkovic, 2006). To write and run programs, novices should not have to deal with the complexity of an extensive general-purpose programming language such as C, C++, and Java (Brusilovsky, Calabrese, & Miller, 1998). Logo editors do not rely on a click-and-drag approach allowing the students to type the instructions by themselves. This makes students care for the correct syntax and allows them to practice debugging (Serafini, 2011). Additionally, the open-source programming environment of XLogo (Le Coq, 2010) presents some interesting features; it runs on multiple platforms, no Internet connection is needed, runs quite well on slow computers and is free, encouraging its use as an introductory tool for programming in schools (Serafini, 2011). Furthermore, teaching materials are available free of charge designed as didactic guidelines and exercises to support teachers (Hromkovic, 2006).
Scratch is a media-rich programming environment developed by MIT’s Media lab (https://scratch.mit.edu). It allows students to create animations, games, and interactive art through programming using a computer mouse. The instructions (or code pieces) can be represented as puzzle pieces that only fit one below the other if they are syntactically correct (Malan & Leitner, 2007). Scratch is proposed to be a first language for beginners in introductory courses. It was designed to be user friendly, for all ages, backgrounds, and interests. By using Scratch, students are encouraged to program their own interactive stories, video games, animations, and simulations, and are able to then share their creations with others (Resnick, Maloney, Rusk, & Kafai, 2009). Scratch shows several advantages for introductory programming courses for freshmen students. It allows the instructor and the users to avoid syntax issues (e.g., semicolon use), and thus, allows them to focus on fundamental programmatic constructs (e.g., conditions, loops, variables). Scratch is able to run as a virtual machine in Linux, Mac OS, UNIX, and Windows. It has a version for kids (called Scratch Junior) and offers a great amount of pedagogical material online for free (Malan & Leitner, 2007). In general, most of the students (76%) that are exposed to Scratch, claim a positive influence on their subsequent experiences with specialized languages such as Java (Resnick et al., 2009).
Python is a high-level scripting language designed by Guido van Rossum to facilitate learning (van Rossum, 1999). Van Rossum suggested that any student could become an expert in programming by using python. The use of Python as a starting programming language, allows novice students to get easily involved into the main characteristics of CT (e.g., solving problems and thinking algorithmically (Grandell et al., 2006). This is mainly due to (a) the small, intuitive and clean syntax used in Python compared with languages such as Java or C++; (b) the dynamic typing (variables do not need to be declared) which reduces the notation; (c) the immediate feedback of potential errors; (d) the enforced structural design that leads the programmer to an indented and structured way of writing; (e) and finally, Python is a free and widely used language that comes with a specially designed text editor, tutorials, books, course material, exercises, and assignments available on the Web.
Real life experiences: LEGO® and LEGO® Mindstorms robot
According to Hood and Hood (2005), the use of LEGO® bricks is a powerful method for teaching programming and language concepts. The combination of colors and positions help indicate specific actions that lead to the learning and development of a set of sequenced instructions, algorithmic thinking, and problem-solving strategies, all, critical skills in CT. Moreover, whereas the LEGO® brick approach does not directly involve technology, it allows the participation of a more inclusive audience given that it evades the intimidation related to the use of computers (LEGO Dacta A/S, 2007). Another advantage of using LEGO® bricks to teach programming, is that a base plate and different-shaped LEGO® blocks are easily acquired. A knowledgeable instructor can design multiple exercises and provide clear instructions by using a single base plate for each participating student or team (Hood & Hood, 2005).
The educational robots of the LEGO Company (LEGO Mindstorms “LM”; http://mindstorms.lego.com/) have been broadly used for introducing programming to novice students (Dagdielis, Sartatzemi, & Kagani, 2005; Hussain, Lindh, & Shukur, 2006; LEGO & A/S, 2007). This approach is inspired on the Constructionism learning theory (Papert, 1993), where students are able to construct the knowledge for themselves. Lego Mindstorms are easily programmable robots that contain a broad variety of bricks, sensors, and motors. These robots can be programmed by using proper software environments to execute different kinds of orders, and most importantly, to react to different stimuli received through their sensors (Atmatzidou, Markelis, & Demetriadis, 2008). By using these educational robots, students learn by playing, creating new knowledge based on a preexisting one (Hussain et al., 2006; LEGO Dacta A/S, 2007).
There are several advantages correlated to the use of LM in introductory programming courses. By using the LM educational robots, students learn through direct observation of their robots operating and interacting in the real world. Students can see when they have made a mistake given that the robot may fall off from a table, crash into a wall, or not interact with environmental conditions. This stimulates them to create robust, expanded, complete, and correct programming, and to invest a huge amount of time debugging programs (Lawhead, Bland, & Schep, 2003). Furthermore, the use of LM robots reduces the fear factor of using computers even if the student had had no previous exposure to playing with LEGO® bricks as a child (Lawhead et al., 2003). Huang, Yang, and Cheng (2013) showed that students who used LM to design and build an artifact as a mean to learn basic concepts, performed better in standardized programming tests in comparison with students who learned using standard methods such as flowcharts. Atmatzidou et al. (2008) stated that the engagement of children during a course that used LM educational robots greatly contributed to the understanding of programming concepts (such as counter, flag, repetition), leading to the familiarization of structured programming principles.
Virtual life experiences: Game-programming
Video games have been widely used in introductory programming courses as an engaging tool to teach computer science, graphics, software engineering, and network topics (Al-Bow, Austin, & Meyer, 2009). Researchers and educators at schools are confident that this tool can be very helpful in the immersion of novices into programming (Rodger, Hayes, Lezing, & Slater, 2009). As Al-Bow et al. (2009) highlighted, the number of papers suggesting the use of video games in introductory programming courses is quite large as it can be further noted in recent proceedings of conferences such as ACM SIGGRAPH Sandbox, Future Play, Conference on Game Development in Computer Science Education, and Foundations of Digital Games.
An example of video game programming is Alice (Conway, Audia, Burnette, & Christiansen, 2000). This educational software uses an innovative programming environment to create 3D animations using drag-and-drop programming as well as a language that is closely related to objects in Java. In this software, each property, method, and function is attached to an object, with the world being the global object. A variation of Alice, known as Storytelling Alice was created by Caitlin Keller (Kelleher et al., 2007) to encourage middle school students, in particular middle school girls, to learn programming through the creation of short 3D animated movies. Students are able to better understand a variety of programming concepts (e.g., abstraction, modeling, control structures, handlers) by using Alice to make games (Werner, Campe, & Denner, 2012) and stories (Kelleher et al., 2007).
A second example of video gaming as an introductory strategy to programming is the Greenfoot environment (www.greenfoot.org). This visual and interactive software has been specially designed to be simple and easy to use for beginners. Greenfoot includes tutorials that provide the necessary Java concepts (such as inheritance, abstraction, and data binding) to create 2D games (Greenfoot Team, 2009). In a summer camp organized for 14- and 15-year-old students (supported by the NSF and Electronic Arts®), the use of computer games such as Greenfoot was used to integrate computer science and art design instruction through a project-based model methodology. This approach, led to a significant improvement in self-confidence and computer programming knowledge (Al-Bow et al., 2009).
A third example of an educational gaming environment for teaching and learning programming is Pex4Fun (from Microsoft Research; http://www.pexforfun.com/). This web-based tool, allows students to edit code in any browser, to create or manipulate games, and then execute and analyze the game in the cloud (Tillmann & de Halleux, 2011). Pex4Fun is able to find interesting and unexpected input values that help students understand what the code is actually executing. This educational gaming environment, permits a connection between teachers and students by tracking and streaming progress updates in real time. Pex4Fun has been used to teach and learn software engineering from high school all the way through graduate school courses (Tillmann & de Halleux, 2011).
The last example for video gaming learning is the Hour of Code. Code.org® is a nonprofit organization launched in 2013, and Hour of Code was created in collaboration with engineers from Microsoft, Google, Twitter, and Facebook. The Hour of Code web page was created with the goal of increasing computer science in schools as well as encouraging participation of women and underrepresented students of color in this discipline of study (Code.org®, 2013). The strategy is based on learning basic coding principles through gameplay, using an extensive set of tutorials (called the hour of code) containing practice exercises, lectures, and videos designed by technologists including Bill Gates and Mark Zuckerberg, and artwork from popular games like Angry Birds (Rovio) and Plants vs. Zombies (PopCap Game). According to the creators, more than 10 million people have tried the hour of code (48% female). Among the surveyed teachers who have signed up to teach the intro courses, 99% (almost 115,000) recommend implementing the website resources into computer science curricula (Code.org®, 2013). Last, one additional advantage is that tutorials can be implemented online, using a smartphone with or without Internet connection, and free of charge.
Current Status of Teaching Programming in Schools Worldwide
We have identified three main categories to describe the situation of teaching programming in different countries. These categories are (a) countries where programming is taught as a core course within computer science based on a national curriculum; (b) countries where programming is taught as a tool related to ICT, but major changes are on the way; and (c) countries where programming is taught as a tool merely related to ICT.
Countries where programming is taught as a core course within computer science
According to Diagiene, Jevsikova, Schulte, Sentance, and Thota (2013), Germany and Israel are the countries where a strong curriculum in computer science (CS) is well established. This curriculum includes problem solving, programming, as well as other skills related to CT. In primary and secondary schools in Germany, students are exposed to robotics and HTML as an introduction to the main topics related to CS in parallel with a strong focus on privacy and ethics. High schools in Germany place a strong emphasis on computer programming and computational theory to develop higher skills related to CS.
Israel on the other hand, has developed and implemented a model for a high school CS education program based in four pillars: (a) National CS curriculum and syllabus, (b) Research in CS education, (c) CS teacher preparation programs, and (d) Mandatory CS teaching license (Hazzan, Gal-Ezer, & Blum, 2008). Moreover, students interested in CS take five modules over a 2- to 3-year period, which includes (a) Fundamentals 1 and 2 that introduce central concepts in algorithmic thinking and how to apply them in programming; (b) software design that introduces data structures, abstract data structures, and designs of complete systems; (c) second paradigm that introduces object-oriented languages, programming logic, or functional programming; (d) applications that are focused on computer graphics, management information systems, or Internet programming; and (e) theory that exposes the students to selected topics in theoretical CS such as models of computation and finite automata. Additionally, in both countries, there is a strong focus on teacher training, ranging from CS bachelor degrees to extensive pedagogical training certified by the Ministry of Education of each country.
Countries where programming is taught as a tool for the information and communications technology field, but major changes are on the way
There are several countries in which programming has been taught for an extensive period of time (5 to 20 years) as part of a program where students are exposed mainly to the syntaxes of a specific programming language with no clear intention in developing skills related to CT. However, thanks to the efforts of the CS teacher’s associations and other individuals related to the computer science field, major changes will become visible in the upcoming future (Jones, 2011). The CS associations in the United Kingdom (http://www.computingatschool.org.uk), the United States (http://www.csta.acm.org), and France (http://www.academie-sciences.fr) have been working on promoting and highlighting the importance of teaching programming as a core course in schools.
The Computing At School (CAS) association in the UK released a document (Jones et al., 2013) where they present a review of the CS/ICT curriculum. Several suggestions related to teaching CS, teacher training, and implementation were proposed in view of changing the way how CS is being taught in schools throughout the UK. Moreover, a national curriculum has been proposed in 2013 with the aim of ensuring that students in the UK would be able to understand and apply logic and algorithmic thinking, data representation, and communication as well as analyze and solve problems, and evaluate and apply information technology. This curriculum is under revision at the moment and will hopefully be implemented in the near future (Jones et al., 2013).
In the United States, major events have happened in the past 5 years. The National Science Foundation (NSF) has launched a program called computing education for the 21st century. Numerous companies and associations including the Association for Computing Machinery (ACM), Microsoft, Google, Facebook, Twitter, and other partners have developed a coalition called Computing in the Core with the aim of promoting research in CS teaching. Furthermore, they have developed a platform to attract children into programming and CS in general (Stephenson & Wilson, 2012). The Computer Science Teacher Association (CSTA; 2011) has released a revised K-12 CS standards focused on algorithmic and CT concepts.
In France, the French Academy of Sciences released a report in 2013 (French Academy of Sciences, 2013) claiming that a full review of the ICT/CS curriculum has been made with the support of the government. This ICT/CS curriculum for primary, middle, and high school, aims to achieve a competitive task force in the future. Briefly, students from primary school are dedicated to develop skills related to CT by using appropriate programming languages for their age. This allows them to discover by themselves the main features of algorithmic thinking and problem solving. Later, students from middle school are encouraged to acquire specific concepts related to programming (i.e., syntax) as well as to solve problems on their own, by combining topics in science with programming skills to perform specific tasks. Finally, students in high school work in the strengthening of concepts learned in the earlier two stages, offering the opportunity to introduce advance constructions such as functions, recursion, dynamic allocation, types of data and objects, and parallelism.
In countries such as Finland, Canada, Scotland, Singapore, South Korea, Japan, Greece, and India, there are curricula that include concepts related to CT and ICT. However, the creation of updated drafts of curricula that intend to include learning of CT skills through programming are on the way with the purpose of increasing the number of students in STEM disciplines (Jones, 2011; Sturman & Sizmur, 2011).
Countries where programming is taught as a tool merely related to the information and communications technology
Due to the lack of well-documented information and well-established associations in countries not mentioned above, it is not unreasonable to assume that most countries are dealing with a situation very similar to that of New Zealand and most countries in Latin America (Jones, 2011). In these countries, computing in school curricula is often ignored, probably due to the fact that computers are used as a tool for teaching (e.g., for web browsing), for general applications related to ICT (e.g., use of Microsoft office), or as a discipline without clear guidelines or purposes regarding CT skills (e.g., learning the syntax of a specific programming language (Jones, 2011).
In Colombia, there are no clear guidelines provided by the government related to CT or CS. Most of the guidelines related to technology focus on the creation of passive users of technology, where students are exposed to a handful of applications with no clear purpose with regard to the development of skills. However, in some private schools, minor changes are occurring. In the last Technology for Education meeting held in Colombia (http://csfr.edu.co/index.php/teb-innovation-time-2015/), besides discussing tools for teaching ICT, some private schools expressed that they have been teaching programming for a while with the purpose of introducing CT skills. Moreover, they spoke about issues related to algorithmic thinking, problem solving, debugging, and other thinking skills. This has motivated them to reevaluate the curricula and to think about ways in which programming is being taught. A couple of schools expressed their intentions of including CS as an official course within their curricula to develop skills associated to CT.
Furthermore, some organizations such as Eduteka (www.eduteka.org) are working on initiatives to expose children to CS and CT. This nonprofit organization, teaches programming via Scratch (Malan & Leitner, 2007) by using mental maps and Venn diagrams. Eduteka also works on strategies to increase the number or girls interested in programming. Another organization from Universidad Nacional de Colombia, developed ProBot (Moreno & Montaño, 2009), a videogame-like application with the purpose of motivating students and engaging them in programming via a boxing-contest environment. Finally, the educational section of RoboCol (an organization in the Department of Engineering of Universidad de los Andes focused on the design and construction of robots for contests; https://robocol.uniandes.edu.co/) teaches programming to kids in elementary schools using the robots of Lego Mindstorms®.
Discussion
It is clear that computers are present in all areas of society, creating an important link between the world’s economy and technology and innovation. The impact of CS on multiple fields within the industry, science, communications, humanities, and society in general is becoming more important. Hence, it is crucial to educate our students not only in the passive understanding and application of digital technology but also to teach them the most important principles of how computers work. In other words, we believe that students should learn the key foundations of CS, given that the skills related to CT could be very helpful in any career at any stage.
However, in order to achieve these goals, the teaching and learning of CS must be centered and focused around CT. The development of skills related to CT such as algorithmic thinking, logic, abstraction, problem solving, debugging, among others, should be the fundamental purpose of CS courses. Moreover, it is important to recall that CS means more than solely learning to program in a specific language, such as Java or C++. Even if programming is central in computing and CS, programming must be taught in light of the development of skills related to CT, instead of a passive use of syntax.
Taking into account all the interventions, points of view, and reports analyzed in this review, it is clear that there are several issues for novice students participating in introductory courses in CS and programming. Despite the different strategies implemented to support these novice students (ranging from collaborative team works, peer tutors, pre-introductory programming courses, exercises and workshops, virtual platforms, virtual tutors, and forums, to changes in the grading system, programs, and curriculum) multiple adversities are still present when students are confronted to algorithmic thinking, logic, debugging, and problem solving; which in turn are the most important skills related to CT. Furthermore, these difficulties, in combination with the exhausting labor of learning syntax, generally leads to frustration, rejection, and poor visions of what programming is, driving most novices away from CS-related careers.
Consequently, as mentioned in several articles referenced in this review, we believe that skills related to CT must be taught at primary, middle, and high school, in order to initiate the cognitive development of students at an earlier age. CS should be recognized as a discrete subject in schools as is math, biology, or social studies. Numerous strategies and initiatives that seek to facilitate the learning and teaching of CT in schools have been developed and put into practice during the last decade. Most of these initiatives aim to replace current practices that use technology in a passive way.
Future Directions
It is important to mention that there is a critical gap in terms of educational research focused on teaching and learning CS and programming. Despite the significant number of articles written by computer scientists that investigate issues related to teaching and learning CS and programming, research conducted by experts in the field of education are almost nonexistent in most countries. Because social and cultural factors have a direct impact in learning, they must be taken into account in curricula design. Thus, constructivist, sociocultural, and pedagogical approaches are needed to create curricula that are geared toward the development of CT skills in primary, middle, and high school. These skills will, without a doubt, be fundamental for the vast majority of jobs in the 21st century.
Footnotes
Authors
FRANCISCO BUITRAGO FLÓREZ obtained his bachelor’s degree in microbiology from Universidad de los Andes in 2010. He then earned a master’s degree in biological sciences with an emphasis in bioinformatics in 2012. He worked as a school teacher for 4 years and is now pursuing a doctoral degree in education at the Center for Research and Training in Education, Universidad de los Andes, Carrera 1A # 18A-12, Bogota, Colombia; email:
RUBBY CASALLAS obtained her PhD from the Université de Grenoble (Scientifique et Medicale–Joseph Fourier) on informatics where she worked on Historical Objects and Annotation for Software Engineering Environments. She currently works as a full professor at the Systems and Computing Engineering Department, Universidad de los Andes, Carrera 1A # 18A-12, Bogota, Colombia; email:
MARCELA HERNÁNDEZ earned her PhD from the Institut National des Sceinces Appliquées de Lyon on images and systems. She currently works as a full professor at the Systems and Computing Engineering Department, Universidad de los Andes, Carrera 1A # 18A-12, Bogota, Colombia; email:
ALEJANDRO REYES earned his PhD degree in computational and systems biology from Washington University in Saint Louis, where he worked on metagenomic analyses of the human gut virome. He is currently working as an assistant professor at the Department of Biological Sciences, Universidad de los Andes, Carrera 1A # 18A-12, Bogota, Colombia; email:
SILVIA RESTREPO is the vice-president for research at Universidad de los Andes. She is a full professor in the Department of Biological Sciences, Carrera 1A # 18A-12, Bogota, Colombia; email:
GIOVANNA DANIES obtained her PhD from Cornell University (Ithaca, New York) in plant pathology. She currently works as a postdoctoral researcher at the Department of Biological Sciences, Universidad de los Andes, Carrera 1A # 18A-12, Bogota, Colombia; email: