Search

ABSTRACTBackground and ContextAuto-graders are praised by novice students learning to program, as they provide them with automatic feedback about their problem-solving process. However, some students often make random changes when they have errors in their code, without engaging in deliberate thinking about the cause of the error.ObjectiveTo investigate whether requiring students using an auto-grading system to reflect on the errors in their code would reduce trial and error behavior often seen in such systems.MethodThe paper analyzes the impact of reflection per student and per problem using paired t-tests.FindingsStudents took fewer steps to solve the problem in reflective sessions than in Usual Debugging Sessions (4.33 vs 8.04) and they made half as many syntax errors, logic errors, and runtime errors. However, they took more time between runs.ImplicationsThis paper provides evidence that requiring reflection in autograding systems can improve student debugging skills.

ABSTRACTBackground and ContextHour of Code is one of the largest educational campaigns implemented. It exposes millions of learners, to an hour of computer science fundamentals. With such a large impact, a large number of research articles have been published on the topic. This research ranges from reports of experiments testing the efficacy of Hour of Code and analysis of learner behavior, to reports of participation and suggestions for facilitating.ObjectiveThe goal of this work is to determine the effects of Hour of Code on Computer Science education.MethodArticles in IEEE Xplore, ACM, EBSCO, ERIC, and Google Scholar that include “Hour of Code” were identified. Papers with “Hour of Code” as an emphasis of the research design or exploratory effort were analyzed.FindingsSystematic review identified 64 papers which were sorted into six categories. Papers focused on overall participation numbers to novel Hour of Code Activities and research using Hour of Code data.ImplicationsAnalysis of these articles provides detail into the impact of Hour of Code on participants and influences resources for researchers. However, many questions remain to understand how Hour of Code can improve to meet its goals, expanding access to computer science to all students.

ABSTRACTBackground and ContextSince the surge of grounded cognition (GC) theories in cognitive psychology, many studies have focused on demonstrating the importance of embodiment and sensorimotor activities on students’ conceptual development. In computing education, however, there is not yet a conceptual framework for developing age-appropriate.ObjectiveThis paper brings these sets of work together, showing how the wider grounded cognition literature can be of value to computing education. The main objective of the paper is to suggest and set the theoretical foundations of a model for conceptual development in the early years of computing education.MethodThe paper is a conceptual paper and thus, it is based on an extensive account of relevant cognitive psychology and education literature.FindingsThe paper presents a model for conceptual development (EIFFEL -Enacted Instrumented Formal Framework for Early Learning in Computing). The general premise underlying the model is that programming concepts are first realised as actions performed on objects; as such, it aims to describe children’s conceptual development in computing from their first actions on concrete objects to entirely abstract forms of action representation epitomised by a program.ImplicationsThe model constitutes the first attempt to theorise conceptual development in the early years of computing education; as such it is expected to be used for the design of learning trajectories that progressively advance children’s conceptualisations from concrete, situated and multi-modal to formal and more abstract representations.

ABSTRACTBackground and ContextAssessing team members’ indivdiual contributions to software development projects poses a key problem for computing instructors. While instructors typically rely on subjective assessments, objective assessments could provide a more robust picture. To explore this possibility, In a 2020 paper, Buffardi presented a correlational analysis of objective metrics and subjective metrics in an advanced software engineering project course (n= 41 students and 10 teams), finding only two significant correlations.ObjectiveTo explore the robustness of Buffardi’s findings and gain further insight, we conducted a larger scale replication of the Buffardi study (n= 118 students and 25 teams) in three courses at three institutions.MethodWe collected the same data as in the Buffardi study and computed the same measures from those data. We replicated Buffardi’s exploratory, correlational and regression analyses of objective and subjective measures.FindingsWhile replicating four of Buffardi’s five significant correlational findings and partially replicating the findings of Buffardi’s regression analyses, our results go beyond those of Buffardi by identifying eight additional significant correlations.ImplicationsIn contrast to Buffardi’s study, our larger scale study suggests that subjective and objective measures of individual performance in team software development projects can be fruitfully combined to provide consistent and complementary assessments of individual performance.

