International Journal of Engineering Education Vol. 30, No. 4, pp. 929–936, 2014 Printed in Great Britain
0949-149X/91 $3.00+0.00 # 2014 TEMPUS Publications.
Context-Aware Generative Learning Objects for Teaching Computer Science* ˇ IUS and RENATA BURBAITE˙, KRISTINA BESPALOVA, ROBERTAS DAMASˇEVIC VYTAUTAS SˇTUIKYS Software Engineering Department, Kaunas University of Technology, Studentu 50, Kaunas, Lithuania. E-mail:
[email protected],
[email protected],
[email protected],
[email protected]
The paper introduces context-aware Generative Learning Objects (GLOs) to support wide-scale reusability and automatic adaptability in teaching Computer Science (CS) topics. We introduce the theoretical background of the approach to support adaptation through transformations based on the principles of Design-for-Reuse and Design-with-Reuse, which are well known in Software Engineering (SWE), and validate the approach in the robotics-based CS course. We automatically adapt GLOs to the specific context of teaching using transformation tools (refactoring tool and metalanguage processor) to transform a set of context-aware GLOs into usable LOs within the educational Arduino robotics environment. Keywords: generative learning object; context modelling; e-learning; computer science education
1. Introduction Learning Object (LO) research is a wide topic in elearning. The term defines the course-independent learning content to support interoperability and reusability in the domain. Therefore, Computer Science (CS) teaching researchers and practitioners have adopted and widely use the term too. Though there is no a precise definition of LO (e.g. the IEEE standard defines it as ‘‘any digital entity, which can be used, reused, or referenced during technology supported learning’’ [1]), since 1994, when the concept of LO has been introduced by Wayne Hodgins, it has played a significant role to systemize and standardize the teaching content worldwide. Among multiple ideas and approaches proposed (see, e.g. [2]), the generative learning objects (GLOs) should be mentioned in the first place. Boyle et al. [3, 4] have introduced the GLO concept and approaches based on it aiming to enforce the reuse potential in e-learning. They have identified GLOs as ‘‘the next generation’’ LOs. Here, the term ‘generative’ should be understood as a property of the learning content (or its sequence) to be produced and handled either semi-automatically, or automatically under the support of some technology. The contribution of GLOs in e-learning is that an extremely wide community involved in learning has received an evident sign to shift from the component reuse model (typically it relates to the use of LOs) to the generative reuse model, which relates to the use of GLOs. More specifically, the first model focuses mainly on design, storing, search and manual adaptation of LOs before using them in a specific teaching context. * Accepted 6 January 2014.
While the second model additionally opens the way not only to produce the content semi-automatically, or even automatically; it also enables to combine the generation along with the automatic adaptation. In fact, the generative technology used pre-defines those capabilities of GLOs. In contrast to other researchers [3, 4] who use the GLO Maker tool (constructed on the template technology basis), we use meta-programming [5] as a generative technology that allows achieving the aims of automation. The importance of context has been underscored by numerous researchers. Decontextualized courses lead to inert knowledge, i.e. the knowledge that can be reproduced, but not applied to real-world problem solving while the context information can provide learning authenticity and immediacy of purpose [6]. Usually context-awareness can provide directed links to learner-relevant learning materials, to affect the sequence and presentation of the material, and to provide the additional information for in depth learning. There are two general approaches for adapting learning content. The first approach [7] tries to adapt learning content to the requirements and needs of individual learners (content adaptation or macroadaptation). It filters the learning content based on learner’s competencies and knowledge requirements; however, it considers only static elements of the context, which does not allow for deeper adaptation of learning processes. The second approach [8] focuses on delivering the most appropriate effective sequence of learning content (link-level adaptation or micro-adaptation). It allows for a wide contextualization of LOs on the personal level, but usually neglects the institutional learning context. 929
930
The pedagogical theories to support contextaware LOs include Kolb’s Innovative Learning [9], which emphasizes abstract (Abstract Conceptualization, AC) vs. concrete (Concrete Experience, CE) dichotomy of information comprehension and its assimilation by Active Experimentation (AE) or Reflective Observation (RO), as well as introduces the convergent (AC/AE), divergent (CEI/RO), assimilative (RO/AC), and accommodative (AE/ CE) learning styles, which represent individual differences in the way of people comprehend and process information. As every individual has a preferred learning style and usually applies each learning mode to some extent only, the learner’s preferred learning style is important contextual information that helps to deliver and map knowledge to mental models more efficiently. Another pedagogical theory, the constructivism of Piaget [10], emphasizes ‘‘learning through action’’, ‘‘learning-by-doing’’ or ‘‘learning-bydesign’’ [11], which allows building knowledge progressively through one’s practical experience. A variant of constructivism, called constructionism [12], focuses on knowledge reconstruction by students using meaningful artefacts such as educational robots. The latter is especially suitable for engineering education where real physical (tangible) entities can be used as LOs [13, 14]. The created artefacts can be used (or reused) as models and visual aids for further learning [15]. Thus the technical characteristics of the physical entity provide another dimension of context. In Project-Based Learning (PBL) [16], students affirm concepts learned through generation of tangible entities as a representation of their understanding, which can be used to engage and invoke competition and teamwork, to enhance creativity, to facilitate cognitive abilities and self-confidence as well as to feed back the student’ emergent knowledge [17, 18]. Teachers act as facilitators of active knowledge construction by learners rather than passive transmission by teachers, and the learning process takes place in a collaborative environment of GLOs and robotics kits [19]. The aim of this paper is to introduce a new type of GLO, that is, context-aware meta-programmingbased GLOs to support wide-scale reusability and automatic adaptability in teaching CS topics. The tasks we formulate are as follows: (i) to compose a general framework by using which we could be able to achieve the aim, (ii) to introduce the theoretical background of the approach to support adaptation through transformations, and (iii) to validate the approach in real setting of CS teaching. Main contribution of the paper is: (i) the adoption of the well-known in SWE reuse paradigm that is based on the principles of Design-for-Reuse (DfR)
Renata Burbaite˙ et al.
and Design-with-Reuse (DwR) and its application for e-learning; (ii) design and automated adaptation of GLOs to the specific context using transformation tools (refactoring and a meta-language processor) to transform a set of models (context-aware, meta-programming-based such as multi-stage GLO) into usable LOs within the robotics educational environment.
2. Reuse-based framework to design and use context-aware GLOs At an abstract level, e-learning can be identified as the interaction among the following components (with the tightly integrated feedback links): (i) pedagogy-driven activities, (ii) technology-driven processes, (iii) knowledge transfer channels with actors involved, (iv) a set of tools used (they can also be treated as technology), and (v) the pedagogical outcome [19]. GLOs and their derivative instances LOs stand for the instrument to supply the teaching content. The latter is for enabling the interfacing, integrating and functioning of the components within the whole e-learning system. No matter what form we are able to select for representing the teaching content, either LO, GLO or somewhat else, the whole cycle includes the following processes: to design, to search, to adapt and to use the content. With respect to reusability in mind (this vision prevails in e-learning, too (see, e.g. [20]), the processes should be handled and managed as effectively as possible. Here, for this purpose, we introduce and apply the reuse-based framework borrowed from the SWE domain, which is known as design-for-reuse (DfR) and design-with-reuse (DwR) [21]. We have adapted it to our aims (see Fig. 1). Note that there are different terms of the framework (such as a twin life-cycle model [21], Product Line Engineering [22], or software families [23]) to express similar meaning. DfR aims at understanding the e-learning domain (e.g. CS) through its modelling. The modelling should be guided by the clearly stated goal. In our case, the goal is to extract the relevant data and represent them into some generic form (e.g. Feature Diagram usually considered as a domain model [24]) to facilitate the construction of GLOs. At this level, the domain model describes two general aspects: domain commonality and domain variability. In [19], we have introduced the e-learning Variability (LV) as a composition of Pedagogical (PV), Social (SV), Content (CV), Technological (TV) and Interaction (IV) Variability: LV = PV SV CV TV IV. Here, variability is understood as an attribute to indicate the existence of variants for the subject
Context-Aware Generative Learning Objects for Teaching Computer Science
(pedagogy, sociality, etc.), and ‘’ means some kind of composition. We define the context as an implicit or explicit factor influential to delivering the content for teaching. As the PV and SV, in fact, are those factors, we accept them as a teaching context here. The basic assumption is that the context may have variants too (e.g. types of the pedagogical model such as problem-based, project-based; student social variability such as beginner, intermediate, etc.). Therefore, we can speak also about the context variability as well. As any kind of variability we are able to express through higher-level parameters (see case study, for details), the DfR activity results in context-aware GLOs. Further, when it is appropriate, we refer to context-aware GLOs as the GLOs for simplicity. GLO is the executable specification to support wide range reuse for the DfR activity. The specification specifies a set of LO instances that are coded using meta-language as the implementation technology. More specifically, we pre-program the anticipated (via analysis) e-learning variability. The latter gives us the capability for adaptation by selecting the appropriate variant from the available set through transformation and generation. In this paper, we do not focus so much on how to build such a specification (a general understanding can be learned from [5]). Instead, here we accept the GLOs as input data which specify the initial space for the possible adaptation. Therefore, our focus here is on how to automatically adapt the GLOs to different context of use. The key for the automatic adaptation is a pre-programmed context which is provided along with the GLO specification. Note that we categorize the pre-programmed context as the priority-based for tool/process managing (considered here) and the teaching-oriented (considered above) ones. The second part of the framework (i.e. DwR, see Fig. 1) is about adaptation. In general, adaptation of the content is a big problem in e-learning. Even the well-designed content, for example, extracted from digital libraries, requires adaptation to the new context of use. There are many reasons for that as follows: rapidly changing the social context, the need to introduce innovations in syllabus, to transfer the content from one learning environment to another, to be a more competitive teacher/educator, to enforce the students’ engagement, etc. Especially it is true for CS teaching. Our adaptation model has two phases. We implement the first phase using the automatic refactoring tool MP-ReTool managed by the context. It aims at narrowing the context-aware (CA) GLO by refactoring (structural transformations only) it into the so-called multi-stage GLOs that, in fact, is the
931
Fig. 1. A framework to adapt the known reuse paradigm (DfR/ DwR) for e-learning domain.
adaptation for the teacher’s context. We refer to the stage as an abstraction to re-arrange the structure of a GLO so that to enable its partial evaluation by staging when processed. Refactoring of GLO is a transformation process that alters the structure of a GLO without altering its observable behaviour (note that this definition has been adopted from [25], where program refactoring is discussed; here, we treat GLO as a higherlevel program (meta-program). Teacher, before using the tool, identifies the number of stages needed, i.e. identify a strategy for adaptation. The tool, on the basis of the pre-programmed context for staging and preliminary teacher’s needs, produces the k-stage GLO. The k-stage GLO is a (k-1)-stage GLO generator. The latter is a higher-level specification containing information to support the adaptation by staging, i.e. narrowing the space for selecting variants. At the second phase, using a re-factored GLO as an input for the meta-language processor (PHP compiler in our case), teacher or student is able to automatically derive the needed LO. Before that, the adequate parameter values should be identified and submitted by the user. Therefore, the adaptation is two-phase process: firstly, we create a multistage GLO which is seen as a higher-level (or deep in terms of [26]) adaptation for the teacher’s needs, and secondly, the lower-level adaptation by deriving the concrete LO for the student’s needs.
3. Case study: use of GLOs within the Arduino-based environment We use two different robot-based teaching environments: Lego NXT and Arduino [27] to teach CS
932
Renata Burbaite˙ et al.
topics. The aim of this case study is to show on how the theoretically-grounded approach works in practice. 3.1 CS teaching methodology We have selected 3 tasks to demonstrate the interdisciplinary teaching of CS using the given environment as follows: Text scrolling on LCD, Light follower and Traffic light tasks. We describe the latter in more details, though all has been realized completely according to the proposed methodology. Our initial data is the original hand-made 1-stage GLOs (or simply GLO). It is a highly reusable entity. It may cover the needs of different SC teachers, different levels of teaching, or even different educational environments (this capability has not yet been implemented). Working with the MPReTool (meaning meta-program refactoring tool) and the original specification, the teacher (most
likely along with students because the tool is automatic having user-friendly interfaces) is able to provide some experiments to construct a suitable k-stage specification (k = 2, 3, 4). After that, he (she) works with the meta-language processor (PHP interpreter in our case) applied to the k-stage GLO. The process is k-staged. The user’s (teacher’s or students’) intervention between stages is minimal. The user needs to select the parameter values from menu only. What value to select is the matter of teaching goal and problem understanding. Thus, adaptation is automatic, except for the setting of parameter values. 3.2 Experimental results with selected tasks In Table 1, we have presented main characteristics of the hand-made original GLO specification for one task. Parameters and their values are at the focus here. As teaching has had a concrete objective (to teach loops and nested loops), its parameter
Table 1. Traffic light task: characteristics of original GLO GLO characteristics
Name of parameters (in bold) and their values (in brackets): for abbreviations, full set of values and meaning, see legend below
Context-based parameters
CO (LN); LA (CT; PS); LL (BG; IT; AD); M (PR; PB); LP (SL; MD; F)
Content-based parameters
A (FT; DB); I (NO; 1; 2; 3); O (1-2-3; 1-3-2; 2-1-3; 2-3-1; 3-1-2; 3-2-1); T (500; 1000; 1500); T1 (100; 200; 300); N (3; 4; 5)
MDT/MDG, FP LOC in PHP
11 / 120, 62
Possible # of LOs derivable from the GLO for adaptation and use
12296333 = 5832
Legend. Context-based parameters: CO—curriculum objective (LN—loops and nested loops), LA—learning activity (Case study (given by Teacher) – CT; Practise (done by Learner)—PS), LL—learner’s previous knowledge level (Beginner—BG; Intermediate—IT; Advanced— AD), LP—learning pace (Slow—SL, Medium—MD, Fast—F), M—learning method (Project-based—PR; Problembased—PB). Content-based parameters: A—algorithm’s type (FT—fixed time control; DB—demand button control), I—input pin on Arduino for button (NO—without button), O—output pins on Arduino for red, yellow and green LEDs, T—duration of light phase in ms, T1— duration of a warning signal in ms, N—number of warning signals, MDT/MDG—Interface (textual—T and graphical—G), respectively, FP—functional part; LOC—Lines of code (practical complexity measure).
Table 2. Characteristics of k-stage GLOs obtained through refactoring using MP-ReTool # of stages k = 4 Parameters at stage
# of stages k = 3 Parameters at stage
# of stages k = 2 Parameters at stage
GLOs and their characteristics
4
3
2
1
3
2
1
2
1
Traffic light
CO
LA, M
I, A, LL, LP
O, T, T1, N
CO
LA, M , I, A, LL, LP
O, T, T1, N
CO, LA, M, I, A, LL, LP
O, T, T1, N
MDG/FP LOC in PHP
9/ 262
17/215
34/143
38/66
9/233
48/155
38/66
53/154
38/66
# of GLOs
1
4
9
162
1
36
162
36
162
# of LOI*
149162 = 5832
136162 = 5832
33162 = 5832
* Note that the number of LOI is Cyclomatic Complexity Index (CCI) as applied to GLOs that we have adapted from the McCabe’s Cyclomatic Index [28].
Context-Aware Generative Learning Objects for Teaching Computer Science
933
Fig. 2. The derived LO instance in C++ (on left) and running the task by Arduino (on right).
(CO) value (LN) was pre-defined uniquely. The other parameters specify the e-learning variability with multiple variants of values. The second line (read from the bottom) provides the size of the GLO (in PHP LOC). The last line specifies the space of variants for adaptation. Note that the latter is defined as a product of all independent parameter values. In Table 2, we have presented main characteristics obtained after applying multiple refactoring and multiple instance generation. Note that the context-based parameter names and their values are common for all tasks. However, the contentbased parameters are different. For conciseness, we have omitted deciphering of abbreviations for the first two tasks. Parameter permutation among the pre-defined number of stages (4, 3, or 2) is the result of operating on context-based parameter priority information. There one can see (i) how narrowing of the search space for adaptation takes place and (ii) how parameters were permuted among stages. In Fig. 2, we present a snapshot of Traffic lights task in operation fuelled by LO to teach nested loops in C++ language. This LO has been derived from 2-stage GLO with the following parameter values (see the right side of Table 1). Six comment lines at the top (see the left side) are automatically generated metadata of the LO for the external library.
4. Evaluation We evaluate the approach from two perspectives (technological and pedagogical) as follows. For the technological evaluation, we evaluate complexity of the given (original) GLO and complexity changes introduced by the automatic refactoring using Cognitive Difficulty (CD) metric as applied to metaprograms [5]. The metric is calculated as CD ¼ maxðjDj; N1 ; N2 Þ, where |D| – the total number of parameters in the meta-program (i.e. GLO) interface, N1 and N2 – the total number of operators and operands, respectively. Note that |D| is not always the same as N2 because different metafunctions may have the same parameters. Figure 3(a) shows that CD diminishes for the 1stage GLO when refactoring is applied (due to a part of parameters were evaluated in highest stages) as compared to the hand-made GLO. However, CD increases with the increase of the number of stages (see Fig. 3(b)) due to implementation specificity (in PHP, there is the need for nested functions and arguments). For the pedagogical evaluation, we use categories in the cognitive domain of Bloom’s taxonomy [29] and extract the cognitive processes as defined by [30] for our learning task. We evaluate the processes by a typical number of parameters for the task cognition and compare this number with the Miller’s cognitive
934
Renata Burbaite˙ et al.
Fig. 3. CD measures: a) complexity of 1-stage hand-made GLO against the one after automatic refactoring/ generating; b) refactoring-based complexity changes. Table 3. Traffic light task: Bloom’s taxonomy-based categories, processes and their evaluation using Miller’s metrics (7 2) Category
Description using the verb-subsets from [31]
Cognitive complexity expressed by a typical parameters (see Table 1) as compared to the Miller’s metric
Space # of LO instances for selection [min..max*]
Remember
recognize, recall
3 (O = {red, yellow, green})
1..6
Understand
interpret, exemplify, classify, summarize, infer, compare, explain
4 (O; T; T1; N)
1..162=6333
Apply
execute, implement
5 (O; T; T1; N; A-I)
1..648=63334
Analyse
differentiate, organize, attribute
5 (O; T; T1; N; A-I)
1..648=63334
Evaluate
check, critique
6 (O; T; T1; N; A-I; M)
1..1296=633342
Create
generate, plan, produce
7 (O;T;T1; N; A-I; M; LL-LP)
1..2916=633392
* This item was calculated using all possible values of the identified typical parameters to learn the task.
complexity bounds derived from 7 2: 9 (over-complex). The results are given in Table 3.
5. Discussion In LO research, GLO is a technological shift from the component reuse model to the generative reuse model, where the technology-driven generation of the teaching content is at the focus. The technology used pre-defines the generative capabilities of GLOs. In this paper, we have discussed GLOs from the perspective of automatic adaptation. We have implemented the adaptation through refactoring and generation. We have presented our analysis as a part of the well-known reuse paradigm (i.e. DfR—design for reuse and DwR—design with reuse) adopted from the SWE domain. In our approach, the adaptation is driven by the preprogrammed context information. It is the reason why we use the term context-aware GLOs.
The basic results of the paper are as follows: 1) the scheme for adapting the paradigm (DfR and DwR) for the e-learning domain; 2) the stage-based automatic refactoring of GLOs, which is driven by the context and theory related to refactoring, generation and adaptation of GLOs to the context of their use and 3) a case study demonstrating capabilities and practical benefits in using the approach in the real setting to teach CS. The approach (GLO itself) can benefit to teaching CS in the following aspects: (i) It is independent upon the educational environment (it might be the PC, robot, or smartphone); however, the task type to demonstrate programming concepts is highly dependable on the selected environment; (ii) The GLOs are independent upon the type of meta- and target languages; (iii) It is possible to teach not only how to construct programs using the approach, but also to deliver modern concepts such as automatic
Context-Aware Generative Learning Objects for Teaching Computer Science
program generation, meta-programming, program refactoring, etc. in teaching of CS topics; (iv) It is possible to provide the interdisciplinary knowledge for students using the robot-based environment, because CS programming courses are deeply rooted with control programs that operate within different physical devices; (v) GLO might be also seen as a modern LO per se for CS teachers and educators in the first place as well as for the advanced students; (vi) The use of robot-based environments has improved the students’ learning performance by 3–15 % depending on engagement levels [32] and gender. We have presented more results on pedagogical evaluation in [14, 19]. The approach has a few limitations too as follows: (i) It is not an easy task to develop the initial GLO specification; the process requires a deep knowledge to provide analysis, modelling and higher-level coding; (ii) As the search space for automatic adaptation is predefined by the anticipated variability, the new requirements for change (in terms of the necessity to introducing new parameters) require some re-design of the initial specification; (iii) The approach is not yet matured enough and extensive research along with widened applications in the other real settings should be on the focus.
6. Conclusions 1.
2.
3.
As a context-aware GLO has enough descriptive information, it is possible to automatically generate metadata (e.g. for storing, searching and composing of LO sequences) along with LO instances derived from the GLO specification. The refactoring tool we have developed transforms the initial context-aware GLO into its multi-stage format so that to partially evaluate the specification and to make the subsequent adaptation easier. Then, using the meta-language processor, teacher is able to generate lower-stage GLOs, which are already adapted to his/her context. In the next generation-adaptation phase, teacher or learner through managing the pre-programmed learner’s context is able to produce the instance suitable for the concrete learning and teaching context. The robot-based environments, which are fueled by the adopted LO instances, enable to improve the students’ engagement in learning CS (due to the real visualization), to enhance
935
their creativity (due to the interdisciplinary aspects) and to increase learning performance (due to the overall factors).
References 1. LTSC (Learning Technology Standards Committee), IEEE Standard for Learning Object Metadata, IEEE Standard 1484.12.1, IEEE, N.Y., 2002. 2. A. A. Koohang, Learning Objects 1: Theory, Praxis, Issues, and Trends, 2, Informing Science, 2007. 3. T. Boyle, D. Leeder and H. Chase, To boldly GLO – towards the next generation of learning objects, World Conference on eLearning in Corporate, Government, Healthcare and Higher Education, 2004, pp. 28–33. 4. R. Morales, D. Leeder and T. Boyle, A case in the design of generative learning objects (GLOs): applied statistical methods, Proc. of World Conf. on Educational Multimedia, Hypermedia and Telecommunications, 2005, pp. 2091–2097. 5. V. Sˇtuikys and R. Damasˇevicˇius, Meta-Programming and Model-Driven Meta-Program Development, Springer, 2013, p. 326. 6. A. Schmidt, Impact of context-awareness on the architecture of learning support systems, in C. Pahl (Ed.), Architecture Solutions for E-Learning Systems, Hershey, PA: Information Science Reference, 2008, pp. 306–319. 7. D. Woelk and S. Agarwal, Integration of e-learning and knowledge management, World Conference on E-Learning in Corporate, Government, Health Institutions, and Higher Education, 1, 2002, pp. 1035–1042. 8. O. C. Park and J. Lee, Adaptive instructional systems, in D.H. Jonassen (Ed.), Handbook of research for educational communications and technology, Lawrence Erlbaum, Mahwah, N. J., 2004, pp. 651–684. 9. D. A. Kolb, Experiential learning: Experience as the source of learning and development, Prentice Hall, 1984. 10. J. Piaget, The origins of intelligence in children, Basic Books, New York, 1953. 11. L. E. Carlson and J. F. Sullivan, Hands-on Engineering: Learning by Doing in the Integrated Teaching and Learning Program, The International Journal of Engineering Education, 15(1), 1999, pp. 20–31. 12. I. Harel and S. Papert, Constructionism, Norwood: Ablex Publishing, 1991. 13. R. Burbaite, V. Stuikys and R. Damasevicius, Educational Robots as Collaborative Learning Objects for Teaching Computer Science, Int. Conference on System Science and Engineering, Budapest, Hungary, 2013, pp. 211–216. 14. R. Burbaite˙, R. Damasˇevicˇius, and V. Sˇtuikys, Using Robots as Learning Objects for Teaching Computer Science, 10th IFIP World Conference on Computers in Education, Torun, Poland, 2013. 15. I. M. Verner and D. J. Ahlgren, Robot Projects and Competitions as Education Design Experiments, Intelligent Automation & Soft Computing, 13(1), 2007, pp. 57–68. 16. P. Blumenfeld, E. Soloway, R. Marx, J. Krajcik, M. Guzdial and A. Palinscar, Motivating project-based learning: Sustaining the doing, supporting the learning, Educational psychologist, 26(3–4), 1991, pp. 369–398. 17. E. D. Graaff and A. Kolmos, Characteristics of problembased learning, International Journal of Engineering Education, 19 (5), 2003, pp. 657–662. 18. F. Ramos and E. Espinosa, A self-learning environment based on the PBL approach: an application to the learning process in the field of robotics and manufacturing systems. The International Journal of Engineering Education, 19(5), 2003. 19. V. Sˇtuikys, R. Burbaite˙ and R. Damasˇevicˇius, Teaching of Computer Science topics using meta-programming-based GLOs and LEGO robots, Informatics in Education, 12(1), 3013, pp. 125–142. 20. K. Johnson and T. Hall, Granularity, reusability and learning objects, Learning objects: Theory, praxis, issues, and trends, 2007, pp. 181–207.
936
21. J. Sametinger, Software Engineering with Reusable Components, Springer, New York, 1997. 22. K. Pohl, G. Bockle, and F. van der Linden, Software Product Line Engineering, Springer-Verlag, 2005. 23. D. L. Parnas, On the Design and Development of Program Families, Software Engineering, IEEE Transactions, 2(1), 1976, pp. 1–9. 24. K. C Kang, S. G. Cohen, J. A. Hess, W. E. Novak and A. S. Peterson, Feature-oriented domain analysis (FODA) feasibility study, CMU/SEI-90-TR-21, Carnegie-Mellon Univ, Software Engineering Inst., 1990. 25. M. Fowler, Refactoring: Improving the Design of Existing Code, Addison-Wesley Longman Publishing Co, 1999. 26. T. Boyle and A. Ravenscroft, Context and deep learning design, Computers & Education 59(4), 2012, pp. 1224–1233. 27. M. McRoberts, Beginning Arduino, Apress, 2010. 28. T. J. McCabe, A Complexity Measure, IEEE Transactions on Software Engineering, 1976, pp. 308–320.
Renata Burbaite˙ et al.
29. L. Anderson and D. A. Krathwohl, Taxonomy for Learning, Teaching and Assessing: A Revision of Bloom’s Taxonomy of Educational Objectives, New York: Longman, 2001. 30. G. Miller, The Magic Number Seven, Plus or Minus Two: Some Limits on Our Capacity for Processing Information, The Psychological Review, 63(2), 1956, pp. 81–97. 31. S. Martin, M. Vallance, P. van Schaik and C. Wiz, Learning spaces, tasks and metrics for effective communication in Second Life within the context of programming LEGO NXT MindstormsTM robots: towards a framework for design and implementation, Journal of Virtual Worlds Research, 3(1), 2010, pp. 3–12. ´ . Vela´zquez-Iturbide, Pedagogi32. J. Urquiza-Fuentes and J. A cal effectiveness of engagement levels–a survey of successful experiences, Electronic Notes in Theoretical Computer Science, 224, 2009, pp. 169–178.
Renata Burbaite˙ is a PhD student at Software Engineering Department of Kaunas University of Technology (KTU) and a teacher of Computer Science (CS, Informatics) at Gymnasium. She also provides teaching of students in Informatics at KTU. Her research interests relate to the e-learning domain that includes the use of meta-programming-based Generative Learning Objects and Educational Robots to teach CS topics. She is a member of Interest Group of Informatics Teachers. Kristina Bespalova is a PhD student at Software Engineering Department of Kaunas University of Technology (KTU). Her research interests are e-learning and formal methods in computer science education. Robertas Damasˇevicˇius is a Professor at Software Engineering Department, Kaunas University of Technology (KTU). He received his PhD (2005) degree in informatics engineering from KTU. Currently he teaches robotics and software maintenance courses. His research interests include program transformation, design automation and software generation. Currently he is a supervisor of five PhD students. He is also member of ACM and IEEE. Vytautas Sˇtuikys is a Professor of Software Engineering Department at Kaunas University of Technology and holds the degree of Habilitate Doctor of Science (1992). His research interests include system design methodologies based on reuse and automatic program generation and transformation, and their applications in e-learning. He is author of about 100 papers in this area. Currently he is a head of research group at KTU and a supervisor of three PhD students. He is a member of ACM and IEEE.
