In the computing education community, discussion is growing about the benefits of teaching programming by explicitly using notional machines to help students. To-date most work is largely theoretical and little work addresses actually using them in a classroom. This paper documents our experience of creating a notional machine for a specific course and using it in that classroom. A key point we learned while creating this notional machine is that many of the difficulties encountered were due to the concept of a notional machine being tightly coupled to students' mental models. Although not surprising, the numerous complications this brings are important to overcome. The potential amount of detail included in the notional machine is enormously influenced by the students' mental models, which are likely specific to a course, and also change throughout a semester -- and certainly across several semesters. We present lessons learned from this experience, among them that implementing a notional machine and using it in class is a non-trivial yet possibly beneficial exercise.

Tracing code execution and creating memory diagrams have long been tools for teaching computer science. These techniques are useful beyond demonstration or assessment of understanding: they are teaching and learning tools. We argue that if consistent diagramming is used across courses and programming languages, variations to the level of detail in those diagrams can become a teaching technique. We previously described a consistent form of memory diagram to be used across curricula, Ithaca Memory Diagrams IMDs, and explained their basic use. After four more years of classroom use, we find that variation in these diagrams is useful to emphasize specific concepts and highlight features of various languages. Our updates to previously published memory diagrams improve their usefulness in courses from the high-level abstraction of CS1 to the depth of systems courses. We provide specific examples of this variation with explanation of the intended benefits.

The term "the machine" is commonly used to refer to the complicated physical hardware running similarly complex software that ultimately executes programs. The idea that programmers write programs for a notional machine - an abstract model of an execution environment - not the machine itself, has risen to the point of gaining acceptance as a useful device in computing education. This has seeded a growing discussion about how explicitly utilizing notional machines in teaching can help students construct more accurate mental models, which is essential for learning programming. Much of the existing literature necessarily involves specific languages, visualization, and/or facilitating tools, and is not very accessible to many practitioners. Less focus has been put on how teachers can make explicit use of notional machines in their teaching. In this paper we describe notional machines and their use in a manner that is more accessible to a general educator audience in order to facilitate more effective computing education at all levels. We advocate explicitly delineating between visualization tools and the notional machines they depict, isolating and clarifying the notional machine so that it is conspicuous, apparent and useful. We present examples of how this approach can facilitate a more consistent method of teaching computing, and be used in more effective pedagogical practice for teaching computing.

In computer science (CS) classes it is common to give students a large ill-defined problem and let them struggle with it. The mess of the problem forces students to identify knowledge needed to solve the problem and to learn problem-solving skills. This is the concept behind problem-based learning (PBL), a learner-centered pedagogy that has become a popular research topic in computer science. PBL in CS has 3 defining characteristics: 1) presenting students with large authentic projects, 2) enabling students to independently learn necessary concepts, and 3) enabling them to learn while working in groups. An examination of the CS PBL/project-based learning (PrBL) literature reveals that step 2, self-directed or self-regulated learning (SRL), is lacking in almost every description of PBL. However, extensive CS research literature explores effective methods of SRL, and these methods revolve around the concept of reflection. We therefore propose a new structure for PBL/PrBL that we term messy learning that explicitly incorporates large, ill-defined, authentic projects and reflective activities. We also describe our experience with using messy learning in a game development course and present some examples of how to apply messy learning.

Computer Science is a rapidly changing field where code bases and development strategies can change in months even if core concepts stay largely the same. In order to prepare our students for this environment we need to enable them to learn on their own and this concept appears in the literature as self-directed or self-regulated learning (SRL). The literature on SRL suggests that reflection is one of the most effective ways of promoting SRL. Reflective diaries, blogs, journals and questionnaires have all been used successfully in fields from the humanities to medicine to engineering to encourage students to engage in SRL. We believe that reflection has not caught on in CS as heavily as in some other fields because our students dismiss these common methods of reflection as mere busy work. The benefit of reflection, however, is not the writing itself but the process of thinking about and analyzing the actions and experiences of learning in order to master them. With this BOF we will describe reflection and its use in CS and start a discussion of reflective exercises relevant to computer science. As an example, students can reflect on how they learn new material by creating YouTube tutorials for others and adding to community knowledge. The intended result of this BOF is to begin the development of a repository of reflective activities that can be used in computer science classes.

We often give students large projects because solving them teaches students so much. If we give them messy problems with a lot of structured ambiguity, we can make it so that they learn even more because they will have to really think about the problems they are solving. This concept is often applied through project/problem-based learning. If only this were true, we could just give our students a lot of poorly defined problems and in so doing create extremely competent graduates. The idea breaks down because we as faculty think about how much students will learn from the process and gain insight through doing, while students tend to focus on their final product/grade and ignore the journey. Students learn a lot but not as much as they could. The problem is not with the projects and their intrinsic messiness but instead with our students' focus. We propose the concept of messy learning, which couples project/problem-based learning with reflection to solve this problem. Messy learning involves giving deliberately ambiguous problems where we want students to focus on learning about how to solve the ambiguous parts of the problem. Reflection is the method that we propose to use to make the messy learning projects effective for our students by using it to focus attention on appropriate parts of the messy problems.

