Search

Research shows that examples play an important role for cognitive skill acquisition. Students as well as teachers rank examples as important resources for learning to program. Therefore examples must be consistent with the principles and rules of the topics we are teaching. However, educators often struggle to find or develop objectoriented example programs of high quality. Common examples are often perceived as not fully faithful to all principles and guidelines of the object-oriented paradigm, or as not following general pedagogical principles and practices. Unless students are able to engage with good examples, they will not be able to tell desirable from undesirable properties in their own and others' programs. In this paper we report on a study in which experienced educators reviewed a wide range of object-oriented examples for novices from popular textbooks. This review was accomplished using an on-line checklist that elicited responses on 10 quality factors. Results show that the evaluation instrument provides a sufficiently consistent set of responses to distinguish examples. The paper then goes on to examine some of the characteristics of good and bad examples and how this study will influence the evolution of the evaluating instrument.

This case study discusses the incorporation of encryption systems development into the educational journey of undergraduate computer science or game development majors. We discuss the experience of first semester Daniel Webster College sophomores who attempted to develop the German WWII ENIGMA encryption system in assembly language. By incorporating a real world encryption system project into a beginning computer architecture class students become deeply immersed in numbering systems, hardware logic design, operating system services and, of course instruction set architectures. Of necessity, they also must refine and develop their programming skills to an extraordinary degree. During the past seven years we have found that most students can develop a complete software version of the complex and amazing ENIGMA encryption system. We outline in this paper the strategy that seems to lead to a successful outcome for most students.

This paper presents one educator's experience with a browser-based project for an upper-level/graduate Operating Systems course. The author explains the project goals, why the browser in general and JavaScriptin particular are so well suited for this task, challenges andtheir solutions, the incremental assignments that ultimately result in a fairly complex OS simulation by the end of the semester, the response to the project, and some ideas about where to go next.

Information Assurance and computer security are serious worldwide concerns of governments, industry, and academia. Computer security is one of the three new focal areas of the ACM/IEEE's Computer Science Curriculum update in 2008. This ACM/IEEE report describes, as the first of its three recent trends, "the emergence of security as a major area of concern." The importance of Information Assurance and Information Assurance education is not limited to the United States. Other nations, including the United Kingdom, Australia, New Zealand, Canada, and other members from NATO countries and the EU, have inquired as to how they may be able to establish Information Assurance education programs in their own country. The goal of this document is to explore the space of various existing Information Assurance educational standards and guidelines, and how they may serve as a basis for helping to define the field of Information Assurance. It was necessary for this working group to study what has been done for other areas of computing. For example, computer science (CS 2008 and associate-degree CS 2009), information technology (IT 2008), and software engineering (SE 2004), all have available curricular guidelines. In its exploration of existing government, industry, and academic Information Assurance guidelines and standards, as well as in its discovery of what guidance is being provided for other areas of computing, the working group has developed this paper as a foundation, or a starting point, for creating an appropriate set of guidelines for Information Assurance education. In researching the space of existing guidelines and standards, several challenges and opportunities to Information Assurance education were discovered. These are briefly described and discussed, and some next steps suggested.

What is the core of Computing? This paper defines the discipline of computing as centered around the notion of modeling, especially those models that are automatable and automatically manipulable. We argue that this central idea crucially connects models with languages and machines rather than focusing on and around computational artifacts, and that it admits a very broad set of fields while still distinguishing the discipline from mathematics, engineering and science. The resulting computational curriculum focuses on modeling, scales and limits, simulation, abstraction, and automation as key components of a computationalist mindset.

Given increasing adoption of agile software development methodologies it is essential that information technology students are exposed to them. This paper describes and evaluates an attempt to introduce agile programming into a core second year programming course. The initiative appeared to be associated with improvements in both drop out and pass rate, and student perceptions of the innovation were largely positive.

