key: cord-0869574-aca00fdi authors: Castro-Schez, J.J.; Glez-Morcillo, C.; Albusac, J.; Vallejo, D. title: An intelligent tutoring system for supporting active learning: a case study on predictive parsing learning date: 2020-09-17 journal: Inf Sci (N Y) DOI: 10.1016/j.ins.2020.08.079 sha: cfdcea771dc9f7cb11f21e134a810f4baa2be0d9 doc_id: 869574 cord_uid: aca00fdi The way in which people learn and institutions teach is changing due to the ever-increasing impact of technology. People access the Internet anywhere, anytime and request online training. This has brought about the creation of numerous online learning platforms which offer comprehensive and effective educational solutions which are 100% online. These platforms benefit from intelligent tutoring systems that help and guide students through the learning process, emulating the behavior of a human tutor. However, these systems give the student little freedom to experiment with the knowledge of the subject, that is, they do not allow him/her to propose and carry out tasks on his/her own initiative. They are very restricted systems in term of what the student can do, as the tasks are defined in advance. An intelligent tutoring system is proposed in this paper to encourage students to learn through experimentation, proposing tasks on their own initiative, which involves putting into use all the skills, abilities, tools and, knowledge needed to successfully solve them. This system has been designed, developed, and applied for learning predictive parsing techniques and has been used by Computer Science students during four academic courses to evaluate its suitability for improving the student’s learning process. formal language processing The importance and contribution of e-learning systems, used as a supplement in the learning process, is unquestionable in normal situations, and it is more obvious in cases of lockdown scenarios, such as the one we are experiencing now due to the CORONAVIRUS health crisis (COVID-19 pandemic). In this 5 context, providing e-learning systems and promoting their use was one of the major challenges addressed by many universities. Designing and developing systems which help or promote learning has always been a multi-disciplinary concern. Since the 90's these have been based on Information and Communication Technologies (ICT), spurred on by the rapid 10 evolution of the Internet and the state of the worldwide web today. There are numerous software systems aimed at assisting the teaching/learning process online (e.g. Learning Management System-LMS, Learning Content Management Systems-LCMS, Virtual Learning Environment-VLE, e-Learning) whose main purpose is to provide resources which enable skills, knowledge, and behaviors to 15 be acquired by means of study, instruction, reasoning and observation. These systems usually enable courses to be created and listed in online learning platform (Edx, Udacity, Udemy, Coursera, Khan Academy). An online course is made up of many different components and activities which, to a large extent, depend on the professor and the methodology he or she uses to 20 achieve the learning outcomes. Some of these are lessons (with varying degrees of complexity), readings, images, audios, videos, games, debates, surveys and tests. Moreover, there are various communication tools which participants on the course share such as emails and discussion forums, among others. These systems also provide components for scheduling activities and monitoring students' 25 progress in them. New components are being researched and developed, in order to make these systems more interesting to learners and also different from the others in the competition. These components focus on promoting active learning [1], i.e. they involve learners in their own learning process, and also on encouraging learners' 30 independence, i.e. they support the learning process without the need for instructor intervention. Ultimately, these systems should guarantee the autonomy of the learner, i.e. they should give the learner the opportunity to take charge of his or her own development. A major advance in this direction has been the development of Intelligent 35 Tutoring Systems (ITS) [2] [3] [4] [5] , which are systems that adapt to the needs of the learners and make recommendations to them on the next activities to be carried out in order to achieve the learning outcomes, thus guiding their learning process. With this type of systems, it is possible to implement active-participatory methodologies in the learning process. However, they are still limited in al- 40 lowing for learning through experimentation. This type of learning promotes active learning and learners' autonomy, making the learning process easy, passionate and creative. When a task, however difficult, is carried out on one's own initiative, all the capacities, skills, tools and knowledge necessary to solve it successfully are put to use. Thus, learning through experimentation provides 45 a number of advantages to the learners such as to acquire and refine control knowledge, to augment an incomplete domain theory and to refine an incorrect domain theory [6] . Currently, existing ITS turn this learning through experimentation into "knowing through doing". The following approaches can be found [7] : 50 First approach: Systems that extract and propose exercises taken from a repository to learners with the purpose that they solve them. Then, these systems check how good the solution given by the learners is and propose new exercises to them, which are always taken from the repository. These exercises are chosen on the basis of different criteria, such as their progress in the learning 55 process or the results obtained in previous exercises [4, [8] [9] [10] . Second approach: Systems that present to learners an exercise and how to solve it step by step (worked-examples). Then, these systems create similar exercises, usually changing data, which can be solved by following the learnt steps. In subsequent stages, they may also gradually fade out the number of 60 steps there are in the worked solution (faded worked examples) so that the students can explain how they arrived to the final solution [11] [12] [13] [14] . Research within both approaches focuses primarily on adapting the rules which recommend learning actions than on giving the learner the freedom to experiment with [15] [16] [17] [18] [19] . Experimentation in both approaches is controlled, 65 that is, the instructor establishes the exercises that learners should or can do. These learners have no freedom to propose new exercises that they might come up with. Recent research has focused on open learning environments, where the set of exercises is not limited to a predefined set, or where the learners can create new exercises [20] [21] [22] [23] [24] [25] [26] . These systems provide a language that enables the 70 generation of exercises and the communication with the learners, which may be a standard language (e.g. eXtensible Markup Language -XML) [22, 26] or a Domain Specific Language (DSL) specifically designed for the problem to be solved [23] [24] [25] . On the other hand, there are systems that focus on the ability for the students to create exercises on their own initiative and upload them into 75 the system, which will solve them and explain how the solutions are reached [20, 21] . These last systems are undoubtedly a major advance in getting the learners to construct their own knowledge through experimentation, working with abstractions which require high level thinking skills. They enable the learners to 80 work at higher levels of Bloom's Taxonomy [27, 28] and help them to gain independent thinking skills. However, these systems do not include an ITS module that adapts to the needs of the learners by making recommendations of the following activities to be done in order to guide their learning process, nor do they provide feedback on what they are doing right or wrong. Designing and 85 developing ITS with this last approach is complex since they are usually highlydependent on the subject and problems to which they are applied. Moreover, they must work with the exercises that the learner creates at any time, which is highly unpredictable. In this paper an ITS has been designed and developed for providing a rich 90 learning environment in which students can learn actively, freely creating exercises, which allow them to operate and manipulate subject matter concepts. Our proposal is specially focused on the tutoring module and how it corrects exercises, gives feedback and promotes progress in student learning. The developed system behaves as an expert system simulating the behaviour of the instructor 95 [2] who applies an active teaching methodology that promotes learning through experimentation. The developed ITS helps students learn predictive parsing algorithms, which are a type of exercises found in Compiler Design or Formal Language Processing subjects. These are part of Computer Science theory, and are included in the 100 syllabuses for this degree at most universities. The remaining sections have been organized as follows. In Section 2, the subject and type of exercises the ITS helps to learn will be briefly presented. In Section 3 the system set out herein will be developed with a special focus on the system architecture (Sec. 3.1), the interface module (Sec.3.2) and tutor 105 module (Sec. 3.3) with a strong focus on the way in which the system automatically corrects exercises (Sec. 3.3.3) and guides student learning by making recommendations (Sec. 3.3.4). In Section 4, there will be an initial evaluation of the system put forward herein. Lastly, in the final section of this paper, there will be a conclusion and future lines of work will be mentioned. Compiler Design, in most curriculums at introductory level in Computer Science, is a highly complex and wide-ranging topic [29] [30] [31] [32] . The contents of an introductory course in Compiler Design are usually organized into the following 115 units: U1. Introduction: An overview of compiler design is covered in this unit. U2. Notation and concepts for formal languages and grammars: Basic notation and concepts related to discrete mathematics, grammars and languages are covered in this unit. 120 U3. Programming-language design: The items to be taken into account when designing and developing a language are presented in this unit (i.e. lexis or language vocabulary, the syntax or sentence structure, the semantic or sentence meaning). U4. Lexical analysis: This unit focuses on designing and developing lexical an-125 alyzers (i.e. scanners). U5. Syntax analysis: The focus of this unit is syntactic analysis techniques which are used to check whether a sentence has a valid structure or not. Top-down (LL(1)) and bottom-up (LR(0), SLR(1), LR(1), LALR(1)) predictive parsing techniques are studied. U6. Semantic analysis or context sensitive analysis: In this unit what the grammatically correct sentences mean is studied, with special focus on syntaxdirected translation. U7. Synthesis task: This unit describes how the output of a compiler is generated, and the code generation and code optimization phases are presented. In these introductory courses, the focus is on the analytical part of the compilation process, with greater emphasis on syntactic analysis (U5), since this provides basic knowledge about compiler theory. Therefore, this is the part which most time is dedicated to. As a result of what they have learnt, students will gain a solid foundation 140 in compiler design. They are expected to master the fundamental theories behind programming languages and lexical, syntactic and semantic processing techniques. Moreover, they will know how to use these when designing languages and developing processors associated with them. To be precise, students must understand the top-down parsing techniques (LL(1)), and the bottom-up or 145 shift-reduce parsing techniques (SLR(1), LR(1) and LALR(1)), and develop processors based on these. In order to master the syntactic analysis phase and predictive analysis techniques, doing a large number of exercises about parsing is recommended. When 150 students practice, they learn theory and acquire practical skills on parsing techniques. Developing an ITS that enables students to perform as many exercises as they want, as well as correcting them and providing guidance on the next steps in the learning process is essential in online learning. In addition, it could be used as an auxiliary tool for face-to-face studying, where it provides additional 155 learning support for students and their professor. The two types of parsing exercises the students must carry out are: LL and LR. Each exercise consists of a grammar and constructing of a parser for it (LL(1), SLR(1), LR(1) and/or LALR(1)). At this point, it may be beneficial for us to recall the classical definition of 160 grammar, given by Noam Chomsky [33] . A formal grammar is the four-tuple G = (N, T, P, S), where: • N is a set of non-terminal symbols (variables). • T is a set of terminal symbols (constants), so N ∩ T = ∅. • S is a special symbol, the start symbol, so S ∈ N . • P is a finite set of production rules. Since we are going to work with context-free and regular grammars, each production rule p i ∈ P will have a structure similar to A → α, where A is in N and α is in (T ∪ N ) * with * being the Kleene's closure. The solution to an exercise will depend on the type of parser to be developed: • For LL(1) parsers, it implies constructing a LL(1) parsing table, and for this purpose, the set of prediction symbols must be obtained for each production rule p i ∈ P (i.e. LOOKAHEAD(p i )). The nullable symbols must be identified (i.e. those non-terminal symbols in the grammar that can be derived into the empty string (λ)) and FIRST and FOLLOW sets must be computed for each non-terminal symbol in the grammar. F IRST (α) is the set of terminal symbols in the grammar that begin the strings which are derivable from α (such that α ∈ (T ∪ N ) + ) and F OLLOW (A) is the set of terminal symbols in the grammar that can appear immediately to the right of A in some partial derivation (A ∈ N ). • For SLR(1), LR(1) and LALR(1) parsers, this entails constructing SLR(1), LR(1) and LALR(1) parsing tables. To do so, the automaton that recognizes viable prefixes and reduces them appropriately for deterministic SLR(1) or LR(1) parsing, must be built. The automaton for deterministic LALR(1) parsing is obtained from the LR(1) automaton. These are the exercises we hope the student will practice with the ITS proposed in this paper. We will not explain here how to solve these exercises since any classical books on this topic includes it [29, 30, 34] . However, we must point out that these exercises can be solved by means of algorithms. At present, a series of tools for this purpose have been proposed, designed and used [35] . Among these we can mention ANAGRA 1 , BURGRAM 2 [36], JavaPars 3 , PAVT [37] , SEFALAS, JFLAP 4 [38] , VAST [39, 40] 195 There are several differences between these tools. Firstly, they differ in their execution environments, where we can find web applications (based on client- It should be noted that all the tools presented above allow the introduction of new exercises, but none of them can be considered to be an ITS, since they lack an essential component needed in these systems: the learning instructor. They are traditional computer aided instruction tools (CAI). Only one of them comes close to that idea, Proletool 2.0. This tool allows the student to propose 215 solutions to the exercises and adds the possibility to make corrections (through the named exercises corrector component). The tool suggested in this paper will have models of instructional content that specify what to teach along with the teaching strategies that specify how to teach, incorporating within the latter the challenge for the student to propose new exercises that comply with cer-220 tain restrictions (working at higher levels of Bloom's Taxonomy). In addition, the proposed system should enable visualization and interaction mechanisms regarding the developed analyzers, showing how they work and how the syntax tree is constructed. Figure 1 In this paper, an ITS, Proletool 3.0, is proposed for enabling students to understand the relationship between the phases of lexical and syntactic analysis and the technical fundamentals of top-down (LL(1)) and bottom-up or shiftreduce parsing techniques (SLR(1), LR(1) and LALR(1)). Moreover, this ITS will enable them to develop processors based on these techniques. The system 235 proposed in this paper will contain a number of conceptual components, or modules, that interact with one another. Figure The evaluation module enables the professor to access information about how students are using the system or concerning how they are progressing with their training. This information may be used for planning new learning activi-260 ties. The domain module possesses declarative, procedural and conditional knowledge needed to enable active learning as explained below: 1. Declarative knowledge, which refers to grammars or elements of solutions such as first and follow sets of non-terminal symbols, the set of prediction 265 symbols for each production and the parsing tables. 2. Procedural knowledge, which is made up of those algorithms needed for solving the exercises and for correcting the solutions which are proposed by the students (see Table 1 ). be used for guiding the student's work. The system designed and developed has been deployed on the web and can be accessed by a web browser to be tested (registration is necessary) 9 . In the following sections, the interface and tutor modules will be explained in detail. These are the most important and innovative modules, as the interface 280 module is that which gives freedom to students and the tutor module is that which implements the most up-to-date functionalities. The interface module of the ITS proposed herein has been designed on the premise of providing students as much freedom as possible. Therefore, commu-nication between the tool and the student is carried out with a DSL which has been specifically designed for this purpose. Using this language, students may upload the exercises they want to learn how to do as well as the solutions (which may or may not be correct) they have proposed for them to the ITS. Due to space limitations, details of how the vocabulary, syntax and semantics The solutions to the exercises the tools solve involves the following steps: • Identifying nullable symbols. • Specifying FIRST(X) and FOLLOW(X) sets for all grammar symbols X in N (i.e. ∀X ∈ N ). • For LL1 exercises: -Specifying LOOKAHEAD(p i ) for each grammar production rule p i in P (i.e. ∀p i ∈ P ). -Specifying the LL(1) parsing table whose dimensions will be |N | × for the exercise in Listing 1 is shown in Figure 5 . In Listing 2, an example of a correct and complete solution to the problems related to developing bottom-up analyzers (a LL (1) analyzer to be specific) is shown (see Listing 1). This solution is correct and complete and it could be compared with an incorrect and incomplete one shown in Listing 4. In Listing 3, an example of a correct and complete solution to the problems about developing shift-reduce analyzers (specifically a SLR(1) analyzer) is shown (see Listing 1). There will be similar solutions to the problems associated with the LR(1) and LALR(1) types. The interface module uses a DSL processor for processing the documents 345 given as input to the system. Meanwhile, it will check if these are well formed (in terms of vocabulary, syntax and semantic restrictions). Subsequently, it will obtain the necessary information from them, that is, the four elements that define the grammar (N, T, P, S), the type of parser the student want to build for it (LL1, SLR1, LR1 or LALR1) and the solution he or she proposes to it 350 (nullable symbols, first and follow sets for each non-terminal symbol, lookahead symbols for each production and parser tables). The latter could be considered as a belief which the student has as to what the solution is for the exercise loaded into the system. All this information will be used in other modules of this ITS. The traditional model has been followed for designing and developing the DSL processor which is made up of four phases: Phase 1. Lexical analysis: this will be responsible for analyzing the sequence of characters there are in the input and grouping them into elements belonging to language vocabulary (i.e. tokens). Phase 2. Syntactic analysis: the purpose of this phase will be to check that the sequence of tokens obtained in the lexical phase has a valid structure according to the language syntax. Phase 3. Semantic checking: this will be entrusted with checking the semantic restrictions on the syntactically well formed structures and starting the 365 information extraction process. Phase 4. Code generation: in this phase information will be changed into declarative knowledge which will make up part of the domain module. The details of how the DSL processor was developed will not be given as this has been deemed to be beyond the scope of this paper. The interface module also has mechanisms for enabling interactions with the solutions developed in order to streamline navigation of the generated solution, the solutions corrections, feedback and suggestions made by the system. Moreover, this module enables visual and interactive simulations of strings analysis to be carried out using the parsers developed (see Fig. 6 ). With this students 375 can experience and understand how the types of parsers studied work. Just as stated earlier, the purpose of this module is to encourage students to actively and self-sufficiently learn predictive parsing techniques. Intended 380 learning outcomes (ILOs) for the ITS proposed herein are as follows: • o 1 : To know how to determine the N U LLABLE symbols. • o 2 : To know how to calculate the F IRST sets. • o 3 : To know how to calculate the F OLLOW sets. • o 4 : To know how to calculate the LOOKAHEAD sets. The main purpose of the ITS proposed in this paper is to get students to engage in learning activities conducive to achieving these ILOs. When deciding 390 on the best learning activities in our situation, it should be remembered that what the students do is actually more important that what the professor does [49] . Thus, the teaching/learning activities (TALs) used by the ITS proposed here will be as follows: • Exampling: students are asked to suggest and do an exercise which brings 395 out a specific concept, problem or situation that they should explore in depth. • Individual exercises: students are asked to do an exercise from the repository, the purpose of which is to study a specific concept, problem or situation in depth. • Active review: students are asked to review a specific concept or algorithm in order to identify what they do not understand. In order to know to what extent students understand ILOs, assessment tasks (ATs) that will be used in the ITS must be set. Scoring rubrics streamline assessment of students' work. Moreover they are teaching tools that support 405 student learning and promote the development of sophisticated thinking skills. Instructional rubrics that the ITS proposed here uses for grading and evaluating the students' work (Tables 2, 3, 4), as well as the errors they can make before achieving each ILO, will be outlined below (Tables 5, 6 , 7, 8, 9, 10) . This is public information and helps them focus their efforts and self-assess their own 410 work. Furthermore, rubrics and errors provide students with specific feedback enabling them to reflect on how they are performing with a view to improving. The raw rubric score is calculated as the sum of all criteria grades. The final grade is calculated by comparing actual scores with the worst/best possible score. This module consists of three components which will provide students with the necessary guidance, support and resources for them to succeed, which are as follows (see Fig. 2 ): (i ) Problem solver, (ii ) Exercises corrector, and (iii ) Learning instructor. These are described in greater detail below. The problem solver component just solves exercises uploaded to the system, and for this purpose, it uses declarative knowledge acquired by the interface module and procedural knowledge available in the domain module (see Sec. 3.1). Futhermore, it will show how to reach the solution and, in doing so, it must perform the following actions: • It first understands the exercise, converting the information obtained by the interface module (i.e. four elements that define the grammar (N, T, P, S) and the type of parser that students wants to build for it (LL1, SLR1, LR1 or LALR1)) in declarative knowledge. • It generates the solution applying the appropriate procedural knowledge The main goal of the exercises corrector component is to compare the solution obtained by the problem solver component with that the student has 445 provided for the exercise given as input to the ITS. That is, this component must act as a professor in its capacity as exercises corrector, its mission is to detect the correct answers as well as where students may go wrong. It must also inform of any information which students have not specified in the solution that they set out. To do so, it carries out the following actions: This is carried out using procedural knowledge that has the necessary mechanisms to do such comparison. Additionally, it detects whether there 455 are errors in the student exercise solution and if so, which ones. • It evaluates the solution students provide for the exercise, using the aforementioned rubrics score (see Tables 2, 3, 4 ). The score for each ILO will be stored in a variable called recent scores whose value ranges from 0 to 5, inclusive. Moreover, they will be used to modify the extent to which 460 students have mastered each ILO. It will be stored in a variable called level mastery, also defined in the range [0, 5]. • It gives feedback, informing whether the solution students have given for the exercise contains errors (see Tables 5, 6 , 7, 8, 9, 10) . This feedback also provides a justification for the grade given. The fuzzy definition domains for the input variables recent scores, level mastery and for the output variable achievement level are not shown, as the authors of this paper do not deem this to be important in order to understand the system 500 presented herein. However, we do think that justifying the use of fuzzy logic when designing this module would be beneficial. At this stage, there is no attempt to provide an accurate assessment of how much students have learnt, but rather to provide them with guidance that they can understand. In this respect, using linguistic 505 variables makes it easier for them to interpret this information. As a result of the work done by this module, students will receive detailed feedback on the work they have done, with an explanation of what areas they have done well, and what they may still need to improve. In addition, on a broader level, students will be informed as to whether they have truly mastered 510 the subject or not. The aim of the learning instructor component is to guide the student's progress towards a goal, which in our situation is reaching our ILOs (see Sec. 3.3.1). Now, it is time to guide the work of the students by assigning new exer- Where o i is an ILO (see Sec. 3.3.1), e j is an ILO-related error (see Tables 5, 6, 540 7, 8, 9, 10) and X is a hyperlink which points to a study material. where select exercise(e j ) takes an exercise from the repository in which there are the same circumstances whereby the error e j occured (see Tables 5, 6, 7, 8, 9, 10) . For R 2 and R 5 , this means choosing an exercise which contains a NULLABLE symbol A and ∄p i , with p i : A → λ. For R 15 , this means 585 recommending an exercise from the repository which contains the production p i ∈ P , with p i : A −→ βCα such that β ∈ N + and α ∈ (N ∪ T ) * and C ∈ N and β + ⇒ λ and a ∈ F IRST (C). For R 21 , this means selecting an exercise from the repository which contains the production p i ∈ P , with p i : X −→ Aβaα such that α ∈ (N ∪ T ) * and β ∈ N + and β + ⇒ λ. For R 42 , it selects an exercise 590 from the repository which contains the production p i ∈ P , with p i : X −→ α such that α ∈ (N ∪T ) * and α * ⇒λ and a ∈ F OLLOW (X). For R 58 , it selects an exercise from the repository for developing bottom-up SLR(1) syntax analyzers. To round off this section, it is worth mentioning that each exercise in the repository is related to errors or rather to situations that can lead to such 595 errors. This association is automatically made every time the professor uploads an exercise to the repository. The DSL processor will analyze it, extract any important information there is and associate it with types of errors. It must be stressed that every example may be associated with various error situations. After this module has completed its work, students will know what to do 600 next to keep on learning. Lastly, it must be noted that instructor learning component just makes recommendations, which students are free to accept or decline. In any event, a record is made of the exercises recommended and done from the repository to prevent duplicating recommendations to the student. In total, 68 students had the opportunity to use the tool Proletool 3.0 to study the subject (i.e. the number of students enrolled in the course). The tool was freely used only by students who considered it useful to study the subject. In other words, no experimentation was designed (not an experiment itself). Moreover, its use was neither rewarded nor penalized. Therefore, the free use of 620 the tool might already be considered as an indicator of its perceived usefulness. The tool was regularly used by 35 students (those that did more than 20 exercises with it), occasionally by 6 students (who did less than 15 exercises) and 27 students never used it (among whom were the 5 students who did not attend classes). Out of the group that used the tool regularly, 51% used the new functions that Proletool 3.0 offered (18 students), as opposed to 49% who did not (17 students). In total, the students completed 1.210 exercises using the tool. The usefulness and effectiveness of the tool was evaluated by comparing the exam grades of students who used the tool as opposed to those who did not (see 630 Table 13 ). The average grade obtained by the students was 5.87 points out of In the light of these data, it could be stated that the tool has influenced the academic results of the students. However, one may argue that because using 650 it was voluntary, only the best students used it. Even if that were true, the fact that the tool had been used by this type of student is a good sign as they may have considered it useful for studying this subject or that it was highly motivating for that purpose. In order to confirm this hypothesis, we asked the students their opinion con-655 cerning Proletool 3.0. This was done by means of an online survey in which questions were asked on a range of issues (see Table 14 ). The survey, in which a total of 25 students took part out of the 35 who used the tool, was anonymous and voluntary. They had to answer dichotomous questions about the tool features. We use this kind of questions to elicit a choice from respondents on 660 specific issues. They are used for unambiguously distinguishing the opinion of each respondent. Table 14 shows the questions and the answers respondents gave to them. From the values obtained in this survey, some conclusions can be drawn: the tool is user-friendly (Q 1 ), the learning curve for the tool is quite short (Q 2 ), 665 the information it provides is understandable and its simulation capacity helps understand the concepts (Q 3 and Q 4 ). The responses to questions Q 5 , Q 6 , Q 7 and Q 8 show the students found the tool useful for learning this subject. The response to question Q 9 shows students did not find the tool motivating. In this paper, an Intelligent Tutoring System has been designed and developed to enable student learning through experimentation, working at the highest cognitive level of Bloom's Taxonomy, encouraging them to learn actively and to be self-sufficient. As such, the tool developed, called Proletool 3.0, contains the modules typically found in this type of systems (Domain module, Tutor module, Student's module, Interface module and the Evaluation module). In addition, the system provides a web interface 10 that enables it to be used as a learning object on an e-learning platform. To allow the learning through experimentation, the tool enables students to create new exercises as well as give solutions to them on their own, to obtain A specific domain language has been designed to create exercises and specify their solutions, and its associated processor has been developed to process them. The DSL has been designed with a high focus on syntactic and semantic specifications and restrictions. Its processor has been implemented according 690 to the tradicional model, in which the input text is processed, through four sequential phases (lexical analysis, syntactic analysis, semantic checking and code generation), and its meaning is processed to produce declarative knowledge. In addition, the developed system contains the components that allow to solve the exercises proposed by the student, to correct the solutions that he/she 695 presents and to guide his/her learning. The design of these components is a complex task due to the freedom given to the student to define their own exercises. For any exercise given as input, the exercises corrector component The learning instructor component is the responsible for giving students 705 recommendations in order to guide their learning, so that the ILOs will be reached. To carry out this task, a knowledge base is used, in which the different achievement indicators for each of the learning goals are linked to each of the errors that may be made in the subject in order to recommend the next action to be taken. This may be (i ) challenging the student to propose an exercise 710 (type 1), (ii ) suggesting doing an exercise from the repository (type 2), or (iii ) recommending studying a concept or technique (type 3). The system put forward in this paper has been used on a real learning situation. It has been used by the students during four academic years in a Language Processors course at the Computer Science and Engineering Faculty 715 of the University of Castilla-La Mancha (Spain). Thus, an initial evaluation of the usefulness and effectiveness of the system has been made. The data obtained show how promising the system is as a useful learning instrument for student training, since it has had influence on the marks obtained, and it has been perceived by them as a good learning instrument. As a future line of research a component has been planned to be incorporated into the tutor module which can assess the knowledge students have gained. The aim of this is to detect those who are at risk of dropping out and to set up activities which will encourage to join the group again. There are also plans to It obtains the non-terminal symbols in the grammar G that can be derived into the empty string (λ). It obtains the set of terminal symbols that begin the strings derivable from α. F ollow(A) It obtains the set of terminal symbols that can appear immediately to the right of A in some partial derivation. It checks whether the grammar G is LL(1). It obtains the set of terminal symbols which help choose whether to use the rule p. P arsing T able LL1(G) It constructs the predictive parsing The student does not try to calculate the nullable elements. 1 The student correctly calculates less than 10% of the nullable elements. 2 The student correctly calculates between 10% and 40% of the nullable elements. 3 The student correctly calculates between 40% and 80% of the nullable elements. 4 The student correctly calculates more than 80% of the nullable elements, but not all of them. 5 The student correctly calculates all the nullable elements. The student does not try to calculate the elements of the set. 1 The student correctly calculates less than 10% of the elements of the set. 2 The student correctly calculates between 10% and 40% of the elements of the set. 3 The student correctly calculates between 40% and 80% of the elements of the set. 4 The student correctly calculates more than 80% of the elements of the set, but not the full set. 5 The student correctly calculates all the elements of the set. The student correctly fills less than 10% of the table. 2 The student correctly fills between 10% and 40% of the table. 3 The student correctly fills between 40% and 80% of the table. 4 The student correctly fills more than 80% of the table, but not the 100%. 5 The student correctly fills the table. Does not indicate that a non-terminal symbol A is nullable, when it has a direct derivation to the empty string (i.e. ∃p i ∈ P , with Does not indicate that a non-terminal symbol A is nullable, when it has a derivation to the empty string in two or more steps (i.e. A Indicates that a non-terminal symbol A is nullable, when it is not. Does not include a terminal symbol a in the FIRST(A) set, when there is a production defining the A symbol whose right-hand side begins with this terminal symbol (i.e. ∃p i ∈ P , with p i : A −→ aα such that α ∈ (N ∪ T ) * and a ∈ T ). e 5 Does not include a terminal symbol a in the FIRST(A) set, when there is a production defining the A symbol whose right-hand side begins with a non-terminal B and a belongs to the F IRST (B) set (i.e. ∃p i ∈ P , with p i : A −→ Bα such that α ∈ (N ∪ T ) * and B ∈ N and a ∈ F IRST (B)). e 6 Does not include a terminal symbol a in the FIRST(A) set, when there is a production defining the A symbol whose right-hand side begins with a list of non-terminal and nullable symbols, β, and the symbol a is on its right (i.e. ∃p i ∈ P , with p i : A −→ βaα such that α ∈ (N ∪ T ) * and β ∈ N + and β + ⇒ λ). e 7 Does not include a terminal symbol a in the FIRST(A) set, when there is a production defining the A symbol where on its right-hand side there is a non-terminal symbol C and all symbols on its left are nullable and a belongs to the initials of symbol C (i.e. ∃p i ∈ P , with p i : A −→ βCα such that β ∈ N + and α ∈ (N ∪ T ) * and C ∈ N and β + ⇒ λ and a ∈ F IRST (C)). e 8 Includes terminal symbols which do not belong to F IRST (A). Does not include a terminal symbol a in the FOLLOW(A) set, when there is a production rule in which, on its right-hand side, the nonterminal symbol A appears followed by the terminal symbol a (i.e. ∃p i ∈ P , with p i : B −→ Aaα such that α ∈ (N ∪ T ) * and B ∈ N ). e 10 Does not include a terminal symbol a in the FOLLOW(A) set, when there is a production rule in which, on its right-hand side, the nonterminal symbol A appears followed by the non-terminal symbol B and the terminal symbol a belongs to the F IRST (B) set (i.e. ∃p i ∈ P , with p i : X −→ ABα such that α ∈ (N ∪ T ) * and B ∈ N and a ∈ F IRST (B)). e 11 Does not include a terminal symbol a in the FOLLOW(A) set, when there is a production rule where on its right-hand side the nonterminal symbol A appears followed by a list of non-terminal and nullable symbols β and the terminal symbol a appears after them (i.e. ∃p i ∈ P , with p i : X −→ Aβaα such that α ∈ (N ∪ T ) * and β ∈ N + and β + ⇒ λ). e 12 Does not include a terminal symbol a in the FOLLOW(A) set, when there is a production rule where on its right-hand the non-terminal symbol A appears followed by a list of non-terminal and nullable symbols β and the terminal symbol a is an element of the FIRST set of the following non terminal symbol (i.e. ∃p i ∈ P , with p i : X −→ AβCα such that α ∈ (N ∪ T ) * and β ∈ N + and β + ⇒ λ and C ∈ N and a ∈ F IRST (C)). e 13 Does not include a terminal symbol a in the FOLLOW(A) set, when there is a production rule where on its right-hand side the nonterminal symbol A appears followed by a nullable part and the terminal symbol a belongs to F OLLOW (X) (i.e. ∃p i ∈ P , with p i : X −→ Aβ such that β ∈ (N ∪ T ) * and β + ⇒ λ and a ∈ F OLLOW (X)). e 14 Includes terminal symbols which do not belong to F OLLOW (A). Does not include a terminal symbol a in the LOOKAHEAD(p i ) set, when the right-hand side of the production rule p i begins with this terminal symbol (i.e. ∃p i ∈ P , with p i : A −→ aα such that α ∈ (N ∪ T ) * and a ∈ T ). e 16 Does not include a terminal symbol a in the LOOKAHEAD(p i ) set, when the right-hand side of the production rule p i begins with a nonterminal symbol B and a belongs to the F IRST (B) set, (i.e. ∃p i ∈ P , with p i : A −→ Bα such that α ∈ (N ∪ T ) * and B ∈ N and a ∈ F IRST (B)). e 17 Does not include a terminal symbol a in the LOOKAHEAD(p i ) set, when the right-hand side of the production rule p i begins with a list of non-terminal and nullable symbols, β, and the symbol a is on its right , (i.e. ∃p i ∈ P , with p i : A −→ βaα such that α ∈ (N ∪ T ) * and β ∈ N + and β + ⇒ λ). e 18 Does not include a terminal symbol a in the LOOKAHEAD(p i ) set, when the right-hand side of the production rule p i has a non-terminal symbol C with all symbols on its left nullable and a belongs to C initials, (i.e. ∃p i ∈ P , with p i : A −→ βCα such that α ∈ (N ∪ T ) * and β ∈ N + and C ∈ N and β + ⇒ λ and a ∈ F IRST (C)). e 19 Does not include a terminal symbol a in the LOOKAHEAD(p i ) set, when the right-hand side of the production rule p i is nullable and the terminal symbol a belongs to F OLLOW (X) (i.e. ∃p i ∈ P , with p i : X −→ α such that α ∈ (N ∪ T ) * and α * ⇒ λ and a ∈ F OLLOW (X)). e 20 Includes terminal symbols which do not belong to LOOKAHEAD(p i ). Wrongly fills the table when working with productions p i whose righthand side begins with a terminal symbol a (i.e. ∃p i ∈ P , with p i : A −→ aα such that α ∈ (N ∪ T ) * and a ∈ T ) and does not make Wrongly fills the table when working with productions p i whose righthand side begins with a non-terminal B symbol (i.e. ∃p i ∈ P , with p i : A −→ Bα such that α ∈ (N ∪ T ) * and B ∈ N ) and does not make Wrongly fills the table when working with productions p i whose righthand side begins with a list of non-terminal and nullable symbols, β, followed by a terminal symbol a (i.e. ∃p i ∈ P , with p i : A −→ βaα such that α ∈ (N ∪ T ) * and β ∈ N + and β + ⇒ λ) and does not make LL1 T able[A, a] = {p i }. e 24 Wrongly fills the table when working with productions p i where on its right-hand side there is a non-terminal symbol C and all the symbols on its left are nullable (i.e. ∃p i ∈ P , with p i : A −→ βCα such that α ∈ (N ∪ T ) * and β ∈ N + and C ∈ N and β + ⇒ λ) and does not make LL1 T able[A, a] = {p i } ∀a ∈ F IRST (C). e 25 Wrongly fills the table when working with productions p i whose righthand side is nullable (i.e. ∃p i ∈ P , with p i : X −→ β such that β ∈ N + and β + ⇒ λ) and does not make LL1 T able[A, a] = {p i } ∀a ∈ F OLLOW (X). e 26 Fills the cells which must be empty or fills them wrongly (with wrong productions). Wrongly builds the tables, with a wrong number of rows in the action table and reduce or goto table (i.e. incorrect number of states for the viable prefix recognizer). e 28 Does not correctly indicate the symbols that produce actions in the action table (i.e. wrong number of columns in the action table). e 29 Does not correctly handle the end of string delimiter '$' in the action table (i.e. there are no actions associated with it when there should be). e 30 Does not correctly calculate the first state of the viable prefix recognizer (i.e. errors in the first row of the action and reduce or goto table). e 31 Wrongly fills the actions in the action table. e 32 Does not indicate shifts of state in the action table. e 33 Does not indicate a reduction in the action table. e 34 Does not indicate the situation in which the analysis must successfully end. e 35 Does not correctly indicate in the reduce or goto table the symbols that produce a change of state (i.e. wrong number of columns in the reduce or goto table). e 36 Wrongly fills the change of state in the reduce or goto table. Not specifically indicated and ✚ ) p i , using crossing-outs, denotes an error. 12 Proletool 2.0 4, 0 S112 0 -4, 0 S115 10 Proletool 2.0 4, 0 S118 13 Proletool 2.0 4, 0 S211 8 Example-tracing tutors: Intelligent tutor development for non-programmers Authoring 750 tools for designing intelligent tutoring systems: a systematic review of the literature Ch. Learning by 755 experimentation: The operator refinement method Development of e-learning solutions: Different approaches, a common mission Using co-lab to build system dynamics models: Students' actions and on-line tutorial advice A tutor on subprogram implementation Learning to program with coala, a distributed computer assisted environment Modeling engagement in self-directed learning systems using principal component analysis Implementing an adaptive intelligent tutoring system as an instructional supplement Designing and using software tools for educational purposes: Flat, a case study Knowledge-based systems to enhance learning: A case study on formal languages and automata theory, Knowledge-Based Systems Xml-based eassessment system for office skills in open learning environments An extensible domain-specific language for describing problem-solving procedures Generating story problems via controlled parameters in a web-based intelligent tutoring system Automatic generation of problems and explanations for an intelligent algebra tutor The grammatical approach: A syntax-830 directed declarative specification method for xml processing tasks Taxonomy Of Educational Objectives: Handbook 1, The Cognitive Domain A revision of bloom's taxonomy: An overview Compilers: Principles, Techniques, and Tools Compiler Construction: Principles and Practice Modern Compiler Design Three models for the description of language The theory and practice of compiler writing Evaluation of simulation systems suitable for teaching compiler construction courses A tool for teaching ll and lr parsing algorithms Pavt: a tool to visualize and teach parsing algorithms, 860 Education and Information Technologies Learning automata and formal languages interactively with jflap Velázquez-Iturbide, Vi-865 sualization of syntax trees for language processing courses Srec and vast: Visualizing software with a student-centered aim Cupv -a visualization tool for generated parsers Ppvt: A tool to visualize predictive 875 parsing An educational tool for teaching compiler construction Inter-880 active educational simulations for promoting the comprehension of basic compiler construction concepts Vcoco: A visualisation tool for teaching compilers Fernández-Valmayor, An environment for supporting active learning in courses on language processing Experience applying language processing techniques to develop educational software that allow active learning methodologies by advising students A generator for production quality compilers Cognitive conceptions of learning Have you found it difficult to use Proletool 3.0 ? 100% Q 1Have you found it difficult to learn the Proletool 3.0 language? 8% 92% Q 3Do you think the information provided by Proletool 3.0 is understandable?Has the visual and interactive simulations of Proletool 3.0 helped you to understand the syntax analysis methods? 88% 12% Q 5Has Proletool 3.0 been useful for understanding the syntax analysis methods? 100% Q 6 Do you think using Proletool 3.0 influences the obtained grade? 88% 12% Q 7If you could go back in time... would you use Proletool 3.0 to prepare the subject? 100% Q 8 Would you recommend using Proletool 3.0 to other students in the next academic year? 100% Q 9Has Proletool 3.0 motivated you to study more? 32% 68%