Search

In this theory paper, we explore the concept of translanguaging from bilingual education, and its implications for teaching and learning programming and computing in especially computer science (CS...

Computer game development has been shown to be an effective hook for motivating students to learn both introductory and advanced computer science topics. While games can be made from scratch, to simplify the programming required game development often uses game engines that handle complicated or frequently used components of the game. These game engines present the opportunity to strengthen programming skills and expose students to a range of fundamental computer science topics. While educational efforts have been effective in using game engines to improve computer science education, there have been no published papers describing and evaluating students building a game engine from scratch as part of their course work. This paper presents the Dragonfly-approach in which students build a fully functional game engine from scratch and make a game using their engine as part of a junior-level course. Details on the programming projects are presented, as well as an evaluation of the results from two offerings th...

Advanced approaches to the construction of software systems can present difficulties to learners. This is true for multi-agent systems (MAS) which exhibit concurrency, non-determinacy of structure and composition and sometimes emergent behavior characteristics. Additional barriers exist for learners because mainstream MAS technology is young and design methodologies are still evolving. This paper considers the benefits and difficulties associated with teaching/learning agent technology and recommends an approach used by the authors. The paper examines Agent UML - a set of proposed extensions to UML to facilitate MAS design but suggests that simpler design tools are more appropriate for novice MAS programmers. A small suite of preferred tools are presented.

This paper is a summary of the pedagogical patterns project. The project started in 1996 with the aim of collecting and disseminating experiences of teaching and learning about object technology. We adopted a pattern format early on, although the specific format has evolved over time. In this paper we give an overall view of the project: where it started, how the material we have collected has evolved and matured, and where we need to go from here. More material from the project is available from our website www.pedagogicalpatterns.org, and our publications.

This paper examines the needs of students who, in the past, may have chosen to major in computer science or some other aspect of information technology as a way of achieving the goal of finding a job in the computer graphics field. The growth in computer graphics has lead to increased job opportunities in the industry. However, these jobs require fluency in both art and computing that an individual course or even a sequence of several courses cannot provide. In the past, there has been discussion of curricula for isolated graphics courses as part of a BS/CS degree, but industry demands more preparation than what one or two courses can deliver. This paper surveys and compares the two extant Bachelor of Science degrees in Computer Graphics with the intent of encouraging dialog on the possibility of a four-year curriculum supporting this discipline.

Computing has become highly visual as interactive programs become increasingly prevalent. Computer science students need to be able to create effective visual displays as part of interface implementation. This paper describes a course covering graphic design topics relevant to computer science students. In this course, students learn the basic visual elements, the visual organizational principles and how to use them in the context of the digital page. The other topics of this paper are the presentation of course information to the computer science student, the implementation of the course information as praxis, course project construction, and a method for critiquing student projects. Curriculum Integration will also be discussed as a feature towards achieving a seamless and collaborative experience.

The current educational climate provides both incentives and pressures to extend the use of information technology in university teaching. The computer science discipline is ideally placed to take a leading role in the development of technology-based teaching tools. In recent times the technological resources available for such initiatives have also taken a leap forward, not least with the release of the rapidly developing Java language. This paper reports on one such initiative—the development of a system for providing automatic feedback on computer science laboratory work and monitoring student progress. The paper outlines the goals of the system and shows that the collection of facilities afforded by the Java language provides a strong foundation for the development of software for securely analyzing student code.

This article explores the suitability of static analysis techniques based on the abstract syntax tree (AST) for the automated assessment of early/mid degree level programming. Focus is on fairness, timeliness and consistency of grades and feedback. Following investigation into manual marking practises, including a survey of markers, the assessment of 97 student Java programming submissions is automated using static analysis rules. Initially, no correlation between human provided marks and rule violations is found. This paper investigates why, and considers several improvements to the approaches used for applying static analysis rules. New methods for application are explored and the resulting technique is applied to a second exercise with 95 submissions. The results show a stronger positive correlation with manual assessment, whilst retaining advantages in terms of time cost, pedagogic advantages and instant feedback. This study provides insight into the differences between human assessment and st...

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.

Submitted by Christina Chavez (flach@ufba.br) on 2020-12-07T17:42:07Z No. of bitstreams: 1 preprint_CSE_2015-DeboraCoelho-journal.pdf: 846247 bytes, checksum: ceeb12b24683cb10b1345563f2b7e27e (MD5) Approved for entry into archive by Solange Rocha (soluny@gmail.com) on 2020-12-10T23:18:13Z (GMT) No. of bitstreams: 1 preprint_CSE_2015-DeboraCoelho-journal.pdf: 846247 bytes, checksum: ceeb12b24683cb10b1345563f2b7e27e (MD5) Made available in DSpace on 2020-12-10T23:18:13Z (GMT). No. of bitstreams: 1 preprint_CSE_2015-DeboraCoelho-journal.pdf: 846247 bytes, checksum: ceeb12b24683cb10b1345563f2b7e27e (MD5) Previous issue date: 2015-05-12 Context: It is common practice in academia to have students work with “toy” projects in software engineering (SE) courses. One way to make such courses more realistic and reduce the gap between academic courses and industry needs is getting students involved in open source projects (OSP) with faculty supervision. Objective: This study aims to summarize the literature on how OSP have been used to facilitate students’ learning of SE. Method: A systematic mapping study was undertaken by identifying, filtering and classifying primary studies using a predefined strategy. Results: 72 papers were selected and classified. The main results were: (a) most studies focused on comprehensive SE courses, although some dealt with specific areas; (b) the most prevalent approach was the traditional project method; (c) studies’ general goals were: learning SE concepts and principles by using OSP, learning open source software or both; (d) most studies tried out ideas in regular courses within the curriculum; (e) in general, students had to work with predefined projects; (f) there was a balance between approaches where instructors had either inside control or no control on the activities performed by students; (g) when learning was assessed, software artefacts, reports and presentations were the main instruments used by teachers, while surveys were widely used for students’ self-assessment; (h) most studies were published in the last seven years. Conclusions: The resulting map gives an overview of the existing initiatives in this context and shows gaps where further research can be pursued. London

This paper reports on a series of introductory programming workshops, initially targeting female high school students, which utilised Lego Mindstorms robots. Cognitive load theory (CLT) was applied to the instructional design of the workshops, and a controlled experiment was also conducted investigating aspects of the interface. Results indicated that a truncated interface led to better learning by novice programmers as measured by test performance by participants, as well as enhanced shifts in self-efficacy and lowered perception of difficulty. There was also a transfer effect to another programming environment (Alice). It is argued that the results indicate that for novice programmers, the mere presence on-screen of additional (redundant) entities acts as a form of tacit distraction, thus impeding learning. The utility of CLT to analyse, design and deliver aspects of computer programming environments and instructional materials is discussed.

Computer games have been accepted as an engaging and motivating tool in the computer science (CS) curriculum. However, designing and implementing a playable game is challenging, and is best done in advanced courses. Games for mobile devices, on the other hand, offer the advantage of being simpler and, thus, easier to program for lower level students. Learning context of mobile game development can be used to reinforce many core programming topics, such as loops, classes, and arrays. Furthermore, it can also be used to expose students in introductory computing courses to a wide range of advanced topics in order to illustrate that CS can be much more than coding. This paper describes the author’s experience with using mobile game development projects in CS I and II, how these projects were integrated into existing courses at several universities, and the lessons learned from this experience.

To design an effective computer science curriculum, educators require a systematic method of classifying the difficulty level of learning activities and assessment tasks. This is important for curriculum design and implementation and for communication between educators. Different educators must be able to use the method consistently, so that classified activities and assessments are comparable across the subjects of a degree, and, ideally, comparable across institutions. One widespread approach to supporting this is to write learning objects in terms of Bloom's Taxonomy. This, or other such classifications, is likely to be more effective if educators can use them consistently, in the way experts would use them. To this end, we present the design and evaluation of our online interactive web-based tutorial system, which can be configured and used to offer training in different classification schemes. We report on results from three evaluations. First, 17 computer science educators complete a tutorial on using Bloom's Taxonomy to classify programming examination questions. Second, 20 computer science educators complete a Neo-Piagetian tutorial. Third evaluation was a comparison of inter-rater reliability scores of computer science educators classifying programming questions using Bloom's Taxonomy, before and after taking our tutorial. Based on the results from these evaluations, we discuss the effectiveness of our tutorial system design for teaching computer science educators how to systematically and consistently classify programming examination questions. We also discuss the suitability of Bloom's Taxonomy and Neo-Piagetian theory for achieving this goal. The Bloom's and Neo-Piagetian tutorials are made available as a community resource. The contributions of this paper are the following: the tutorial system for learning classification schemes for the purpose of coding the difficulty of computing learning materials; its evaluation; new insights into the consistency that computing educators can achieve using Bloom; and first insights into the use of Neo-Piagetian theory by a group of classifiers. © 2013 Copyright Taylor and Francis Group, LLC.

This paper builds on previous research into teachers' conceptions of learning and teaching with an investigation of information technology academics. Using a phenomenographic approach to build a model of IT academics experiences and practice of teaching we aimed to identify any specific issues that academics in the IT discipline face and to assess the impact of the changing higher education environment on their teaching experiences. While there were few discipline-specific issues we did find that the current higher education environment appears to be negatively affecting the quality of teaching and learning within the IT discipline and indications are that these environmental factors are affecting academics within other disciplines. We concluded that current institutional policies, including teaching and learning quality measures and lack of resources, are compromising the way subjects are delivered. In some cases academics are discouraged from improving their teaching practice.

ion is a major concept in computer science and serves as a powerful tool in software development. Pattern-oriented instruction (POI) is a pedagogical approach that incorporates patterns in an introductory computer science course in order to structure the learning of algorithmic problem solving. This paper examines abstraction processes in the course of solving an algorithmic problem and highlights three distinct, although interrelated, facets of abstraction: pattern recognition, black-boxing, and structure identification. A study that examined the influence of the POI approach on students' abstraction skills is described; students who learned according to the POI approach were compared with students who learned in a traditional manner with regard to analogical reasoning and problem decomposition and solution, as well as verbal expression. The three facets of abstraction were used to analyze students' abstraction skills and their competency in algorithmic problem solving.

Debugging is often difficult and frustrating for novices. Yet because students typically debug outside the classroom and often in isolation, instructors rarely have the opportunity to closely observe students while they debug. This paper describes the details of an exploratory study of the debugging skills and behaviors of contemporary novice Java programmers. Based on a modified replication of Katz and Anderson's study of novices, we sought to broadly survey the modern landscape of novice debugging abilities. As such, this study reports general quantitative results and fills in the picture with qualitative detail from a relatively small, but varied sample. Comprehensive interviews involving both a programming and a debugging task, followed by a semi-structured interview and a questionnaire, were conducted with 21 CS2 students at seven colleges and universities. While many subjects successfully debugged a representative set of typical CS1 bugs, there was a great deal of variation in their success at the p...

A key challenge of effective teaching is assessing and monitoring the extent to which students have assimilated the material they were taught. Concept mapping is a methodology designed to model what students have learned. In effect, it seeks to produce graphical representations (called concept maps) of the concepts that are important to a given domain and how they are related, according to the students. In recent decades various methods have emerged to evaluate concept maps, each measuring different features of concept maps. New approaches are still being developed. Few guidelines are available regarding the method to choose for a given application. This paper is a literature review that consists of two parts. The first is a review of the many automated and manual techniques of concept map analysis. The second is a critical and reflective commentary on these techniques.

Students learn better when they both hear and do. In computer architecture courses “doing” can be difficult in small schools without hardware laboratories hosted by computer engineering, electrical engineering, or similar departments. Software solutions exist. Our success with George Mills' Multimedia Logic (MML) is the focus of this paper. MML provides a graphical computer architecture solution with convenient I/O support and the ability to build and emulate a variety of computer designs. It has proven highly motivational to upper division computer science students designing and constructing emulated computers. Student projects resulted in excellent student understanding of the detailed inner workings of computers. Students also developed better teamwork skills and produced useful training aids for the lower division computer organization class. Designs implemented include 8 bit and 16 bit von Neumann and Harvard architectures, from single cycle to 12 cycle instructions. Issues resolved during the learni...

In this paper, we present the results from a two-part study. We analyze 60 programs written by novice programmers aged 16 – 19 after their first programming course, in either Java or Python. The aim is to find difficulties independent of the language used, and such originating from the language. Second, we analyze the transition from a “simple” language to a more “advanced” one, by following up on eight students, who learned programming in Python before moving on to Java. Our results suggest that a simple language gives rise to fewer syntax errors as well as logic errors. The qualitative part of our study did not reveal any disadvantages from having learned to program in a simple language when moving on to a more complex one. This suggests that not only can a simple language be used when introducing programming as a general skill, but also when providing basic skills to future professionals in the field.

Design pattern creation, especially in the e-learning domain, is a highly complex process that has not been sufficiently studied and formalized. In this paper, we propose a systematic pattern development cycle, whose most important aspects focus on reverse engineering of existing systems in order to elicit features that are cross-validated through the use of appropriate, authentic scenarios. However, an iterative pattern process is proposed that takes advantage of multiple data sources, thus emphasizing a holistic view of the teaching – learning processes. The proposed schema of pattern mining has been extensively validated for Asynchronous Network Supported Collaborative Learning (ANSCL) systems, as well as for other types of tools in a variety of scenarios, with promising results.

A considerable amount of experiences in teaching object-oriented concepts using the Java language have been reported to date, some of which describe language pitfalls and concrete learning difficulties. In this paper, a number of additional issues that have been experienced as difficult for students to master, along with approaches intended to overcome them, are addressed. Concretely, practical issues regarding associations, interfaces, genericity and exceptions are described. These issues suggest that more emphasis is required on presenting Java programs as derivations of conceptual models, in order to guarantee that a thorough design of the object structure actually precedes implementation issues. In addition, common student misunderstandings about the uses of interfaces and exceptions point to the necessity of introducing both specific design philosophies and also a clear distinction between design-for-reuse and more specific implementation issues.

For beginning programmers, inadequate problem solving and planning skills are among the most salient of their weaknesses. In this paper, we test the efficacy of natural language tutoring to teach and scaffold acquisition of these skills. We describe ProPL (Pro-PELL), a dialogue-based intelligent tutoring system that elicits goal decompositions and program plans from students in natural language. The system uses a variety of tutoring tactics that leverage students' intuitive understandings of the problem, how it might be solved, and the underlying concepts of programming. We report the results of a small-scale evaluation comparing students who used ProPL with a control group who read the same content. Our primary findings are that students who received tutoring from ProPL seem to have developed an improved ability to solve the composition problem and displayed behaviors that suggest they were able to think at greater levels of abstraction than students in the read-only group.

Problem-Based Learning (PBL) method emphasizes students' own activity in learning about problems, setting up their own learning goals and actively searching for and analyzing information. In this paper, we describe and discuss our experiences on applying PBL, especially the seven steps method widely used in medical faculties, in an introductory computer programming course. We explain how the method is implemented, give examples and identify different kinds of PBL cases, and describe how the method is supplemented by other learning methods in our course. According to our experience, the PBL method increases the commitment of the students which results in a significantly lower drop-out rate: the average is 17% versus 45% in our traditional programming courses. In addition to computer programming, students also learn generic skills related to group work, collaborative design work, independent studying, and externalization of their knowledge.

This paper proposes an evaluation framework for assessing students' comprehension of concurrent programs. The need for such a framework is illustrated by a review of various Computer Science Education forums. This review suggests that there is little pedagogical research in the area of concurrent software, particularly with respect to assessing students' knowledge. In particular, the proposed framework attempts to categorize the types of information students seek and the types of information they obtain, as they learn about concurrent software. Thus the framework could be used to guide teaching methods in this area, to hone the representations used to portray concurrent software to students and subsequently, to assess students' performance.

Today, virtually all operating systems support multithreaded programming. In fact, threads are easier to use and more efficient than processes. This paper presents a possible way of using multithreaded programming to strengthen an operating systems course. More precisely, the lecture hours are divided into a theory track and a programming track. The former concentrates on the traditional topics, while the latter consists of seven programming assignments and one mini-project that can provide students with a comprehensive coverage of the use of multithreaded programming in the design of various operating system components. These assignments also serve as a vehicle for introducing interesting materials (e.g., PRAM models) that are normally not available in a typical operating systems course.

This paper presents CCL, a programming language designed for implementation efforts and laboratory projects in compilers courses for undergraduates. CCL is small, cohesive, and regular enough that a working compiler can be implemented by an individual student in a single semester; yet, CCL includes a collection of features (including pointers, dynamically-sized arrays, anonymous functions, and a restricted form of continuations) that make it a useful vehicle for studying compiler theory and design. Experiences using CCL in compilers courses are discussed, and suggestions for a number of projects concerning CCL are given.

Robust communication protocols are essential components in every telecommunication system. Formal methods are used in the protocol engineering process to cope with the complexity of distributed protocol systems. In this article the use of the formal description technique SDL (Specification and Description Language) in the context of education in protocol engineering is presented and evaluated. After a comprehensive overview of a laboratory course on protocol engineering using SDL, the paper presents a case study, which is the final and largest exercise of the course. This example is based on the SDL description of the ISDN signaling protocol Q.931. The well-known functionality of the protocol makes it a good example for the use of SDL in protocol design and development. The case study also deals with the integration of SDL-defined systems in an external environment, in this case a Tcl/Tk-based graphical user interface. The article concludes with a report on the experiences gained from our educational acti...

This paper describes the delivery of a computer networks course with accompanying materials and software. The course is offered at the fourth-year undergraduate level, and has few formal pre-requisites, other than general programming skills. There is a substantial architectural and coding component to any practical course on networks, and it is important to challenge the experienced and knowledgeable students without making the material too difficult for the inexperienced students who have minimal experience in programming practical applications. Some students have an industrial background and are expecting to build practical working applications. At the other extreme are students with no exposure to operating system principles, and therefore lacking pertinent knowledge, such as concurrency concepts. Our programming framework provides an event-polling approach to avoid the complexity of more general concurrency techniques. Protocol layers are implemented with data types and use a finite state machine mode...

This paper shows how students can quickly learn how to use neural networks as classifiers. It shows how to apply the teaching principles of problem-based learning, the inverted curriculum and action reflection to equip students to undertake a substantial classification project. The approach centers around the use of a single real-life classification problem to drive the teaching. It describes a series of experiments on the Iris data which demonstrate that it is a suitable data set to support this approach.

Operating systems is an example of a subject that, with the right tools, can be taught in an applied manner, giving students the opportunity to understand, and hence appreciate, the fundamentals of commercial operating systems such as Unix and Windows. Not surprisingly, the tools needed in an operating systems course are, at a minimum, a hardware testbed and a programming language into which algorithms can be translated. This paper describes how many of the salient points concerning operating systems, such as concurrency and critical regions, can be covered in an applied manner using the PC, the C programming language, and extensions to C.

Basic to any data structures course is the introduction of linked lists, their applications and implementations. In this paper we trace the evolution of the exposition of linked lists, as influenced by the language of instruction. We found that while the node pool implementation of linked lists was originally prominently discussed, the current trend is to present only the pointer-based implementation. We feel that the shift toward object-oriented programming should not preclude a presentation of various implementations. We present our own approach to introducing linked list implementations, in which the pointer-based implementation is used to motivate the node pool approach, using pointers to implement the node pool.

One of the main problems faced within departments of computer science is how to encourage students to use their algorithmic and programming skills in the real-life context. This paper deals with control technologies for higher education. We define controlware as a toolkit for creating the control part of a mobile robot in interactive learning environments and educational micro-worlds. Intelligent behavior of mobile robots is created through the composition of constituent control units. The overall behavior of a mobile robot is half cooperative and half-competitive realization of the goals of the control units. To construct this composition behavior and resolve the corresponding conflicts, a partially ordering priority arbitration subsystem is defined. It is shown that the suggested approach links educational processes both in a control curriculum and an intelligent robotics curriculum. We hope that the spreadsheet-based controlware will make the mobile robots lear ning environment an accepted educational ...

This paper presents an online reviewing tool, Poser, written in the Java programming language. Online quizzing tools have proliferated lately, but most are not so wellsuited for reviewing. Poser’s basic functionality is to provide students with a convenient, interactive way to review course materials in a question/answer format. Incorrect responses are corrected, along with an optional explanation. The program keeps usage statistics and information on responses to questions. Poser can be an important part of any course, because it gives students an easy way to test their understanding of the course materials from any Internet computer. We used Poser in two introductory Computer Science courses and gathered some formative data which was used to modify and evaluate the program. Over 100 students used the program and they answered over 38,000 questions while reviewing for their final exams. Student comments indicate that the program was very helpful. Overall, we feel that Poser was a huge success and are planning a controlled study in the coming semesters to measure how much the use of the program facilitates student learning and understanding.

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 thi...

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.

There is considerable variation in the terminology that is used in discussing the subject of (abstract) data types. Further, discussions of individual data types often combine several types into unnecessarily complex or interlinked structures and sometimes refer to a single data type in inconsistent ways. This paper resolves many of these problems by proposing a unified classification of a wide range of data types.