The evaluation of an advanced software engineering (SE) course is a challenging task that should be addressed as part of the course design. In this paper, we describe an implementation of the reflective practitioner perspective as part of an advanced SE course and introduce its use for feedback purposes. Reflective feedback goes beyond merely using feedback questionnaires. Furthermore, we show, using both qualitative and quantitative empirical data, that the course on which the perspective was applied meets its objectives and fosters students' awareness to the multidimensional nature of SE.

International audience; In general, university guidelines or policies on plagiarism are not sufficiently detailed to cope with the technical complexity of software. Software plagiarism can have a significant impact on a student's degree result, particularly in courses were there is a significant emphasis on large-scale projects. We argue that a policy for software reuse is the most explicit, and fair, way of overcoming this problem. In our policy, we specify the notion of software to cover all the documents that are generally built during the engineering of a software system -- analysis, requirements, validation, design, verification, implementation and tests. Examples are used to show acceptable and unacceptable forms of reuse, mostly at the design, testing and implementation stages. These examples are represented in Java, although they should be easily understood by anyone with software engineering experience. We conclude with a simple code of practice for reuse of software based on a file-level policy, combined with emphasis on re-using only what is rigorously verified

We introduce a "hands-on" experimentation approach for teaching mathematical specification and reasoning principles in a software engineering course. The approach is made possible by computer-aided analysis and reasoning tools that help achieve three central software engineering learning outcomes: (i) Learning to read specifications by creating test points using only specifications; (ii) Learning to use formal specifications in team software development while developing participating components independently; and (iii) Learning the connections between software and mathematical analysis by proving verification conditions that establish correctness for software components. Experimentation and evaluation results from two institutions show that our approach has had a positive impact.

This paper is the preliminary report of a joint research project on developing a body of knowledge on model checking. The project is being carried out by four organizations that give model checking courses to software engineers in Japan. The paper explains the main objective of the project and reports the results of an evaluation of model checking programs.

Applets are little applications. Proglets are little programs. The author advocates the use of proglets in first-year programming courses to encourage students to investigate aspects of the language being taught, to test (parts of) algorithms, and to have fun. The writing of proglets allows beginning students to concentrate on their current concerns without being overwhelmed by the requirement to write assignment quality programs worthy of a fully-trained software engineer. The author has used proglets during three semesters to help students in repeat offerings of first-year programming courses which used Java as the teaching language.

We report on our experience in teaching introductory courses on programming based on formal specification and program calculation, in two different Computer Science programmes. We favour the use of logic as a tool, the notion of program as a formal entity, as well as some issues associated with efficiency. We also review and use in practical cases some program transformation strategies, such as generalisation, tupling and modularisation. We describe our approach, its advantages and drawbacks. Furthermore, we present some preliminary results from an ongoing qualitative research which intends to characterise, describe and understand the students' experiences when taking these courses.

Formal methods were developed to provide systematic and rigorous techniques for software development, and they must be taught in the context of software engineering. In this paper, we discuss the importance of such a teaching paradigm and describe several specific techniques for teaching formal methods. These techniques have been tested over the last fifteen years in our formal methods education programs for undergraduate and graduate students at universities as well as practitioners at companies. We also present a curriculum to systematically introduce formal methods to students at university and a successful program of teaching formal methods to industry. Our experience shows that students can gain confidence in formal methods only when they learn their clear benefits in the context of software engineering.

We describe our experience in creating and teaching a graduate course in cryptography at the Johns Hopkins University. We emphasize on the importance of such a course for a graduate student in an information security program. We discuss the course implementation and discuss the challenges in teaching this course to students from varied backgrounds. Based on our observations, we suggest specific improvements that could be applied to this course in the future.

Classical engineering is based on solid scientific and mathematical foundations, but neither the science, nor the mathematics, is simply borrowed from the scientists or the mathematicians. Engineers develop their own formulations of the relevant science and mathematics, adapted to support the engineering knowledge used in design of artefacts. There are many formulations of the same science and mathematics, as classical engineering is highly domain specific. A key question for Formal Methods Education is whether uses and formulations of mathematics used in software engineering should be analogous to the situation in classical engineering described above. The position advocated in this paper is that the classical engineering approach is also crucial for Formal Methods. We may well not be in a position to teach a proper formulation of formal methods until we have developed the appropriate reformulations of the usually mathematically oriented mathematics usually taught in computer science and software engineering programmes.