Students' interest in game development often leads departments to attempt to put together a stand-alone game development course. We have used both Unity and Unreal for just such a course. Unity and Unreal are discussed here in the context of how viable they are and how they compare in terms of usefulness for teaching game development. We also present them in context of high level overviews of other game engines and discuss which factors add to a more effective game engine for teaching game development. This paper is intended to help answer some of the questions asked by those without experience in the field who find themselves developing stand-alone game development courses.

Undergraduate teaching assistants have been used in many classes, over many years, and at many institutions. The literature primarily focuses on the practice in a university environment with large classes. We focus instead on the use of undergraduate teaching assistants in the small college, small class environment. We have been employing students in this capacity for over 15 years and have gained some insight on how best to use these undergraduate teaching assistants in the small classroom setting. We believe these conclusions can inform the design of other undergraduate teaching assistant programs.

In this paper we present an improved method for capturing information presented on a whiteboard in the context of lecture capture. The method produces better results than any method currently used and builds on methods available within the field of single-frame whiteboard enhancement. We present new techniques for both removing the lecturer from in front of the whiteboard and enhancing whiteboard content.

Hand-drawn memory diagrams are frequently used in computer science to demonstrate new programming concepts and support students' understanding of program functionality. These diagrams often vary among courses, instructors, and languages, which confuse students moving through the curriculum. Consistent memory diagrams throughout a curriculum not only alleviate confusion but offer a scaffold for students to transfer their understanding between courses taught at different levels of complexity and in different languages. We describe our standardized system for memory diagrams as it is used in our curriculum to demonstrate this scaffolding process through multiple concepts and programming languages.

Lecture recording is not a new concept nor is high-resolution recording of multimedia presentations that include computer and whiteboard material. We describe a novel portable lecture capture system that captures not only computer content and video as do most modern lecture capture systems but also captures content from whiteboards. The white-board material is captured at high resolution and processed for clarity without the necessity for the electronic whiteboards required by many capture systems. Our presentation system also processes the entire lecture in real time. The system we present is the logical next step in lecture capture technology.

Video games are ubiquitous and our students want to learn how to make them. As computer science professors we see incorporating games into our curricula as a great way of increasing student excitement, increasing retention, and teaching communication skills. The problem many of us face though is how to teach game development when you have never written a game. Searches of articles and course offerings from other colleges does not provide a lot of clarification on what is the best environment for teaching such a course. The solution that we have found after many attempts is to build a game development course around the Unity game engine, and in this paper we describe how we arrived at this decision. Unity is easy to learn, free, cross-platform, a real game engine, and known in the field of game development but not discussed in computer science literature with regard to this type of course.

Objective – We sought to develop best practices for creating online research guides in an academic library. Methods – We performed usability tests of particular library research guides in order to determine how to improve them. Students in a Human-Computer Interaction (HCI) class (n=20) participated in the studies both as subjects of the tests and as evaluators of the results. The students were each interviewed and then asked to review the interviews recorded of four other classmates. Based on their own experience with the guides and their viewing of their classmates using the guides, the students worked with librarians to develop best practices. Results – Students were generally unfamiliar with the library's research guides prior to the study. They identified bibliographic databases as the most important links on the guides and felt that these should be prominently placed. Opinions about many specific features (e.g., images, length of guide, annotations) varied widely, but students felt strongly that there should be some organizational consistency among the guides. Conclusions – The importance that students placed on consistency led the library to adopt guidelines dictating the inclusion of a table of contents and short list of major databases at the top of each guide, as well as uniform placement of certain other elements.

This paper evaluates the benefits and drawbacks of lecture recording, which aspects of lectures and lecture capture systems are most used, and what additional features and functions would make the experience more effective. We evaluated 4 computer science courses recorded during spring 2011 using our comprehensive lecture capture system PAOL and presented with webMANIC. We discuss the results of student surveys and focus groups and compare these with prior surveys that investigated how students reacted to the availability of online lecture content and how they used these resources in large- and small-scale deployments with both home-grown and commercial lecture capture technologies. The primary motivation for this study was to analyze how lecture capture fits in the context of computer science curricula and pedagogy and about how we can enhance our systems to be more educationally effective.

Mobile computing is a growing market and an area of increasing interest to students. To answer our student demand we decided to develop a mobile computing course but one with a focus on interface and application design rather than implementation. The course is designed for a student audience ranging from novice programmers to experts. Using Cabana as our platform, we were able to achieve this end while also enabling our students to build functioning mobile applications. Cabana enables rapid interface design and application development without the learning curve of more traditional mobile application building. In this paper we describe our project-based curriculum and discuss its successes and failures.

Mobile application development is a hot topic in computer science education, and debate rages over which platform to develop on and what software to use for development. Cabana is a web-based application designed to enable development on multiple mobile platforms and to make application development easier. It uses an approach to application programming based on a wiring diagram that is supplemented with the ability to program directly using JavaScript. It is an ideal choice for application development in introductory computer science courses and for upper-level courses where the focus is on application design and not application programming. This paper introduces Cabana and describes its use in two different computer science courses.