Through a cross-disciplinary approach, two researchers solved the problem of poorly written term papers in the computer science curriculum. Using software engineering techniques, students produced focused, well-organized, well-formatted papers, some of publishable quality. The three-step assignment taught time and research management, organization, and accepted formatting style. The researchers developed supplemental materials to help students create and then assess their work. Any Computer Science teacher at any university level can use the material if a Writing Across the Curriculum (WAC) program exists or if the instructor has sufficient rhetorical skills.

Computer programming students need to develop an early awareness of execution time considerations. All decisions related to selection of data structures and construction of code should account for timing, yet students have few intellectual tools adequate for the task. This paper provides a simple methodology that enables college freshmen to model programs and derive bounds for their execution times. The methodology begins with a study of the program of interest and the construction of a model of its control structure. Then the syntactic parse of the model, using seven rules given in the paper, generates as a side effect the bounding time formula for the original program. Several examples are included to demonstrate the method.

Core computer science is about virtual machines, whereas computer applications and robotics are about the real world. The hypothesis that we will pursue in this paper is that real-world autonomous robots provide a tool that enables us to learn about how to design intelligent computer systems for the real world. They can teach us many powerful ideas about intelligence and computer systems in general. We will show a number of case studies illustrating how complex behaviors can be achieved by very simple mechanisms (e.g. how robots can clean up without knowing about it), and how robots learn to form concepts about the real world depending on how they are built. We also show how intelligence does not require central control and how the real world is not something to fight against, but something to live with and to exploit beneficially. We discuss how real-world autonomous agents can be used to teach an interdisciplinary audience. Finally, we discuss potential ways in which ideas like the ones developed in this paper might eventually change computer science.

The Young Scholars Program at the Institute for Systems Research of the University of Maryland at College Park is an innovative summer research experience for high school students from Maryland, Virginia, and Washington D.C. Its goal is to steer talented high school seniors toward higher education and careers in science and engineering. One particularly popular component of this program is a two-week mini-coursein robotics. This course utilizes the resources of the Intelligent Servosystems Laboratory of the university to introduce and demonstrate theoretical and practical aspects of robotics. This paper reports on the characteristics that make this a unique effort in robotics-related education for both the Young Scholars Program participants and the small group of University of Maryland graduate students who have been responsible for the development and instruction of this course.

For several years business and industry have recognized serious problems associated with software development. These problems have collectively been referred to as "The Software Crisis" (Pressman, 1987). This crisis is most characterized by problems of software planners to project accurate schedules and reliable cost estimates. It is now widely accepted that applying an engineering approach significantly reduces software development problems. This method includes using standardized management techniques in conjunction with technical tools to improve the development, testing, and maintenance of software. This paper will present a method of incorporating a unified presentation of software engineering techniques in several computer science courses in the undergraduate curriculum.

When a liberal arts college decides to include computer science as one of its academic disciplines, a number of questions arise. What is an appropriate curriculum? What sort of laboratory support does this new discipline need? How does a small liberal arts school attract, retain, and evaluate faculty in this area? Do computer science faculty become a separate department or remain joined with mathematics or some other discipline? In short, what must be done to put computer science on equal footing with mathematics and other scientific disciplines? This paper addresses these questions.

This paper discusses the teaching of computer science and engineering in the laboratory. A case is made for the use of laboratory experiences together with the classification of the types of laboratories both in and out of the university environment. Emphasis is placed on the design component. The current problems in establishing, developing, and maintaining laboratory programs are addressed and the response to these from the IEEE Computer Society and the ACM are presented. Typical costs are given to set up the components of a laboratory program for a full curriculum.

This paper describes a research project that was designed to provide a group of bright undergraduate students with a meaningful research experience that would encourage and motivate them to attend graduate school for further education and research. The project illustrated basic research techniques and the nature of the job of a researcher to undergraduates who had had limited or no opportunities for research. The students were involved in all phases of the project to ensure that they would gain the confidence needed to do research on their own. In this project the students were given an opportunity to do research that involved parallel processing.