The small instruction set size of the LC-3 as well as its similarities to more powerful instruction sets make it an ideal hypothetical machine for introductory computer science and computer engineering students. Several tools are available for working with this hypothetical machine including simulators, and assemblers for various platforms. We have created an additional tool, LC3uArch, that is useful for debugging LC-3 programs like the existing simulators, but unlike existing simulators also helps student to develop an understanding of the LC-3 microarchitecture. The results of a student survey on the use of LC3uArch indicate our students find LC3uArch a valuable learning tool.

Like a screenplay, a program is both a static artifact and instructions for a dynamic performance. This duality can keep laypeople from appreciating the complexity of software systems and can be a stumbling block for novice programmers. PyLighter lets laypeople and novice programmers perceive the relationship between static Python code and its execution. PyLighter works with everything from simple console applications to arcade-style games, and because PyLighter is easy to adopt and use, instructors can integrate it into any Python-based introductory course without changing the rest of their syllabus.

We describe an approach to teaching formal interface specifications using aspects of the Collaborative Reasoning Paradigm . The module requires students to construct test cases independently and cooperatively based on their understanding of a given set of method specifications. Students are supported by software-based reasoning assistants that guide them through their exercises and provide realtime feedback as they work --- both for the students and the instructor. We describe the design of the course module, the supporting reasoning assistant, and representative reasoning exercises. We conclude with a discussion of evaluation results from a recent pilot study conducted at Clemson University.

It is widely recommended by both academia and industry that today's technology and software engineering students be well prepared for industry before graduation, especially given global outsourcing and other trends. Various methods have been developed to ensure student readiness, including co-ops and capstone courses. These approaches increasingly use real-world projects for their benefits to industry and often to the community at large. In this paper, we argue that students can be prepared to effectively join industry and keep the US technology workforce competitive through a curriculum that includes a theoretical software engineering course with real-world projects and the collaboration of paired teams across two or more universities. We present a case study of a successful teaching experience that features these aspects, and describe the outcome along with the unique perspective of a participating student.

Learning to program continues to be challenging for many students. This paper reports on problem-solving approaches undertaken by pair programming students. We examine reasons why some approaches lead to success while others lead to failure. We also identify some aspects of the Java language that appear to lead to student misconceptions. Finally, we provide suggestions for educators interested in helping students learn successful approaches and avoid unsuccessful ones.

Software testing is an increasingly important topic in engineering reliable software systems, and test-driven development is an increasingly popular methodology for building reliable systems. However, most software engineering instructors' courses are already very full, so that increasing coverage of testing in those courses can only occur at the expense of another topic. In this paper, we argue that testing should be introduced early in the CS curriculum, that the Data Structures (CS2) course is an especially natural place to emphasize unit testing and test-driven development, and that doing is a way to revitalize the CS2 course.

We report on a recently funded project called Renaissance Computing, an initiative for promoting student participation in computing. We propose a radical re-thinking not only of our core curriculum in CS, but of the role of CS at the university level. In our conception, ''computational thinking'' is neither easily separated from other endeavors nor easily balkanized into a single department. We thus imagine a CS curriculum that is inextricably linked to other domains. Our proposed initiative covers introductory, depth, and capstone courses, targeting both CS majors and minors. It is also aimed to develop interdisciplinary CS courses in sciences, engineering, arts, and humanities. Furthermore, the framework embraces collaborative learning to help improve learning.

In this paper, we report on our experience in designing and deliv-ering two new software design courses in the Informatics major at UC Irvine. When the major was created in 2004, it explicitly con-tained slots for two software design courses to be created from the ground up. The authors led this effort, focusing one course on the topic of system design and one course on the topic of implementation design . We discuss the philosophy and pedagogy behind the courses, present key class activities, and reflect on having offered each course twice over the past two years.

