Work in progress: Investigating the effects of pair-programming on students' behavior in an advanced computer programming course

These days, the conventional ways of teaching programming are not attractive to students. For instance, classical lecture and tutorial classes are not sufficient and provides only one-way learning environment. Most of the students nowadays prefer to have more engaging, fun, competitive, collaborative, and instant feedback learning environment. These elements can be achieved using gamification to increase students’ interest in computer programming courses. More specifically, we used three gamification techniques in one advanced programming course: pair-programming teaching technique to maintain collaboration between students, Kahoot! system to provide an interactive quizzes system and instance feedback, and finally we used Robocode platform to teach Object-Oriented programming concepts in a fun and competitive fashion. We believe that gamifying teaching and learning process has great potential to assist teachers and engage students in a new and challenging way. This paper presents an empirical study that was carried out in one advanced computer-programming course were the mentioned gamification techniques were applied. A subjective system evaluation revealed that the students appreciated the used techniques. The results also revealed that the students’ interest in computer programming were enhanced as well.

Our contention is that there now exists a considerable body of lab exercises that may be used in conjunction with introductory courses.There are fewer models available for instructors of more advanced programming courses, especially those courses which attempt tointroduce students to current practices in software engineering.In this paper, we report on our experiences in buiIding a second-year programming course that includes a significant lab and project component.These labs and projects are the vehicle we use to introduce students to the world of professional practice in software development.

This scoping review aims to comprehensively examine the current landscape of online formative assessment practices in programming courses. The objective is to gain insights into existing practices, emerging trends, challenges, and innovations in this area. To conduct this review, the authors followed established approaches for scoping reviews and identified relevant studies through a systematic search of academic databases. A diverse range of literature on online formative assessment in programming education was found, meeting the inclusion criteria which encompassed studies from various educational settings spanning introductory to advanced programming courses. This chapter examined different methods, tools, and strategies in online formative assessment and their impact on student engagement, motivation, and performance. The results demonstrate a variety of formative online assessment strategies, including automated feedback, coding assignments, peer assessment, and quizzes. This chapter provides insightful advice for improving online formative assessments used in programming courses.

