Kristina Bespalova

Model-driven processes and tools to design robot-based generative learning objects for computer science education

In this paper, we introduce a methodology to design robot-oriented generative learning objects (GLOs) that are, in fact, heterogeneous meta-programs to teach computer science (CS) topics such as programming. The methodology includes CS learning variability modelling using the feature-based approaches borrowed from the SW engineering domain. Firstly, we define the CS learning domain using the known educational framework TPACK (Technology, Pedagogy And Content Knowledge). By learning variability we mean the attributes of the framework extracted and represented as feature models with multiple values. Therefore, the CS learning variability represents the problem domain. Meta-programming is considered as a solution domain. Both are represented by feature models. The GLO design task is formulated as mapping the problem domain model on the solution domain model. Next, we present the design framework to design GLOs manually or semi-automatically. The multi-level separation of concepts, model representation and transformation forms the conceptual background. Its theoretical background includes: (a) a formal definition of feature-based models; (b) a graph-based and set-based definition of meta-programming concepts; (c) transformation rules to support the model mapping; (d) a computational Abstract State Machine model to define the processes and design tool for developing GLOs. We present the architecture and some characteristics of the tool. The tool enables to improve the GLO design process significantly (in terms of time and quality) and to achieve a higher quality and functionality of GLOs themselves (in terms of the parameter space enlargement for reuse and adaptation). We demonstrate the appropriateness of the methodology in the real teaching setting. In this paper, we present the case study that analyses three robot-oriented GLOs as the higher-level specifications. Then, using the meta-language processor, we are able to produce, from the specifications, the concrete robot control programs on demand automatically and to demonstrate teaching algorithms visually by robots actions. We evaluate the approach from technological and pedagogical perspectives using the known structural metrics. Also, we indicate the merits and demerits of the approach. The main contribution and originality of the paper is the seamless integration of two known technologies (feature modelling and meta-programming) in designing robot-oriented GLOs and their supporting tools.

Refactoring of Heterogeneous Meta-Program into k-stage Meta-Program

The paper presents: (1) a graph-based theoretical background to refactoring a correct heterogeneous meta-program into its k-stage representation; (2) the refactoring method; (3) refactoring experiments with tasks taken from different domains, including real world tasks, such as meta-programs to teach Computer Science (CS) topics using educational robots. Refactoring meta-programs by staging enables to flexibly adapt them to the different context of use. To do that (semi-)automatically, we use the contextual information as a priority relation (e.g. highest, lowest, etc.) introduced within the meta-program specification. We implement the refactoring method using the so-called activating/de-activating label (index) to change the role of meta-language constructs at different stages. The contribution of the paper is: (1) applying the known (in programming) staging concept to heterogeneous meta-programming; (2) a theoretical background, properties and the method to solve tasks of this kind of refactoring. DOI: http://dx.doi.org/10.5755/j01.itc.43.1.3715

Stage-Based Generative Learning Object Model to Support Automatic Content Generation and Adaptation

The paper introduces a novel Generative Learning Object (GLO) model, the Stage-Based Model (SBM) to specify the learning content. New capabilities of the model are the content automatic generation and adaptation. Externally, our model has a similar structure as the known two-level generic models (i.e. metadata and content implementation). The internal structure, however, is quite different in both parts. The use of the external parameterization technology based on pre-programming predefines the internal structure. Furthermore, the structure is derived from the initial parameterized GLO model using the refactoring tool. The technology we use in both models is based on the parameter-function relationship so that to perform manipulations on parameters. Parameters represent metadata, while the relationship implements the content variability by pre-programming the possible changes in advance so that to create the space for adaptation. The SBM implements deep internal staging by allocating parameters and functions (further objects) into predefined stages according to the given context. For example, pedagogically related parameters (objectives, teaching model, etc.) have the highest priority and appear at the top stage while the others - at the remaining stages. Typically, objects in the initial GLO specification are active, i.e. are ready to perform the prescribed role when interpreted by adequate tools. In SBM, the top stage objects are active while the remaining are passive (not able to serve the prescribed role there). The essence of the approach is the stage-based de-activation and activation of the objects within the pre-programmed specification. That ensures the automatic stage-based generation and flexibility for adaptation. In this paper, we analyze the SBM capabilities, present a case study and extended results of using the approach to the robot-oriented teaching in computer science. We also provide the pedagogical evaluation of the approach.