Many academic and industry professionals have called for more testing in computer science curricula. Test-driven development (TDD) has been proposed as a solution to improve testing in academia. This paper demonstrates how TDD can be integrated into existing course materials without reducing topic coverage. Two controlled experiments were conducted in a CS1/CS2 course in Winter 2008. Following a test-driven learning approach, unit testing was introduced at the beginning of the course and reinforced through example. Results indicate that while student work loads may increase with the incorporation of TDD, students are able to successfully develop unit tests while learning to program.

Test-Driven Design (TDD) has been shown to increase the productivity of programming teams and improve the quality of the code they produce. However, most of the introductory curricula provide no introduction to test design, no support for defining the tests, and do not insist on a comprehensive test coverage that is the driving force of the TDD. This paper presents a curriculum, pedagogy, and the software support for introductory object-oriented program design that uses the TDD consistently from the very beginning. The testing software does not increase the program complexity and is designed to work with the simplest programs. It has been used by hundreds of students at several colleges and is freely available on the web. Our experiences show that besides improving the quality of code students produce, TDD combined with the novice-appropriate test libraries reinforces students' understanding of the object oriented program design.

This paper will describe the changes made to an existing student outcomes assessment system to more closely conform to the new assessment guidelines of the Computer Accreditation Commission of ABET. The processes, results and effectiveness of the techniques will be examined.

Dynamic memory management and the use of pointers are critical topics in teaching the C++ language. They are also some of the most difficult for students to grasp properly. The responsibility of ensuring that students understand these concepts does not end with the instructor's lectures---a library enhanced with diagnostics beyond those provided by the language's run-time system itself is a useful tool for giving students more detailed information when their code fails. We have designed such a toolkit, Dereferee, which students can incorporate into their code with minimal intrusion into the learning process. To demonstrate its effectiveness, we examine C++ code from students in a course that relied solely on the built-in memory management behavior of the language, without any significant additional diagnostic or debugging facilities. We instrument this code with Dereferee in order to explore the causes of errors that result in program crashes and to expose hidden faults that previously lay undetected. Dereferee provided enhanced diagnostics for bugs in 63% of student submissions, and pinpointed the source of 83% of abnormal program terminations. 95% of the students would have received extra diagnostic help from using Dereferee.

Jeannette Wing's call for teaching Computational Thinking (CT) as a formative skill on par with reading, writing, and arithmetic places computer science in the category of basic knowledge. Just as proficiency in basic language arts helps us to effectively communicate and in basic math helps us to successfully quantitate, proficiency in computational thinking helps us to systematically and efficiently process information and tasks. But while teaching everyone to think computationally is a noble goal, there are pedagogical challenges. Perhaps the most confounding issue is the role of programming, and whether we can separate it from teaching basic computer science. How much programming, if any, should be required for CT proficiency? We believe that to successfully broaden participation in computer science, efforts must be made to lay the foundations of CT long before students experience their first programming language. We posit that programming is to Computer Science what proof construction is to mathematics, and what literary analysis is to English. Hence by analogy, programming should be the entrance into higher CS, and not the student's first encounter in CS. We argue that in the absence of programming, teaching CT should focus on establishing vocabularies and symbols that can be used to annotate and describe computation and abstraction, suggest information and execution, and provide notation around which mental models of processes can be built. Lastly, we conjecture that students with sustained exposure to CT in their formative education will be better prepared for programming and the CS curriculum, and, furthermore, that they might choose to major in CS not only for career opportunities, but also for its intellectual content.