This paper describes a microcomputer interfacing course for computer science students. Students build simple logic circuits to interface a microcomputer with real-world devices, such as stepper motor and digital displays, and program the computer to monitor and control these devices. Programs are written in Pascal and assembly language. The emphasis is placed on applications rather than on theory. This course is especially designed for computer science students who are proficient in software programming but have little or no experience in electronics. The experiments described here have been developed on the Apple ft microcomputer, but they can be easily adapted to other microcomputers.

This paper describes the successful integration of statistics and computer science in a course that combines topics from "Survey of Computer Languages" and from "Applied Statistical Modeling." The benefit to the computer science half of the course is that computer concepts, which are often illustrated in simplified or clean cases, are demonstrated in very sophisticated, yet highly useful settings. The benefit to the statistical portion of the course is that it allows the use of methods that are conceptually related but algorithmically disparate.

In this paper we describe a system for visualizing correctness proofs of graph algorithms. The system has been demonstrated for a greedy algorithm, Prim's algorithm for finding a minimum spanning tree of an undirected, weighted graph. We believe that our system is particularly appropriate for greedy algorithms, though much of what we discuss can guide visualization of proofs in other contexts. While an example is not a proof, our system provides concrete examples to illustrate the operation of the algorithm. These examples can be referred to by the user interactively and alternatively with the visualization of the proof where the general case is portrayed abstractly.

We teach students to become researchers through a kind of apprenticeship. Experienced researchers take graduate students under their wing and tutor them individually on how to do research: a slow and somewhat erratic procedure. This article describes a course that is designed to accelerate the process by imparting professional research skills. It has been taught for three years to incoming graduate students, and includes seminars by experienced researchers, presentations by students in the class, and lectures and discussions on topics that relate to particular research skills. Strong emphasis is placed on the critical analysis and evaluation of research ideas, and students practice by writing reviews, presenting papers, and constructing a thesis proposal.

Students drop out of university courses for a multitude of reasons. Whatever the cause, the costs of an unsuccessful attempt to complete a course are significant to student and university alike. This paper examines student attrition in computer science classes with the hope of identifying common causes and ultimately reducing the number of students dropping computer science courses. Survey data were analyzed to determine if reasons for dropping differed for various groupings of students including undergraduate/graduate, male/female, computer science major/non-major, and service/non-service courses.

Independent of the content and placement of the discrete mathematics course in the computer science curriculum, a common goal is to improve the students' ability to read and communicate mathematical or technical material. This paper describes a teaching format for the discrete mathematics course that fosters this goal. Instead of lecturing, the instructor responds to questions and asks questions over material the students have read. In periodic problem sessions, student groups polish and present problem solutions for the rest of the class to critique. This approach not only improves the technical reading and communication skills of the students, but involves students more actively in the total learning process.

I have discovered that, by giving my students quizzes at the end of each class, I can noticeably improve their learning without having to improve my teaching. In this paper, I want to discuss how this "discovery" might be used by others, how it might be studied scientifically, and how it might be developed into a well engineered teaching tool. I want to suggest that developing simple, well engineered, educational tools might be a worthwhile goal for those who want to try to improve computer science education.

Current research stresses that the success or failure of a new system depends on the education and training that users receive. Implicit in these findings is the warning that automation without appropriate education will lead to chaos. This paper reports the development of a plan to educate managers to fully utilize new computer systems and to recognize the potential of automation.The plan is unique in that it is a cooperative endeavor between a major university and a large government agency. The motivation for providing the education is first presented by reviewing current literature that addresses reasons to educate; who should educate, and what education and training should be conducted to ensure success.The curriculum guidelines, developed by the government agency, were specifically stated, and the joint curriculum reconciled these guidelines with normative goals for curriculum development. This was accomplished through close cooperation between the two groups of participants.The article discusses the methodology employed to develop two course modules, emphasizing the separation of taste. Finally, comments are presented and related to the theoretical issues.

