Harrie Passier

Using IDEAS in Teaching Logic, Lessons Learned

At the Open University we are developing tools to support students in learning procedural skills. The tool for rewriting logical formulas into disjunctive normal form was tested with students in the period 2007-2008. The results of this tests help us to improve our tool, give answers to some questions we had during the development and encourage us to proceed.

Maintaining Unit Tests During Refactoring

The meaning of source code is often described by unit tests, as is for example the case in Test-Driven Software Development. Test-driven development is a principle in software engineering that requires developers to write tests for each method before implementing the method itself. This ensures that for (at least) all public methods tests exist. When performing a refactoring, existing code is changed or restructured according to a predefined scheme. After a refactoring is applied, the alignment between the structure of source code and corresponding unit tests can be broken. In this paper we describe different ways in which refactorings can impact the API coverage of unit tests. We present our approach of tracking the modifications made by refactorings, analyzing their influence on the existing test suite and giving advice to developers on how to update the test suite to migrate it. For example, tests may need to be moved or new tests developed in case a refactoring introduced new public methods. Our approach is applicable to all refactorings. We conclude this paper by discussing the potential of the presented approach and of the preliminary tool support in the Eclipse IDE.

The design of mobile apps: what and how to teach?

Mobile applications (or mobile apps or apps for short) gain importance, and will, as is our expectation, find a place in the curricula of Computer Science and Software Engineering. In books, courses and tutorials, not much attention has been given to the design of mobile applications. In this paper, we describe the anatomy of mobile apps, using Android as an example. Based on this anatomy, we offer an inventarization of modeling techniques that can be applied to adequately design mobile apps. Some of these modeling techniques are already taught in most curricula, albeit in different courses. A modeling technique that is useful for several aspects of mobile apps is the Interaction Flow Modeling Language (IFML). This modeling technique would have to be introduced when one would like to teach students how to design apps. We also describe which strategies can be followed when introducing mobile apps in a curriculum: as a subject of a course, together with knowledge of the concepts and the necessary modeling techniques, or as examples in different courses. We discuss advantages and disadvantages of both approaches.

Template Method test pattern

Abstract How to test abstract classes is an area of testing that is not paid much attention to. Abstract classes cannot be instantiated and therefore standard execution-based test strategies are not applicable. In this paper, we consider a special case of an abstract class, namely one produced by the Template Method pattern. This pattern results in an abstract class, with a concrete template method and one or more abstract primitive operations, and one or more subclasses, implementing the primitive operations specifically for each subclass. How should we test an instance of the Template Method pattern? Testing the concrete template method by testing the abstract class is impossible. Testing an instance of the Template Method pattern by testing the template method in all of the subclasses individually is error-prone in the long run. This paper presents a structured approach to test instances of the Template Method pattern in an elegant way using the Abstract Factory pattern. Furthermore, we introduce the new concept semi-abstract method to reason about concrete methods that depend on abstract operations. We formalize the pattern and demonstrate the approach at work using an example program.

The role of Procedural Guidance in Software Engineering Education

Designing and programming require several types of knowledge. Beside conceptual knowledge, procedural knowledge is of importance. Procedural knowledge, however, is often missed in courses about software design and implementation. As a consequence, students can easily be stuck and do not know how to proceed. Considering software engineering as a complex task, the didactic approach 4C/ID is applicable. This approach prescribes that besides mental models, cognitive strategies should be learned, consisting of overall steps and rules and procedures per step. As an example, a procedure for designing and programming a concurrent program is briefly described. This procedure will scaffffold studentfis learning of concurrency concepts and their application.