Formal code inspections are employed by teams of professional software engineers to identify software defects and improve the quality of software. After reviewing a piece of code individually, members of an inspection team come together to log the issues they have found, and to find new ones. Within the scope of a multi-institutional research project to adapt, refine, and evaluate studio-based learning methods in computing education, we are developing an adaptation of the formal code inspection called the pedagogical code review for use in lower-division computer science courses. In a pedagogical code review, a group of three to four students, led by a trained moderator, (a) walk through segments of each other's programming assignments, (b) check the code against a list of best coding practices, and (c) discuss and log issues that arise. We implemented pedagogical code inspections in three lab sessions of a CS 1 course. Through an analysis of inspection logs and exit surveys, we compiled evidence that the reviews improved the quality of students' code, stimulated increasingly sophisticated discussions of programming issues and practices, and promoted a sense of community.

This case study discusses the incorporation of game development throughout the Daniel Webster College computer science curriculum. During the freshman year all computer science majors develop complex games in C#.net while participating in an instructional game motif method we call the GM method. This freshman educational method combines agile software engineering techniques with an inquiry based, neo-Socratic classroom. The GM method provides freshmen with the core skills necessary to develop complex games throughout their college career. This freshman program of study is followed by more traditional project courses which begin with an encryption system project in the sophomore year. XNA 2-D and XNA 3-D game development soon follow and a C++ game engine development capstone project is undertaken in the senior year.

The way engineering is being taught has changed in recent years with the introduction of commercial and educational software thus allowing a better understanding of the subject matter and increased teaching efficiency. This paper presents the educational software package designed to work in PCs and provides an attractive way to introduce the fundamentals of random variables. The software can be used as a complement to theoretical classes or alone as a self-study tool. The package was implemented in MATLAB and uses MATLAB™ tool "makeshow" which allows the students to create interactive slideshows without building their own graphic interface. The software is easy to use and is in accordance with the established standards, mouse operations, icon menus, etc. The demos include Probability Density Function (PDF), and Cumulative Distribution Function (CDF), normal, lognormal, exponential, Rayleigh and Rician random variables. The package also demonstrates how to generate the desired random sequence, how to examine its characteristics and how to estimate its PDF and CDF.

Current trends in microprocessor design are fundamentally changing the way that performance is extracted from computer systems. The previous programming model of sequential uniprocessor execution is being replaced quickly with a need to write software for tightly-coupled shared memory multiprocessor systems. Academicians and business leaders have both challenged programmers to update their skill sets to effectively tackle software development for these newer platforms [2]. At the University of Wisconsin - Eau Claire, we have taken steps early in our curriculum to introduce our students to concurrent programming. Our approach is not to add parallel programming as a separate class, but to integrate concurrency concepts into traditional material throughout a student's coursework, beginning in CS1. Our goal is for students to gain both familiarity and confidence in using parallelism to their advantage. This paper describes the programming process we seek to introduce to our students and provides example assignments that illustrate the ease of integrating this process into a typical curriculum.

The ĭǽ· project was designed to educate students in undergra-duate computer science courses through the study of and solution to large-scale problems in computer graphics. Our ultimate aim is that this approach would be applied to all computer science courses in the B.A. curriculum. In the first years of this project, we have been working on the foundational sequence, which includes CS1, CS2, and CS3 (data structures and advanced programming). For this last course, which also includes the study of algorithms in our curriculum, we present an approach to teaching data structure concepts using advanced graphics algorithms. The results thus far have been promising, and we are continuing to evaluate and en-hance the approach.

Open-source project artifacts can be used to inject realism into software engineering courses or lessons on open-source software development. However, the use of open-source projects presents challenges for both educators and for students. Educators must search for projects that meet the constraints of their classes, and often must negotiate the scope and terms of the project with project managers. For students, many available open-source projects have a steep learning curve that inhibits them from making significant contributions to the project and benefiting from a "realistic" experience. To alleviate these problems and to encourage cross-institution collaboration, we have created the Repository for Open Software Education (ROSE) and have contributed three open-source projects intended for an undergraduate computer science or software engineering course. The projects in ROSE are education-friendly in terms of a manageable size and scope, and are intended to be evolved over many semesters. All projects have a set of artifacts covering all aspects of the development process, from requirements, design, code, and test. We invite other educators to contribute to ROSE and to use projects found on ROSE in their own courses.