Open Systems are computing systems which are based on industry standards and nonproprietary multivendor components. As an increasing number of computing installations move away from single-vendor proprietary architectures to more and more open architectures, academic institutions are increasingly faced with the responsibility of appropriately introducing open systems concepts into the undergraduate curricula. Using funding from the National Science Foundation, an open systems computing laboratory was recently set up at the University of Michigan-Dearborn. The laboratory is based on the three most popular computing platforms today in the PC to Workstation range; namely IBM/PC, Macintosh, and Sun/UNIX. Supporting equipment include a postcript printer, a Novell network, a tape mass storage, and appropriate software and interfaces. A three credit-hour course titled Open Systems Computing was offered in Summer 1995 to computer science and computer engineering majors. The course utilized the laboratory fully. This paper describes the design and implementation of the laboratory. Initial experiences with the course and laboratory are also described. Student enthusiasm about the course and laboratory was much higher than anticipated. A side benefit of the course was the ability to introduce several contemporary computing-related topics which would have otherwise been omitted from the curriculum.

The cheap and powerful personal computer (PC) has become an important and efficient tool for supporting engineering education. In this paper a PC-based training module, AIROBOT,is presented. The purpose of this module is to provide a platform for students to develop and experiment with artificial intelligence techniques.The training module, AIROBOT,utilizes an electronic noughts and crosses game board which is interfaced to the Scorbot-ER VII robot and a PC. The development and implementation of the module are discussed. Two techniques developed by the students are presented to illustrate the utilization of the module. The first technique involves searching a game tree data structure. The learning involves the on-line generation of the game tree as the games are played. An evaluation function is used to facilitate the search. The other technique is based on the artificial neural network approach using the backpropagation paradigm. The structure of the neural networks, training and performances are presented. The PC-based training module has the potential to enhance the student understanding through the practical application of artificial intelligence. It is envisaged that similar modules can be easily integrated into most engineering undergraduate robotics courses.

This paper reports on experience with project courses, especially those concerning the design and construction of an autonomous aerial robot.Dealing with this complex application task in small teams, advanced students are coached by teaching assistants in state-of-the-art work in special fields of computer science.The task includes a high potential for motivation and is sufficiently complex for a large range of techniques required. Team-orientation is an important aspect; the students have to establish and coordinate various individual tasks.

The paper describes the organization and technical details of an undergraduate project that culminated at the IJCAI robot competition in August 1995. As part of the project, a team of five undergraduate students designed and built an autonomous minirobot that was able to detect cups and cans, pick them up, and bring them to the appropriate trash or recycling bin. The robot was named Walleye, the state fish of Minnesota that is known for its voracious appetite.The limited size of the memory and the limited speed of the microcontroller have dictated most of the design choices. Walleye was, by far, the cheapest of all the entries in the competition, and performed well obtaining the third place. More important, working on the project has been a tremendous educational experience for the students in the team.This project is part of a larger effort aimed at exposing undergraduate students to a variety of projects in robotics, computer vision, and 3D modeling. We have chosen these topics as the sources of projects because of their interdisciplinary nature and because they provide a wide variety of problems where system integration, communication, and cooperation are important, and where the "fun" of building and programming a robot is a highly motivating force for the learning process.

The phenomenon of control is an essential component of our everyday natural, social and artificial environment. Control-related concepts have become a central component of many core topics in modern technology education. However, evidence already collected shows that students have serious difficulties in transcending the phenomenal or behavioral understanding of a system's functioning, towards more formal definitions of the control process. In this paper we suggest a framework for the design of learning environments of control concepts and design skills. Two main paradigms are suggested as the conveyors of very different cognitive approaches to control: programmingor software oriented and designor hardware oriented paradigms. The control of a Lego robot is used to elaborate on the different paradigms, and an example of computer implementation of control using spreadsheet software -the spreadsheet-book metaphor for representing control- is presented in detail.

We report students' experiments with a small mobile robot Khepera developed in the Microcomputing Laboratory of Swiss Federal Institute of Technology (LAMI-EPFL). Khepera makes teaching of fuzzy-control theory easier and more compelling for students. In the experiments, reported in this paper, students learn how to implement a simple fuzzy control algorithm for obstacle avoidance. The students have to build a fuzzy controller step-by-step using software package LabVIEW. Although very simple, this experiment focuses on methodology required for building controllers based on fuzzy logic. It allows students to understand basic fuzzy logic concepts, the advantages and drawbacks of fuzzy controllers as well as the difficulties of their practical design.