Search

This paper presents BlueBook, a lightweight, cross-platform, computer-based, open source examination environment that overcomes traditional hurdles with computerized testing for computer science courses. As opposed to paper exam testing, BlueBook allows students to type coding problems on their laptops in an environment similar to their normal programming routine (e.g., with syntax highlighting), but purposefully does not provide them the ability to compile and/or run their code. We seamlessly transitioned from paper exams to BlueBook and found that students appreciated the ability to type their responses. Additionally, we are just beginning to harness the benefits to grading by having student answers in digital form. In the paper, we discuss the pedagogical benefits and trade-offs to using a computerized exam format, and we argue that both the students and the graders benefit from it.

A problem that many tech companies face today is that many computer science students entering the work force lack fundamental skills for understanding the entire process of a system that is not solely software. Some students may take a series of courses on analog and/or digital circuits, but the integration with modern devices is sorely missing from most curricula. We designed the Tufts University Comp 50: Wearable Devices course to introduce the basics of digital and analog circuits to students with software-driven backgrounds by studying the intricacies of the production of wearable electronic devices. The course focused on the skills needed to design hardware, software, and a chassis for a final wearable product that was novel and potentially marketable. The primary objective was to provide a course that serves as an introduction to digital electronics but with a tangible goal to produce a high-fidelity prototype that student teams presented at the end of the semester. Given the nature of modern wearable devices, which are small, energy efficient, and strongly favor connectivity to other devices, we developed the curriculum around designing a surface-mount Printed Circuit Board (PCB), and we outfitted the student kits with coin-cell battery powered, Bluetooth-connected, Arduino-compatible devices that they needed to learn how to program and connect. We also integrated iOS development into the course so that students' final projects could communicate with both their phones or tablets, or to the Internet via these devices. As the "wearble devices"' field is relatively new, this paper discusses the decisions we made for the set-up of this class, what worked and what did not, and what we would change and improve when we teach it again.

Traditional introductory programming classes teach sequential programming using a single-threaded programming model. It is typical to wait until a student has developed proficiency in sequential programming before teaching parallel programming. As computer hardware becomes increasingly parallel, there is a greater need for software engineers who are proficient in designing parallel programs, and not just by "parallelizing" sequential designs. Teaching parallelism first is an important step towards educating tomorrow's programmers.We present an overview of a five-day introductory parallel programming course. We taught the course to nine and ten year-olds with no prior programming experience. Our course utilized a fundamentally parallel language we designed for the course, one with a near-natural language syntax that exposed the parallel processors throughout the code. This language, coupled with an interactive online programming environment, allowed us to teach a wide range of parallel programming concepts in a very limited timeframe.We also present examples of student-written code that demonstrates their understanding of some basic parallel programming concepts, and we describe the overall course goal and specific lesson plans geared towards teaching students how to "think parallel."

Many developers have begun to realize that heterogeneous multi-core and many-core computer systems can provide significant performance opportunities to a range of applications. Typical applications possess multiple components that can be parallelized; developers need to be equipped with proper performance tools to analyze program flow and identify application bottlenecks. In this paper, we analyze and profile the components of the Speeded Up Robust Features (SURF) Computer Vision algorithm written in OpenCL. Our profiling framework is developed using built-in OpenCL API function calls, without the need for an external profiler. We show we can begin to identify performance bottlenecks and performance issues present in individual components on different hardware platforms. We demonstrate that by using run-time profiling using the OpenCL specification, we can provide an application developer with a fine-grained look at performance, and that this information can be used to tailor performance improvements for specific platforms.