This paper presents a novel and innovative pedagogical approach for teaching software quality assurance in the undergraduate computer science curriculum. The approach is based on students contributing programming problems to an open source web-based system that is used for student practice and instructor assessment of assignments. WeBWorK, and some of the latest web-based systems, use a mechanism based on unit testing to account for variation in the way in which the same problem can be answered in an accurate manner, making such systems highly appealing for education. Tackling open-ended programming problems within WeBWorK therefore requires students to write a code fragment that is then checked for semantic correctness. Given that WeBWorK is open source, the teaching approach that we have evolved revolves around students creating their own problems for other students to practice with. This requires students to construct comprehensive unit tests that can assure both the usability and accuracy of their work prior to deployment. The paper describes this approach, gives examples of student work, presents findings from the experience of using the approach in the classroom, and discusses broader lessons and reasons for integrating software quality assurance practices into the computer science curriculum.

Although computer-aided software engineering (CASE) is one of the most current and interesting subjects within software engineering, relatively little has been published on the issue of teaching CASE at the graduate level. This paper reports a case study in teaching a graduate-level course on CASE tools in a span of six years. We explain the structure and contents of the course, describe the work the students perform as their term project, and summarize the outcome and lessons learned in five course offerings. The issues discussed in this paper might help educational institutions and college professors in designing and implementing software engineering courses at the graduate level.

The field of Cyberinfrastructure (CI) has experienced rapid and exciting progress in enabling technologies, but much slower improvements in application codes, largely because of the ongoing disconnect between the CI and application research communities. At the University of Oklahoma, the OU Supercomputing Center for Education & Research (OSCER) is addressing this issue using a multipronged pedagogical strategy that combines workshops, tours, question-and-answer and "rounds" (one-on-one interactions), with minimal jargon, using storytelling and analogies to capture the essential properties of Cyberinfrastructure.

This paper describes the implementation of a system, called Foundational Learning Objects Workbench (FLOW), which is intended to be used by instructors to educate their students in the major principles of multidisciplinary fields at a variety of grade levels. FLOW functions by dividing the major topics in a field into modules. These modules cover a wide variety of topics and may be inserted into different courses, providing students with a basic understanding of the field in question. FLOW also possesses methods for assessing both students and the modules.

In this paper, we discuss our experience in offering a usability course with projects taken from an active open source software development project. We describe what was done in the class inside the larger context of the usability of open source software. We conclude with an invitation for others to adopt this model and use it for their own purposes.

This paper is a discussion of the early days of CAM-CAD at The Boeing Company, covering the period approximately 1956 to 1965. This period saw probably the first successful industrial application of ideas that were gaining ground during the very early days of the computing era. Although the primary goal of the CAD activity was to find better ways of building the 727 airplane, this activity led quickly to the more general area of computer graphics, leading eventually to today's picture-dominated use of computers. The paper started as an internal exchange of memories between some of the people primarily concerned, but is now offered as the possible start of a discussion involving other such initiatives during that period.

Paying only lip service to the principles of object-oriented programming rarely results in the expected benefits. This paper presents a series of designs for a Sudoku application that will lead introductory students through the all-important process of trial and error. They will see examples of design analysis, criticism, and improvement. The paper concludes with some general pointers why and how the initial mistakes could have been avoided.

Teaching students to incorporate template classes into their C++ projects is an important concept in object-oriented programming. The most efficient implementation method for template classes is dependent on several factors. Two significant factors are different integrated development environments with differing requirements, and incongruous philosophies among instructors. Herein, several template class instantiation methods under Gnu compilers will be discussed, along with their pros and cons.

