Hannu-Matti Järvinen

A study of the difficulties of novice programmers

Programming is related to several fields of technology, and many university students are studying the basics of it. Unfortunately, they often face difficulties already on the basic courses. This work studies the difficulties in learning programming in order to support developing learning materials for basic programming courses. The difficulties have to be recognized to be able to aid learning and teaching in an effective way.An international survey of opinions was organized for more than 500 students and teachers. This paper analyses the results of the survey. The survey provides information of the difficulties experienced and perceived when learning and teaching programming. The survey results also provide basis for recommendations for developing learning materials and approaches.

Object-oriented specification of reactive systems

A novel approach to the operational specification of concurrent systems that leads to an object-oriented specification language is presented. In contrast to object-oriented programming languages, objects are structured as hierarchical state-transition systems, methods of individual objects are replaced by roles in cooperative multiobject actions whereby explicit mechanisms for process communication are avoided, and a simple nondeterministic execution model that requires no explicit invocation of actions is introduced. The approach has a formal basis, and it emphasizes structured derivation of specifications. Top-down and bottom-up methodologies are reflected in two variants of inheritance. The former captures the methodology of designing distributed systems by superimposition; the latter is suited to the specification of reusable modules.<<ETX>>

DisCo specification language: marriage of actions and objects

The potential of the action-oriented paradigm has been explored in the development of a specification language, DisCo, which can be characterized as both action-oriented and object-oriented. Its possibilities are introduced by contrasting them to the more familiar process-oriented approaches. Its execution model is state-based and leads to direct application of temporal logic in formal reasoning. Action-orientation allows a natural support for such forms of modularity that cut across process boundaries. At the same time, process-oriented abstractions are retained by object-orientation and the use of hierarchical state chart structures. The novel aspects of modularity are illustrated by a protocol example. The language is semi-executable.<<ETX>>

Action system approach to the specification and design of distributed systems

in temporal logic [24, 25] or in the logic developed for Unity [10]. External interactions are also modeled as joint actions, without committing to specific communication events between the system and its environment. This means that a joint action system is a closed system containing also a model of its environment. This has an effect on modularity, as will be seen below. For the design process joint action systems provide a framework for stepwise derivation. The initial action system with which this process starts should be simple. Fortunately, the natural ways of structuring action systems support a layered introduction of properties. Bias towards machine architecture or communication primitives does not belong to the initial system, even if the eventual answers to such questions were known from the beginning. No harm is caused at this level by wasteful computations allowed by nondeterminism. Furthermore, the granularity of atomic actions can be coarser than would be feasible in a distributed implementation. Together with independence of communication mechanisms this helps in the avoidance of subtle timing errors. The initial action system is the first baseline for the design process. Being amenable to both formal analysis and experimentation (by simulation and animation), it can be subjected to extensive verification and validation. From this stage the design proceeds by transformations that • refine the atomicity of actions,

Incremental introduction of behaviors with static software architecture

In this paper, we introduce the baseline of a software and system architecture where a static configuration of software components is prescribed but application-dependent behaviors remain customizable. Reflecting the facilities of the formal method DisCo, the architecture enables a development approach where the focus can be placed on the underlying infrastructure separately from application logic. Furthermore, application logic implemented with the architecture can be derived incrementally, which allows stepwise verification and validation and provides a natural basis for adopting incremental development practices. In addition to the underlying ideas, the paper also discusses practical experiences on applying the approach, and introduces some related systems.

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.

Framework for embedded programming course

Embedded programs are controlling a number of devices we use daily. The software of an embedded device is usually tightly coupled with the device hardware, and therefore developing embedded programs is fundamentally different from programming general-purpose computers. In academic education both hardware and software aspects of embedded systems need to be covered. In this paper we provide some general guidelines that can serve as a starting point when designing embedded programming courses. These guidelines are based on our experiences and evaluation of two implementations of an embedded programming course that consists of hands-on assignments and lectures. Furthermore, we discuss about how to improve the course in the future.

Organizing and evaluating course on embedded programming

Embedded systems have been an important part of daily human life for a long time. However, in academic education the subject is somewhat new and to some extent undefined. Most courses focus on hardware aspects of embedded systems, and at the same time there is a lack of embedded programming courses. In this paper, we describe our experiences of organizing, designing and evaluating an embedded programming course. We describe course assignments in detail and present pass-rate of each assignment. We also present our improvements for course of upcoming years.

Code ABC MOOC for Math Teachers

Computing is the latest add-on to enhance the K-12 curricula of many countries, with the purpose of closing the digital skills gap. The revised Finnish Curriculum 2014 integrates computing mainly into math. Consequently, Finland needs to train math teachers to teach computing at elementary level. This study describes the Python and Racket tracks of the Code ABC MOOC that introduce programming basics for math teachers. Their suitability for math is compared based on the course content and feedback. The results show that conceptually the functional paradigm of Racket approaches math more closely, in particular algebra. In addition, Racket is generally regarded as more challenging in terms of syntax and e.g. for utilizing recursion as an iteration mechanism. Math teachers also rank its suitability higher because the content and exercises of the track are specifically tailored for their subject.

Concurrent execution system for action languages

Traditional methods of managing concurrent processes are difficult and prone to errors. We propose that actions can provide a much simpler approach to the problem. In this paper, we use Temporal Logic of Actions to define an execution system that can be used to concurrently execute programs created with action languages. Important features of the system include naturally concurrent execution of actions, automated management of mutual exclusion, complete avoidance of low-level deadlocks, and implicit means of synchronization.