iSTOA: Artefacts for mathematical interactive learning exercises

International audienceIn primary schools, mathematics teachers use support tools to introduce new concepts. The objective of these tools is to reinforce a mental representation of the newly introduced concept. Tools can be physical objects or paper-pen based. We call these tools artefacts. In computer assisted environments, such artefacts are not always clearly present, those environments focus on the nature of the exercises (drills, quiz). To realise environments in closer relation to classroom teaching, we propose to analyse and categorise such artefacts: we used pedagogical literature and we extracted artefacts used in teaching multiplication. We present our infrastructure and a list of artefacts in the multiplication realm

Proceedings of the 3rd Workshop on FAMIX and MOOSE in Software Reengineering (FAMOOSr'09)

International audienceThe goal of the FAMOOSr workshop is to strengthen the community of researchers and practitioners who are working in re- and reverse engineering, by providing a forum for building future research using Moose and FAMIX as shared infrastructure. Research should be collaborative and supported by tools. The increasing amount of data available about software systems poses new challenges for reengineering research, as the proposed approaches need to scale. In this context, concerns about meta-modeling and analysis techniques need to be augmented by technical concerns about how to reuse and how to build upon the efforts of previous research. That is why Moose is an open-source software for researchers to build and share their analysis, meta-models, and data. Both FAMIX and Moose started in the context of FAMOOS, a European research project on object-oriented frameworks. Back in 1997 Moose was as a simple implementation of the FAMIX meta-model, which was a language independent meta-model for object-oriented systems. However over the past decade, Moose has been used in a growing number of research projects and has evolved to be a generic environment for various reverse and reengineering activities. In the same time, FAMIX was extended to support emerging research interest such as dynamic analysis, evolution analysis, identifier analysis, bug tracking analysis, or visualization. Recent work includes analysis of software architecture and semantic annotations. Currently, several research groups are using Moose as a platform, or FAMIX as a meta-model, and other groups announced interest in using them in the future

XO educational software

This project aims to create an environment in which children\u27s play is utilized to let children teach themselves. Through this goal, the project will also contribute to One Laptop Per Child\u27s (OLPC) resources. Research and analysis of the situation at our target site, Nepal, was completed. After consulting with the OLPC organization, the team determined that developing an open source physics simulation game would be appropriate. The basis for this game, Squeak\u27s Journey, was then designed and partially implemented

Activity Report 2012. Project-Team RMOD. Analyses and Languages Constructs for Object-Oriented Application Evolution

Activity Report 2012 Project-Team RMOD Analyses and Languages Constructs for Object-Oriented Application Evolutio

Interactive and Live Program Construction

In the highly technological and advanced society we live nowadays, it is essential to explore new development approaches in order to increase the efficiency and flexibility with which software is built. Our work focuses on the design and conception of a live graphical environment to allow for incremental and interactive construction of web applications through visual manipulation interactions. Our research is introduced in the context of a prototype, Live Programming, that provides a style of incremental and agile development of web applications, allowing for efficient updates of code and data. However, the construction of a web application through the existing coding environment is still slow and not as flexible as one would wish. This is due to the fact that its user interface is based on text editors, resulting in a heavy reliance on computer code to build these applications. The goal of our work consists on the conception of a visual construction model and graphical environment that interacts with the Live Programming system, allowing to incrementally develop web applications through the manipulation of visual symbols on the screen. The user does not need to program: instead, our tool automatically generates code according to the user’s manipulation of the visual components. The user must then be able to visually define the data model, queries, logical operations and presentation views (for example, html pages). We aim, as well, at idealizing and proposing creative and convenient techniques to program visualization and methods to visually organize the structure of a program, in order to help the user comprehending the relationships between elements and their responsibility within the system. This way, developers leverage an agile and interactive approach to efficiently deal with increasingly demanding requirements throughout development

Adaptive object management for distributed systems

This thesis describes an architecture supporting the management of pluggable software components and evaluates it against the requirement for an enterprise integration platform for the manufacturing and petrochemical industries. In a distributed environment, we need mechanisms to manage objects and their interactions. At the least, we must be able to create objects in different processes on different nodes; we must be able to link them together so that they can pass messages to each other across the network; and we must deliver their messages in a timely and reliable manner. Object based environments which support these services already exist, for example ANSAware(ANSA, 1989), DEC's Objectbroker(ACA,1992), Iona's Orbix(Orbix,1994)Yet such environments provide limited support for composing applications from pluggable components. Pluggability is the ability to install and configure a component into an environment dynamically when the component is used, without specifying static dependencies between components when they are produced. Pluggability is supported to a degree by dynamic binding. Components may be programmed to import references to other components and to explore their interfaces at runtime, without using static type dependencies. Yet thus overloads the component with the responsibility to explore bindings. What is still generally missing is an efficient general-purpose binding model for managing bindings between independently produced components. In addition, existing environments provide no clear strategy for dealing with fine grained objects. The overhead of runtime binding and remote messaging will severely reduce performance where there are a lot of objects with complex patterns of interaction. We need an adaptive approach to managing configurations of pluggable components according to the needs and constraints of the environment. Management is made difficult by embedding bindings in component implementations and by relying on strong typing as the only means of verifying and validating bindings. To solve these problems we have built a set of configuration tools on top of an existing distributed support environment. Specification tools facilitate the construction of independent pluggable components. Visual composition tools facilitate the configuration of components into applications and the verification of composite behaviours. A configuration model is constructed which maintains the environmental state. Adaptive management is made possible by changing the management policy according to this state. Such policy changes affect the location of objects, their bindings, and the choice of messaging system

Structuring fault-tolerant object-oriented systems using inheritance and delegation

PhD ThesisMany entities in the real world that a software system has to interact with, e.g., for controlling or monitoring purposes, exhibit different behaviour phases in their lifetime, in particular depending on whether or not they are functioning correctly. That is, these entities exhibit not only a normal behaviour phase but also one or more abnormal behaviour phases associated with the various faults which occur in the environment. These faults are referred to as environmental faults. In the object-oriented software, real-world entities are modeled as objects. In a classbased object-oriented language, such as C++, all objects of a given class must follow the same external behaviour, i.e., they have the same interface and associated implementation. However this requires that each object permanently belong to a particular class, imposing constraints on the mutability of the behaviour for an individual object. This thesis proposes solutions to the problem of finding means whereby objects representing real-world entities which exhibit various behaviour phases can make corresponding changes in their own behaviour in a clear and explicit way, rather than through status-checking code which is normally embedded in the implementation of various methods. Our proposed solution is (i) to define a hierarchy of different subclasses related to an object which corresponds to an external entity, each subclass implementing a different behaviour phase that the external entity can exhibit, and (ii) to arrange that each object forward the execution of its operations to the currently appropriate instance of this hierarchy of subclasses. We thus propose an object-oriented approach for the provision of environmental fault tolerance, which encapsulates the abnormal behaviour of "faulty" entities as objects (instances of the above mentioned subclasses). These abnormal behaviour variants are defined statically, and runtime access to them is implemented through a delegation mechanism which depends on the current phase of behaviour. Thus specific reconfiguration changes at the level of objects can be easily incorporated to a software system for tolerating environmental faults

Groupware for Collaborative Tailoring

In everyday work, teamwork in the presence of the tools, the resources, and the processes that enable work is mostly transparent to the workers. They center their attention on performing work. However, a noticeable change in the work conditions, in the required quality of the product, or in the perceived results of work, may be experienced as a breakdown that brings teamwork to the center of attention. To deal with breakdowns it is currently common practice to include tailoring facilities in groupware systems. The extent to which these facilities are provided, and the way in which they are implemented, determine the power users have to change the groupware system. Determining these facilities has been the focus of most research on tailorability in CSCW. How collaborative tailoring (defined as, collaboration for and in tailoring) can be facilitated remains as yet undetermined. This thesis tackles the problem of the lack of computer support for dis- tributed team members that need to perform tailoring in the context of team- work. The challenge of tailoring in the context of teamwork is to understand and support the needs of the group members, from the moment they encounter a breakdown during work until they have enacted the changes they deem nec- essary. This thesis is based on the premise of participation as a means to achieve acceptance of change. The approach to support collaborative tailoring of team- work presented in this thesis consists of a method for collaborative breakdown handling, a selection of specific groupware tools to be used for the deliberation activities defined by the method, and guidance in the form of scaffoldings for the application of the method. Breakdowns can also occur during tailoring. To deal with breakdowns that occur during tailoring, the method, the tools, and the scaffolding can be tailored. The proposed support for collaborative tailor- ing of teamwork is delivered as a stand-alone groupware system for collaborative tailoring. The system can be deployed along existing groupware systems, thus extending them with support for collaborative tailoring. This thesis exceeds related work by approaching tailoring of teamwork as a social system with a model that explains tailoring as the result of collaborative breakdown handling. The requirements of communication, collaboration, co- operation and coordination, and negotiation observed in the social system are supported by the corresponding technical system. The approach in this thesis is not limited to its application in a particular scenario or groupware system. The only requirement is that the target system/scenario can be tailored. The approach has been conceived to enable and support its own evolution as the result of its tailoring.Editorial: FernUniversität in Hagen. Informatik-Berichte Vol. 325.FernUniversität in Hage

Application of object-orientation to HDL-based designs

The increase in the scale of VLSI circuits over the last two decades has been of great importance to the development process. To cope with this ever­growing design complexity. new development techniques and methodologies have been researched and applied. The early 90's have witnessed the uptake of a new kind of design methodology based on Hardware Description Languages (HDL). This methodology has helped to master the possibilities inherent in our ability to manufacture ever-larger designs. However. while HDL based design methodology is sufficient to address today's standard ASIC sizes, it reaches its limits when considering tomorrow's design scales. Already. RISC processor chip descriptions can contain tens of thousands of HDLlines. Object-Oriented design methodology has recently had a considerable Impact in the software design community as it is tightly coupled with the handling of complex systems. Object-Orientation concentrates on data rather than functions since. throughout the design process. data are more stable than functions. Methodologies for both hardware and software have been introduced through the application of HDLs to hardware design. Common design constructs and principles that have proved successful in software language development should therefore be considered in order to assess their suitability for HDLs based designs. A new methodology was created to emphasise on encapsulation. abstraction and classification of designs. using standard VHDL constructs. This achieves higher levels of modelling along with an Improved reusability through design inheritance. The development of extended semantics for integrating Object-Orientation in the VHDL language is described. Comparisons are made between the modelling abilities of the proposed extension and other competing proposals. A UNIX based Object-Oriented to standard VHDL pre-processor is described along with translation techniques and their issues related to synthesis and simulation. This tool permitted validation of the new design methodology by application to existing design problems