University professors traditionally struggle to incorporate software testing into their course curriculum. Worries include double-grading for correctness of both source and test code and finding time to teach testing as a topic. Test-driven development (TDD) has been suggested as a possible solution to improve student software testing skills and to realize the benefits of testing. According to most existing studies, TDD improves software quality and student productivity. This paper surveys the current state of TDD experiments conducted exclusively at universities. Similar surveys compare experiments in both the classroom and industry, but none have focused strictly on academia.

Emulabs, network testbeds on which experiments can be carried out through a web interface, are widely recognized as useful research environments. We believe that Emulabs are also excellent platforms for teaching courses in operating systems and networking. Moreover, equipment costs have fallen, and Emulab software has evolved, to the point where any school could conceivably afford their own. This raises the obvious question: "Should institutions build and operate their own Emulab?". To get a handle on this question, we describe our experiences building and operating Edulabs --Emulabs specifically designed for education--at Calvin College and the University of Kentucky. We argue that with the right technical support, owning and operating one's own Emulab is a worthwhile endeavor that has many benefits. We acknowledge, however, that in the absence of good technical support, deploying one's own Emulab can be a difficult enterprise. We also describe how we enhanced Emulab to improve its utility in an educational setting.

A qualitative analysis of debugging strategies of novice Java programmers is presented. The study involved 21 CS2 students from seven universities in the U.S. and U.K. Subjects "warmed up" by coding a solution to a typical introductory problem. This was followed by an exercise debugging a syntactically correct version with logic errors. Many novices found and fixed bugs using strategies such as tracing, commenting out code, diagnostic print statements and methodical testing. Some competently used online resources and debuggers. Students also used pattern matching to detect errors in code that "just didn't look right". However, some used few strategies, applied them ineffectively, or engaged in other unproductive behaviors. This led to poor performance, frustration for some, and occasionally the introduction of new bugs. Pedagogical implications and suggestions for future research are discussed.

Language engineering - the theory and practice of building language processors and compilers, has long been recognized as important subject in Computer Science curricula. However, due to lack of suitable target systems, educators face significant challenges to teach language engineering classes effectively. Leveraging the emerging inexpensive robot devices, this paper presents a new approach of using robots as system context to teach language engineering topics. We designed the Chirp-Scribbler Language, which targets the popular Scribbler robot; combined together, they provide an engaging and feature-rich platform to teach a wide range of topics in language engineering. This paper describes the Chirp-Scribbler Language, its integration with the target robot, and the teaching practice of using them to teach language translation basics in an undergraduate programming course.

In this paper we present our experience using code reviews in a CS2 course. In particular, we highlight a series of misunderstandings of object-oriented (OO) concepts we observed as a by-product of the code review exercise. In our activity, we asked students to review code, rate it using a rubric, and to justify their explanation. The students were asked to review two solutions to a project from a previous year. Through examples of their explanations, we found that students had a number of basic misunderstandings of object-oriented principles. In this paper, we present our observations of the misunderstandings, and present some general observations of how code reviews can be used as an assessment tool in CS2.

A common approach for introducing computer science to middle school students is to teach them a simple yet engaging programming language A different approach is to teach them some advanced topic independent of any particular language or syntax We describe a 3-hour workshop module designed to do both This module has been piloted with a group of thirty 8th grade girls. It uses the Scratch programming language to develop the advanced software engineering concepts of specifications, refinement, and composition After this module, students were enthusiastic about continuing to program in Scratch independently and also felt they learned something about computer science as a discipline.

Tools like JUnit and its relatives are making software testing reachable even for introductory students. At the same time, however, many introductory computer sciences courses use graphical interfaces as an "attention grabber" for students and as a metaphor for teaching object-oriented programming. Unfortunately, developing software tests for programs that have significant graphical user interfaces is beyond the abilities of typical students (and, for that matter, many educators). This paper describes a framework for combining readily available tools to create an infrastructure for writing tests for Java programs that have graphical user interfaces. These tests are level-appropriate for introductory students and fit in with current approaches in computer science education that incorporate testing in programming assignments. An analysis of data collected during actual student use of the framework in a CS1 course is presented.