Mobile devices have become fixtures of our everyday lives. As such, it is sensible to deploy them in the IT curriculum where they can help students attain their core competency in programming. Android has been adopted as the platform for an advanced programming course in which students are using Java (Android's native language) and XML to build apps. Many subtle issues and common pitfalls have been encountered when transitioning this programming course to Android apps from traditional Java programs. Gathered from over a year's experience teaching app development, these issues are discussed, and suggestions and tips beneficial to IT instructors and students for working with Android are presented. Overall, the issues dealt with range from setting up devices and emulators to subtleties in linking Java and XML to quirks of the Eclipse IDE. Accessing the Internet is also covered. Some additional benefits of Android development for the undergraduate IT curriculum are discussed.

This paper presents the partial results of an extended replicated pair programming experiment, conducted at the Alexander Technological Educational Institute of Thessaloniki, Greece during the two semesters of the year 2009-10. The entire study involved 160 second semester students attending a Software Engineering advanced programming course with pair programming and test-driven development as teaching methodology. A series of formal experiments were conducted to investigate, as in the first experiment, the impact of developer personalities and temperaments on pair performance. In this paper we report partial results and we focus on pair performance in terms of communication, time to complete assignments and overall score. The main variables were statistically analyzed in order to test differences between two personality groups: A control group with homogeneous personalities in pairs and an experimental one with heterogeneous personalities. The findings reported here concern only the first winter semester and confirm that pairs consisting of heterogeneous personalities and temperaments performed better than pairs with the same personality and temperament type. However, time to complete assignments was not statistically different between the two groups.

The computer science program in a liberal arts college must meet a number of diverse needs. When the curriculum allows for only four computer courses each course must serve several functions. For example, the introductory programming course often must satisfy the need for computer literacy as well as serve more advanced students who need to use the computer in their own discipline. The Hamilton College program which serves an academic community of 1600 students and about 130 faculty, has been evolving for four to five years. Currently five to six hundred students use the computer in some manner during the academic year, and almost one third of the student body enroll in a programming course before they graduate. We shall describe our two-course programming sequence and the success that we have had teaching it using a disciplined approach to programming. Our first course is taught to students whose primary motivation is general literacy and who do not bring to it much in the way of general quantitative or problem solving skills. We use, though, a programming methodology that differs little from that used by larger institutions for courses directed more toward the concentrator in computer science. We argue that structured programming is almost a necessity for this audience. The very limited background of the students requires both a systematic approach to problem solving and a disciplined style of programming. The second programming course must also solve some special problems. Since we only offer two advanced courses, we must include some of the material on data structures in the second course. With a careful selection of topics, we can lay the foundation for a discussion of file structures or data base organization in an advanced course. Our instructional goals for the sequence include the encouragement of general computer literacy, the teaching of programming techniques, the development of problem solving skills, and the coverage of selected advanced topics. We had to meet these goals without making excessive technical demands on the instructional staff.

Computer programming is an essential skill for today's engineers, and sustainability plays a role of growing interest in any of the design phases of an engineering project. The fundamentals of sustainability, with basic concepts such as "carbon intensity", must be covered in any engineering curriculum. We propose a basic computer programming course in which the lab sessions incorporate exercises related to the computation of environmental impacts. For instance, an exercise might request the computation of the carbon footprint of the lab sessions during a whole year. Lab sessions use an automatic evaluation server, so called Jutge.org that assesses about the correctness of the programs submitted by the students. New exercises concerning sustainability topics are included in the Jutge.org course. The course involves the effort of a multidisciplinary team. First, lecturers on basic programming are required. An expert on automatic evaluation of computer programs is essential to prepare the statements and the test sets of the proposed exercises. Finally, the advice of economists and sustainability experts is crucial to guarantee judicious conclusions are drawn from each exercise. Forming a team with this profile is a challenging task. Our Computer Science (CS) department lectures basic programming courses to more than 1700 students/year. The success of this approach could bring a substantial social impact in our ecosystem.

In this paper, we present the design of an advanced course on mobile embedded software, especially focused on programming for various embedded system applications. With the popularity of smartphone applications, there are numerous books and classes for smartphone programming. However, fast growing mobile technologies have led to a huge gap between advances in industry and university educational programs. Furthermore, trends in device convergence based on smartphones necessitate a broadened and diversified treatment of application domains such as automotive embedded systems and smart robots. Consequently, an advanced project course in mobile embedded software requires a complete redesign of its contents to meet these multiple goals. We describe our experience in redesigning an programming course to satisfy both the fundamental educational needs and industry trends. Based on the proposed design, we offered a successful course, CS 190: Mobile Embedded SW with Android at UC Irvine in Spring Quarter 2012, and describe our experience with the offering.

Massive Open Online Courses (MOOCs) have recently gained high popularity among various universities and even in global societies. A critical factor for their success in teaching and learning effectiveness is assignment grading. Traditional ways of assignment grading are not scalable and do not give timely or interactive feedback to students. To address these issues, we present an interactive-gaming-based teaching and learning platform called Pex4Fun. Pex4Fun is a browser-based teaching and learning environment targeting teachers and students for introductory to advanced programming or software engineering courses. At the core of the platform is an automated grading engine based on symbolic execution. In Pex4Fun, teachers can create virtual classrooms, customize existing courses, and publish new learning material including learning games. Pex4Fun was released to the public in June 2010 and since then the number of attempts made by users to solve games has reached over one million. Our work on Pex4Fun illustrates that a sophisticated software engineering technique -- automated test generation -- can be successfully used to underpin automatic grading in an online programming system that can scale to hundreds of thousands of users.

Recent research has demonstrated pair programming to be an effective model of collaborative learning for millennial students. However, much of the research describes the impact of pair programming in first-year programming courses. This paper highlights experiences using pair programming in an advanced web development programming course. Most of the students in the course were at the junior or senior level and had not been formally introduced to pair programming prior to taking the course. Qualitative data were collected through the use of written reports and surveys. The author discusses what was learned about the impact on students’ attitudes, learning and quality of work. Challenges are also described, as well as recommendations for enhancements.

In recent years, many schools have cut back on their teaching and laboratory hours, and courses in the anatomical sciences are more integrated into the horizontal and longitudinal curriculums. Traditionally, teaching in anatomical science classes consists of lectures and laboratory sessions. Usually, gross anatomy and histology are the two main courses in pre-matriculation programs. The summer pre-matriculation program at the University of Mississippi Medical Center (UMMC) was designed to better prepare students for success in their first year of medicine and dentistry. The course provided these students with an opportunity to study gross anatomy and histology ahead of time and develop their learning skills for the coming academic year. Historically, gross anatomy and histology courses have been taught separately with a different emphasis. We have designed a new approach to implement gross anatomy, histology, and pathology-all three disciplines-in a single lecture in the organ section of the histology course. This triple-discipline (triple lecture) approach allows three professors in anatomy, histology, and pathology to work together in a two-and-a-half-hour review lecture. This approach allows students to develop their critical thinking skills and better prepares them to transfer basic anatomic knowledge into their future clinical practice. Students indicated this was their first experience with the triple-discipline approach, and they remarked that it helped them integrate anatomy and histology as well as demonstrate the clinical importance of the structures and organs. This approach can be used at different stages of medical education and helps faculty and students better integrate various disciplines and is more suitable in the modern curriculum. A similar approach was used in our fourth year course in medical histology.

NOTE: The first page of text has been automatically extracted and included below in lieu of an abstract Using Programming Projects in an Operating Systems Course as a Capstone Software Engineering Experience Computer Engineering Technology students at the University of Dayton take two fundamental programming courses teaching the basics of algorithmic problem solving along with the VBA and C++ syntaxes. These courses develop a strong programming foundation for the students; however, they lack the ability to introduce software programming within larger software systems. The final course related to software development is a required operating systems course. This course contains three fundamental goals: to develop the students’ understanding of key operating system concepts, to increase the students’ software engineering capabilities, and to introduce the students to the internal workings of the Linux and Windows operating systems. The operating systems course relies heavily on software programming exercises as a key instrument in teaching students the framework and applications of modern operating systems. The unique aspect of this approach is that the programming projects are designed not as standalone activities, but instead as individual components of a larger software system. Therefore, each programming project focuses not just on learning new syntax related to operating system concepts, but also in how these concepts are relevant to the software system being developed. Students develop programs for both the Microsoft Windows and Linux operating systems, working heavily with their associated application programming interfaces and investigating processes, threads, synchronization, input and output, and scheduling issues. A complete course overview and synopsis of the software programming projects will be presented along with student performance and comments from an end of the semester survey. Introduction The Computer Engineering Technology (CET) Program at the University of Dayton (UD) was started in 1999 and included two software programming courses. These courses predominately focused on teaching the fundamentals of software programming and the syntax associated with the VBA and C++ languages. Likewise, to satisfy the ABET outcome requirements for computer engineering technology programs, the ETC Program at UD also required a new 3 credit lecture course entitled “Concepts & Applications of Operating Systems” to be taken during the students’ Junior year of study.1 This course was structured to provide students hands-on exposure to the internal workings of modern operating systems. During the 2004/2005 academic year, the material being taught in the software programming was evaluated. In accordance with the Computing Curricula 2001 (CC2001) report by the Computer Society of the Institute for Electrical and Electronic Engineers (IEEE-CS) and the Association for Computing Machinery (ACM), the two software programming courses being taught fell within the traditional imperative-first approach. This approach starts students off with software programming activities without any real preparations.2 After careful review, it was found that the student population being served needed to be taught the algorithmic thought process prior to the syntax as many of the students had no prior exposure to software programming and were struggling more with defining the problem solutions than with the specific syntax being taught.3 A modified algorithms-first approach from CC2001 report was applied to these courses. Instead

Programming courses become prominent as one of the courses in which undergraduate students are unsuccessful especially in departments which offer computer education. Students often state that these courses are quite difficult compared to other courses. Therefore, a qualitative phenomenological approach was used to reveal the reasons of the failures of the undergraduate students in programming courses and to examine the difficulties they confronted with programming. In this scope, the laboratory practices of the Internet Programming course were observed in fall term of the 2013-2014 academic year in a university at central Anatolia. Interviews were made with 12 undergraduate students taking this course. Finally, the difficulties students experienced in the programming were determined as programming knowledge, programming skills, understanding semantics of the program, and debugging. Students emphasized that the biggest causes of failure in programming languages are lack of practice, not using algorithms and lack of knowledge. In addition, it was seen that the students who had high programming experience possess higher programming success and self-efficacy related to programming

Compile-time errors pose a major learning hurdle for students of introductory programming courses. Compiler error messages, while accurate, are targeted at seasoned programmers, and seem cryptic to beginners. In this work, we address this problem of pedagogically-inspired program repair and report TRACER (Targeted RepAir of Compilation ERrors), a system for performing repairs on compilation errors, aimed at introductory programmers. TRACER invokes a novel combination of tools from programming language theory and deep learning and offers repairs that not only enable successful compilation, but repairs that are very close to those actually performed by students on similar errors. The ability to offer such targeted corrections, rather than just code that compiles, makes TRACER more relevant in offering real-time feedback to students in lab or tutorial sessions, as compared to existing works that merely offer a certain compilation success rate. In an evaluation on 4500 erroneous C programs written by students of a freshman year programming course, TRACER recommends a repair exactly matching the one expected by the student for 68% of the cases, and in 79.27% of the cases, produces a compilable repair. On a further set of 6971 programs that require errors to be fixed on multiple lines, TRACER enjoyed a success rate of 44% compared to the 27% success rate offered by the state-of-the-art technique DeepFix.

Block-C is a block-based programming learning tool for C programming language that uses the recognition over recall approach on top of the rigid and complex constructs of C language. It empowers students to learn programming by guiding them to focus on the programming logic rather than the syntax of C language. Novice programmers in introductory programming courses are more productive with the use of Block-C than with regular textual C programming. They can internalize the programming concepts more easily by gradually assigning meaning to the visual models (pertaining to the programming logic) created using the tool. In lab or tutorial sessions, where the presence of facilitators is limited, Block-C can guide the students to complete their assignments easily and effectively. Finally, Block-C promotes the transition to the regular textual C programming by allowing the students to export their code and see how their block-based programs are translated to textual C, but also how textual C is translated to block-based C.