Face-to-face and online collaboration: appreciating rules and adding complexity

This paper reports how 6-8 year-old children build, play and share video-games in an animated programming environment. Children program their games using rules as creative tools in the construction process. While working both face-to-face and remotely on their games, we describe how they can collaboratively come to explain phenomena arising from programmed or 'system' rules. Focusing on one illustrative case study of two children, we propose two conjectures. First, we claim that in face-to-face collaboration, the children centre their attention on narrative, and address the problem of translating the narrative into system rules which can be =programmed‘ into the computer. This allowed the children to debug any conflicts between system rules in order to maintain the flow of the game narrative. A second conjecture is that over the Internet children were encouraged to add complexity and innovative elements to their games, not by the addition of socially-constructed or 'player' rules but rather through additional system rules which elaborate the mini-formalism in which they engaged. This shift of attention to system rules occurred at the same time, and perhaps as a result of, a loosening of the game narrative that was a consequence of the remoteness of the interaction

Parallelization of an object-oriented FEM dynamics code: influence of the strategies on the Speedup

This paper presents an implementation in C++ of an explicit parallel finite element code dedicated to the simulation of impacts. We first present a brief overview of the kinematics and the explicit integration scheme with details concerning some particular points. Then we present the OpenMP parallelization toolkit used in order to parallelize our FEM code, and we focus on how the parallelization of the DynELA FEM code has been conducted for a shared memory system using OpenMP. Some examples are then presented to demonstrate the efficiency and accuracy of the proposed implementations concerning the Speedup of the code. Finally, an impact simulation application is presented and results are compared with the ones obtained by the commercial Abaqus explicit FEM code

Contemporary developments in teaching and learning introductory programming: Towards a research proposal

The teaching and learning of introductory programming in tertiary institutions is problematic. Failure rates are high and the inability of students to complete small programming tasks at the completion of introductory units is not unusual. The literature on teaching programming contains many examples of changes in teaching strategies and curricula that have been implemented in an effort to reduce failure rates. This paper analyses contemporary research into the area, and summarises developments in the teaching of introductory programming. It also focuses on areas for future research which will potentially lead to improvements in both the teaching and learning of introductory programming. A graphical representation of the issues from the literature that are covered in the document is provided in the introduction

Social Consequences of Commitment

This paper begins with a detailed computational introduction to a classic ACE model: an evolutionary prisoner's dilemma. The paper presents a simple but fully coded object oriented implementation of this model. (We use the Python programming language, which is shown to be a natural ally for ACE research). Using these tools, we demonstrate that player type evolution is affected by cardinal payoffs. We then explore a possible social benefit to commitment, where 'commitment' denotes an unwillingness to surrender a reciprocal strategy.ACE; agent-based; computational economics; iterated prisoner's dilemma; evolutionary prisoner's dilemma; commitment

Simulating Evolutionary Games: A Python-Based Introduction

This paper is an introduction to agent-based simulation using the Python programming language. The core objective of the paper is to enable students, teachers, and researchers immediately to begin social-science simulation projects in a general purpose programming language. This objective is facilitated by design features of the Python programming language, which we very briefly discuss. The paper has a 'tutorial' component, in that it is enablement-focused and therefore strongly application-oriented. As our illustrative application, we choose a classic agent-based simulation model: the evolutionary iterated prisoner's dilemma. We show how to simulate the iterated prisoner's dilemma with code that is simple and readable yet flexible and easily extensible. Despite the simplicity of the code, it constitutes a useful and easily extended simulation toolkit. We offer three examples of this extensibility: we explore the classic result that topology matters for evolutionary outcomes, we show how player type evolution is affected by payoff cardinality, and we show that strategy evaluation procedures can affect strategy persistence. Social science students and instructors should find that this paper provides adequate background to immediately begin their own simulation projects. Social science researchers will additionally be able to compare the simplicity, readability, and extensibility of the Python code with comparable simulations in other languages.Agent-Based Simulation, Python, Prisoner's Dilemma

Implementing distributed concurrent constraint execution in the CIAO system

This paper describes the current prototype of the distributed CIAO system. It introduces the concepts of "teams" and "active modules" (or active objects), which conveniently encapsulate different types of functionalities desirable from a distributed system, from parallelism for achieving speedup to client-server applications. The user primitives available are presented and their implementation described. This implementation uses attributed variables and, as an example of a communication abstraction, a blackboard that follows the Linda model. Finally, the CIAO WWW interface is also briefly described. The unctionalities of the system are illustrated through examples, using the implemented primitives