Model-driven processes and tools to design GLO for CS education

The paper introduces processes and tools to design generative learning objects (GLO) through feature model (FM) transformations for CS education. In the first stage, to represent the variability of CS education, we apply feature-based modelling using FAMILIAR and SPLOT tools. In the next stages we present processes and newly developed tools to design GLO through high-level transformations. Case study demonstrates our methodology in ARDUINO-based e-learning environment.

Feature transformation-based computational model and tools for heterogeneous meta-program design

We propose an approach and tools for designing heterogeneous meta-program (MP) through feature model (FM) transformations. Tools implement the State Machine (ASM) computational model. Firstly, to map the problem domain FM onto the solution domain FM, we use FAMILIAR and SPLOT tools. Next, to perform Model-to-MP transformations, we use newly developed tools. We present the process-based framework and background of the approach along with a case study, experimental validation and evaluation. The main contribution of the paper is the ASM-based transformation model, its implementation algorithm to describe the functioning of the developed tools.

Generative Learning Object (GLO) Specialization: Teacher's and Learner's View

The paper introduces the stage-based specialization of the initial reusable GLOs treated as meta-programs. The aim is to support pre-programmed user-guided adaptation of the Computer Science (CS) teaching content within the educational robot environment. Specialization of GLOs by staging enables to flexibly (automatically) prepare the content at a higher level for the different contexts of use. We describe the approach along with the case study from the user’s perspective taking into account the specializer tool we have developed. The contribution of the paper is the staged specialization for the pre-programmed adaptation of the learning content.

Product variation sequence modelling using feature diagrams and modal logic

Variability aspects are at the core of software product family modelling approaches. In this paper, we extend the scope of variability modelling techniques through: (a) introducing a novel concept (variation sequences), which is an extension of Jaring and Boschs variability taxonomy; and (b) formalizing feature models. The paper presents: (1) formal definitions of basic feature modelling concepts; (2) formal description of variation sequences; (3) feature selection within variation sequences using graph colouring and modal logic notations; (4) implementing feature models using meta-programming techniques with a case study.

Personal Generative Library of Educational Resources: A Framework, Model and Implementation

We discuss the Personal Generative Library (PGL) concept that covers models to describe some structural, functional and managerial aspects. Since the concept, to some extent, was realized in our previous research, in this paper, we focus more on the managerial aspects. In this regard, we propose the feature model-driven approach to implement those aspects using meta-programming techniques. First, we present the basic idea and theoretical background of the approach. Then we discuss the PGL architecture, its functionality and management procedures that are supported by the developed meta-programs. We outline the process of designing meta-programs through the series transformations of feature models. The main contribution of the paper is the implementation of the concept itself that enables, to some extent, to resolve the well known problems: library scaling and excluding synonymy in search. Furthermore, we have extended the potential of generative reuse (meaning a higher extent of automation as compared to the component-based reuse) by applying it not only at the library entity level (a great deal of PGL items are generative learning objects (GLO)), but also at the whole library, i.e. its management level. Therefore, the approach enables the automatic formation of annotations for PGL entities and generation of queries to support managing procedures. We have approved the approach by presenting a case study and some experimental results. DOI: http://dx.doi.org/10.5755/j01.itc.45.4.14910

Methodology and Experiments to Transform Heterogeneous Meta-program into Meta-meta-programs

The paper analyzes transformation of a correct heterogeneous meta-program into 2-stage meta-programs. We propose a methodology and describe experiments to solve two tasks: 1) transformation of the 1-stage meta-program into the set of 2-stage meta-programs; 2) checking hypothesis of the transformation equivalence under given transformation rules and constraints. The experimental results have shown that introduced formalism, rules and models ensure correctness of transformations, extend reuse dimension to automatically adapt (through transformations) variants of programs/meta-programs to different contexts of use, enable to better understand meta-program development/change processes and heterogeneous meta-programming perse.

Robot-Oriented Generative Learning Objects: An Agent-Based Vision

The paper presents a juxtaposing of the robot-oriented generative objects (GLOs) with software (SW) agents and identifies the capabilities to introduce more intelligence to the educational environment based on those GLOs. The main contribution of the paper is the agent-based architecture of the system and its partial implementation, enabling to solve the prescribed tasks more efficiently (with a less user’s intervention and a higher robot’s accuracy). Also the case study and some experimental results are described.