Vesa Lappalainen

K-12 game programming course concept using textual programming

Several programming environments have been constructed to facilitate novice programming at K-12 and CS0/CS1 levels. The environments can be roughly divided into those using visual or textual programming. This paper presents a K-12 game programming course concept based on textual programming. The concept is based on an easy-to-use C# library, called Jypeli, built on top of Microsoft XNA Framework. The library tries to maintain advantages of visual programming and avoid challenges of textual programming. In particular, the library helps beginners to program their first games in a short period of time and without a heavy syntactic load. The course concept and an initial evaluation consisting of student feedback and a literature rationale are presented.

ComTest: a tool to impart TDD and unit testing to introductory level programming

Research has noticed that imparting TDD-like testing to an early computing curriculum is challenging because it increases technical and cognitive load for the students. This paper addresses the challenge with a software-based solution constructed to facilitate the process of writing tests. The solution allows using a compact while efficient syntax for formulating tests, writing tests into JavaDoc comments, thus close to the source code that implements intended functionalities, and automates the generation of actual test code. The constructed solution -- the ComTest tool -- has now been used in four introductory level programming course offerings. The paper presents the tool and concludes with initial lessons learned.

Five years of game programming outreach: understanding student differences

This paper presents lessons learned from five years of teaching a five-day game design and programming outreach course. The course was offered in summer time and targeted at middle and high school students. In total, 462 youngsters have taken part in 21 course instances. We describe our course concept, and discuss our successes and challenges. In particular, we focus on understanding our student populations by presenting descriptives and statistics of the events, and performing a statistical cluster analysis based on pre- and post-surveys. The cluster analysis was complemented with an analysis of the qualitative data, also originating from the surveys. Taken together, students could be classified into five groups with substantial differences: Enthusiasts, Newbies, Uncertains, Experimenters, and Unsatisfieds. Awareness of the clusters helps instructors of similar courses in developing course content, designing differentiated instruction, and planning follow-up or advanced courses.

Lipschitz classes and the Hardy-Littlewood property

We study the geometry of plane domains and the uniform Hölder continuity properties of analytic functions.

A Practice for Providing Additional Support in CS1

This paper reports on a practice used for providing additional support to beginner programmers. This practice emphasizes low social barriers to learning, differentiated instruction, and revision. Altogether we try to avoid defensiveness or stigmatization among those who face difficulties. Student feedback indicates their acceptance of this approach while teaching assistants report that helping students in need of additional support improve their teaching skills. Further, we have observed indications of improved student performance. We describe the practice and suggest a particular educational constructionism, i.e., how students construct their social identities within a particular school setting, as an explanation for our positive experiences. As a conclusion, we stress the importance of support implemented through differentiated instruction and informed by constructionism as a CS1 research topic.

Application of relation analysis to a small Java software

Relation analysis is a method to find logical couplings in a software by examining a version control log to see which files change together regularly. However, the process can be twisted into finding, for example, illogical couplings between modules, modules with too much influence or burden with responsibility. Here we explain how the relation analysis was applied to a course information system written in Java to find out hidden connections between the modules inside the software.

Modelling Without a Modelling Language

Developments in computer hardware and programming languages, in this case C++, have made it feasible to write models of concurrent systems under verification in the programming language, instead of some established modelling language such as Promela. While this does not reduce the usefulness of modelling languages, it offers new possibilities that may be advantageous, for instance, when teaching state space ideas to newcomers or when experimenting with new scientific ideas. In earlier work, we were able to express everything else fairly naturally in C++, except the set of transitions. The present study uses C++ lambda functions to represent naturally transitions that consist of a tail state, guard, body, and head state. We discuss two implementations, a simple one and a faster one. We present measurements demonstrating that the loss of performance compared to the earlier approach is not big. Starting to use our approach is easy, because one only needs to have a C++ compiler and download (not install) one C++ file.

Towards Computer-based Exams in CS1.

Even though IDEs are often a central tool when learning to program in CS1, many teachers still lean on paperbased exams. In this study, we examine the “test mode effect” in CS1 exams using the Rainfall problem. The test mode was two-phased. Half of the participants started working on the problem with pen and paper, while the other half had access to an IDE. After submitting their solution, all students could rework their solution on an IDE. The experiment was repeated twice during subsequent course instances. The results were mixed. From the marking perspective, there was no statistically significant difference resulting from the mode. However, the students starting with the paper-based part tended to make more errors in their code, but after the computer-based reworking phase, they matched or exceeded the level of the students who started with the computer-based phase. We also discuss the reliability of automatic assessment that is based on a unit test suite that was developed for the purposes of this study.