Concurrency and synchronization are two topics that are becoming increasingly important as multicore systems and distributed systems are becoming the norm. However, prior research shows that students struggle with these topics, perhaps partially since they require a good understanding of language semantics and abstract reasoning. To aid students' learning, we developed Progvis to visualize these concepts and let students experiment with them. We also conducted a pilot study of whether the tool helps students to solve synchronization problems, and the results are promising.

This paper continues previous efforts in understanding the problems students face when learning concurrency. In this paper, we explore students' understanding of the subject using phenomenography in order to gain insights that can aid in explaining the underlying causes for common student mistakes in concurrency, which has been studied in depth previously. Students' experience of concurrency and critical sections were analyzed using a phenomenographic study based on interviews with students attending one of two courses on concurrency and operating systems. We present 6 categories describing students' experience of concurrency, and 4 categories describing students' experience of critical sections in this paper. Furthermore, these categories are related to previous results, both to explore how misconceptions in the categores relate to student mistakes and to estimate how common it is for each category to be discerned.

This paper investigates common misconceptions held by students regarding concurrency in order to better understand how concurrency education can be improved in the future. As a part of the exam in two courses on concurrency and operating systems, students were asked to identify and eliminate any concurrency issues in a piece of code as a part of their final exam. Different types of mistakes were identified and the 216 answers were sorted into categories accordingly. The results presented in this paper show that while most students were able to identify the cause of an issue given its symptoms, only approximately half manage to successfully eliminate the concurrency issues. Many of the incorrect solutions fail to associate shared data with a synchronization primitive, e.g. using one lock to protect multiple instances of a data structure, or multiple locks to protect the same instance in different situations. This suggests that students may not only have trouble dealing with concepts related to concurrency, but also more fundamental concepts related to the underlying computational model. Finally, this paper proposes possible explanations for the students' mistakes in terms of improper mental models, and suggests types of problems that highlight the issues with these mental models to improve students' understanding of the subject.

Despite the plethora of research done in code injection countermeasures, buffer overflows still plague modern software. In 2003, Wilander and Kamkar published a comparative evaluation on runtime buffer overflow prevention technologies using a testbed of 20 attack forms and demonstrated that the best prevention tool missed 50% of the attack forms. Since then, many new prevention tools have been presented using that testbed to show that they performed better, not missing any of the attack forms. At the same time though, there have been major developments in the ways of buffer overflow exploitation.

Most software analysis and assessment techniques operate on graph representations of the target software. One of the most common representations is the Program Dependence Graph in one of its many variations. The Value Dependence Graph is an alternative that is more suitable for many types of analyses, including static slicing and many code transformations, such as instruction scheduling and invariant analysis. The authors present a new algorithm that builds Value Dependence Graphs from the parse tree of a program. By generating the Value Dependence Graph from the parse tree, our algorithm is significantly simpler and clearer than previously published algorithms.

In a series of articles Gupta et al. develop a framework for automatic test data generation for computer programs. In general, their approach consists of a branch predicate collector, which derives a system of linear inequalities representing the branch predicates for a given path in the program. This system is solved using a solving technique of theirs called the Unified Numerical Approach (UNA) [5, 7]. In this paper we show that in contrast to traditional optimization methods the UNA is not bounded by the size of the solved system. Instead it depends on how input is composed. That is, even for very simple systems consisting of one variable we can easily get more than a thousand iterations. We will also give a formal proof that UNA does not always find a mixed integer solution when there is one. Finally, we suggest using some traditional optimization method instead, like the simplex method in combination with branch-and-bound and/or a cutting-plane algorithm as a constraint solver.

The Information Technology curriculum at Linköping University has as goal to form engineers with an integrated view of engineering. The teaching philosophy in this curriculum is Problem-Based Learning. The education in each term is organised in a number of themes where topics from different disciplines are integrated. We describe a particular term in the Information Technology curriculum as an example of the approach and the integration of computer science teaching with the teaching of other disciplines. An important advantage of the approach is that the students discover interactions between different disciplines and view the different topics as naturally connected. Also, the students seem to have a better understanding of the topics and are better motivated. Further, they obtain improved communication and co-operation skills. Another advantage is that the approach is appreciated by our female students, which has led to a higher percentage of female students in this curriculum compared to our other computer science curricula.

As software applications grow larger and become more complex, program maintenance activities such as adding new functionality, debugging, and testing consume an increasing amount of available resources for software development. This is especially true for distributed systems communicating via message passing. In order to cope with this increased complexity, programmers need effective computer supported methods for decomposition and dependence analysis of programs. Program slicing is one method for such decomposition and dependence analysis. A program slice with respect to a specified variable at some program point consists of those parts of the program which potentially affect the value of that variable at the particular program point. A static slice is valid for all possible executions of a program while a dynamic slice considers only a particular execution of a program. In this paper we present a technique for dynamic slicing of distributed programs which computes accurate slices. We introduce the notion of distributed dynamic dependence graph (DDDG) which represents control, data and communication dependences in a distributed program. This graph is built at run time and used to compute dynamic slices of the program. A distributed dynamic slicer for ANSI-C programming language has been implemented on a parallel MIMD computer of type Parsytec GC/Powerplus with 128 PowerPC processors.

During the past ten years several variants of an analysis technique called program slicing have been developed. Program slicing has applications in maintenance tasks such as debugging, testing, program integration, program verification, etc. and can be characterized as a type of dependence analysis. A program slice can loosely be defined as the subset of a program needed to compute a certain variable value at a certain program position. A novel method for interprocedural dynamic slicing which is more precise than interprocedural static slicing methods and is useful for dependence analysis at the procedural abstraction level was given by M. Kamkar et al. (1992, 1993). It is demonstrated here how interprocedural dynamic slicing can be used to increase the reliability and precision of interprocedural data flow testing. The work on data flow testing reported by E. Duesterwald et al. (1992), which is a novel method for data flow testing through output influences, is generalized.>

This paper presents a method for semi-automatic bug localization, generalized algorithmic debugging, which has been integrated with the category partition method for functional testing. In this way the efficiency of the algorithmic debugging method for bug localization can be improved by using test specifications and test results. The long-range goal of this work is a semi-automatic debugging and testing system which can be used during large-scale program development of nontrivial programs. The method is generally applicable to procedural languages and is not dependent on any ad hoc assumptions regarding the subject program. The original form of algorithmic debugging, introduced by Shapiro, was however limited to small Prolog programs without side-effects, but has later been generalized to concurrent logic programming languages. Another drawback of the original method is the large number of interactions with the user during bug localization. To our knowledge, this is the first method which uses category partition testing to improve the bug localization properties of algorithmic debugging. The method can avoid irrelevant questions to the programmer by categorizing input parameters and then match these against test cases in the test database. Additionally, we use program slicing, a data flow analysis technique, to

An algorithmic program debugger for imperative languages is presented, with Pascal as an example case. This debugger extends the power of existing debuggers by providing an interactive debugging facility where errors can be localized semiautomatically. The debugger is activated on demand when the user discovers a symptom of an error as the result of some computation. This symptom presumably denotes a difference between the intended program behavior and the actual behavior. The proposed approach consists of three phases: program transformation, tracing, and debugging. The first phase transforms the source program into an internal representation which is appropriate, according to the Shapiro model, for algorithmic debugging. This phase produces an intermediate program which is free from side effects and loops. The program tracing phase generates trace information which builds an execution tree for the erroneous program. The debugging phase performs bug localization through a number of user interactions. This phase consists of pure algorithmic program debugging and program slicing.>