Essi Isohanni

Are visualization tools used in programming education?: by whom, how, why, and why not?

Visualization tool developers and researchers deliberate on the future directions of tool design and research. Sometimes, it is argued that visualization tools are not used widely. However, there is no factual knowledge about the current rate of visualization tool usage in programming education. How widely are visualization tools used in classes? Who uses them? How, why or why not? This work studies the current usage of visualizations in order to answer the above mentioned questions. The aim is to provide facts to lay the ground for discussion on the future directions on visualization tool development and research. A worldwide survey was organized for over 250 teachers of programming. We targetted the teachers of programming in general, not only those interested in visualization technologies, and asked if they use visualization tools in their class, how they use them and their reasons for and against using them. This paper discusses the results related to almost 500 programming courses giving a current overview of the state of the field. Regular use of visualization tools in class is rather rare: approximately 20% of programming courses use software visualizations regularly. Contrary to the recommendations on visualization tool usage, most commonly they are used by the teacher, not by the students. The most often mentioned reason for not using visualization tools was that the teacher prefers to create his/her own visualizations in some other way, e.g., using the blackboard.

The reasons might be different: why students and teachers do not use visualization tools

In this paper, we address the problem that despite the fact that visualization tools are one of the most investigated research fields in Computer Science Education, most teachers and students neglect utilizing existing visualization tools for teaching and learning programming, respectively. We discuss possible reasons for the problem mentioned above as well as directions for future research based on Activity Theory, a theoretical framework from developmental psychology. Therefore, this is a philosophical paper, with the purposes of briefly presenting those aspects of Activity Theory that are most relevant to the development of program visualization tools, and pursuing the implications of this theory for deepening our understanding of how these tools impact teaching and learning.

On the role of gamification and localization in an open online learning environment: javala experiences

Massive Open Online Courses (MOOCs) have rapidly become an important tool for educational institutes in teaching programming. Nevertheless, high drop-out rates have always been a problem in online learning. As MOOCs have become an important part of modern education, reducing the drop-out rate has become a more and more relevant research problem. This work studies a nine-year-long period of maintaining an open, online learning environment of programming. The aim is to find out how the implementation of the learning environment could engage the students to learning and this way affect the drop-out rate. We provide an insight to experiences stemming from nine years of data collected with Javala, an online system created to help shifting from C++ to Java programming. The paper also discusses two key properties of Javala, gamification, and localization, together with data to assess their significance.

Visualizations as a Basis for Agile Software Process Improvement

Software projects have usually a lot of software engineering data available in different kinds of repositories. This data can be mined and used for software process improvement purposes. In general, agile methodologies emphasize reflection, making problems visible, and learning from the past. As the human mind is powerful in interpreting visual representations, visualizations could help in recognizing problems and areas of improvement in an agile software development process. In this paper an action research approach was taken to carry out software process improvement in an industry project. The research resulted in a visualization of the issue management systems data. The visualizations were a tool to identify problems in the development process and to make them visible for all stakeholders. The results show that this kind of visual approach can be used successfully to point out problems in the process. The visualizations form a basis for communication on possible software process improvement.

Criterion-Based Grading, Agile Goal Setting, and Course (Un)Completion Strategies

When teaching large groups of students with heterogeneous backgrounds and different learning goals, it is essential to personalize the learning experience. In this chapter, we describe how we have implemented this in a university-wide introductory programming course. Each student sets a personal target grade, i.e., the grade they aim at, based on how deep an understanding of programming they need (depending on their major subject, etc.) and on how much effort they are willing to invest in the course. To enable such setup, course assignments are divided into different levels and the grading directs the students in choosing which assignments to work on to meet the goals they have set. Furthermore, the students can change their target grade during the course in an agile manner.

To UML or not to UML?: Empirical Study on the Approachability of Software Architecture Diagrams

Software architecture design is key to building systems that meet quality demands. Choosing the appropriate way to model the architecture ensures it is rightly understood by everyone involved. UML diagrams are commonly used in software engineering but free-form diagrams are almost as common. In this paper, we study the factors influencing the approachability of diagrams, and particularly whether there is a difference in the approachability between UML and non-UML diagrams and colored and black & white diagrams. Our results show that colors do not necessarily increase the approachability of diagrams and free-form diagrams can suffer from ambiguousness. We conclude that simplicity and correctness are key factors when modeling architectures.