Chapter 4. Major-Requirement-First Imitating Learning System (MRFILS)
4.1 Knowledge Acquisition Phase
4.1.1 System Requirement Ontology (SRO)
For imitating learning, we need to construct teaching cases in advance.
According to the features of logic tier design of web-based system, we define a knowledge structure named System Requirement Ontology (SRO) to maintain our teaching case, Video Rental Management System (VRMS).
Traditional learning content of programming case doesn’t take the physical meanings of components and the relationships between components into account, so it’s difficult for learners to get the design concepts of system. Thus, we think the SRO should contain semantic meanings like component’s utility and physical meaning of interaction, and then we can apply MRFS to schedule an appropriate imitating procedure based on the information. Accordingly, the knowledge representation of SRO is defined as Definition 1, where p means the total number of node set and q means the total number of relationship set.
Definition 1. System Requirement Ontology (SRO)
SRO = (N, R) : Composed of a set of nodes denoting to N and a set of relationships denoting to R.
N = {n1, n2, n3,…, np} : A set of nodes denoting the downstream nodes of n.
R = {r1, r2, r3,…, rq} : A set of relationships denoting the downstream relationships of r.
ni = (nTypei, Namei, Requirementi, Interfacei, ClassQuantityi, UsableObjecti) : Composed of component type, component name, component requirements,
20
component interface, the quantity of class under the component, and the names of usable objects, accordingly.
rTypei{ Be-composed-of, Contain, Use-data, Use-function, Such-as} :
Be-composed-of relationship describes what major functional classes constitute System node.
Contain relation describes what Method nodes are included in Class node.
Use-data relation indicates which data-storage Class node is used by Method node.
Use-function relation indicates which functional Class node is used by
Method node.
Such-as relation is similar to inheritance, and it is connected with two Class
nodes. shows that “MemberMgr” class contains the interface such as “Register” method and
“Login” method. Figure 8 (c) shows that “Register” method uses a data-storage object
called “MemberInfo” which stores the information about member to handle data encapsulation. Figure 8 (d) shows that “Register” method uses a functional object called “DBMgr” which communicates with database to handle logic computation.
And Figure 8 (e) shows that “Profile” class and “Portfolio” class inherit from
“MemberInfo” class.
Figure 8. The examples of VRMS_SRO 4.1.2 Recursive Descent Dialog Approach (RDDA)
After defining the SRO, we have to help teachers constructing this ontology. We propose the Recursive Descent Dialog Approach (RDDA), which is a systematic procedure to allow teachers to input relevant program scaffolds of VRMS. RDDA adopts a top-down dialogue mechanism built from a set of mutually-recursive procedures to construct SRO from major functionalities of VRMS to basic components by asking a series of questions about teacher’s design concepts of VRMS.
The question templates described in Table 2 are defined based upon basic object-oriented design (OOD) process [5], which is shown in Figure 9. And the detailed algorithm of RDDA is shown in Algorithm 1.
22
Table 2. Question templates
Node Type Question Template
System
請輸入這套系統的名稱和主要的功能需求 請輸入這套系統主要功能的類別名稱
Class 請問這個類別主要的功能需求以及Interface為何
Method
請問這個方法的功能需求、會使用到的物件和使用的關係為何 請問在這個方法所使用到的物件中，會使用到哪些方法
Figure 9. Object-oriented design process Define system requirements
Define major requirements
Define interface
Define method requirements
Define usable objects & relationships Decompose to objects
Algorithm 1: Recursive Descent Dialog Approach (RDDA) Denotation :
S : The stack which is used for Depth-First Search (DFS)
Input: The program scaffolds of teaching case, Question Templates (QT) Output: System Requirement Ontology (SRO)
While (There exists node ni which needs to be constructed for teacher) {
Push node ni into S.
While (S is not empty) {
Pop a node ni from S.
Based on ni type, use the corresponding QT to compose the dialogue and ask all necessary information about node ni from teacher.
Acquire the teacher’s answer and construct a node
ni = (nTypei, Namei, Requirementi, Interfacei, 0, UsableObjecti).
Add ni to N.
For each relationship rj{ The output relationships of ni } {
Based on ni type, use the corresponding QT to compose the dialogue and ask all necessary information about rj from teacher.
Acquire the teacher’s answer and construct a relationship rj = (rTypej, Fromj, Toj).
According to the relationships and nodes of SRO to compute the class quantity under node nk, and then modify ClassQuantityk.
}
Return SRO.
24
Example 3. RDDA Scaffolds Constructing System
RDDA Scaffolds Constructing System adopts a series of dialogues to acquire the knowledge from the teacher and construct a SRO of teaching case. Figure 10 shows the example of VRMS_SRO construction process, where VRMS_SRO is an instance of SRO. Firstly, RDDA Scaffolds Constructing System asks the system name, system requirement and major functionalities from the teacher. And then according to major functionalities, where we use “MemberMgr” for example to ask the class requirement, class interface and their relationships. Next, based upon the interface of
“MemberMgr”, we choose a method “Register” for example to ask the method requirement, usable objects like “MemberInfo” and “DBMgr” and their relationships like “use-data” and “use-function”, accordingly. Rules like that, at last RDDA Scaffolds Constructing System will request the teacher to upload the library package, source codes and class diagram. According to this constructing process, the teacher can construct a complete VRMS_SRO by RDDA Scaffolds Constructing System.
Figure 10. The example of VRMS_SRO construction process
4.2 Knowledge Acquisition Phase
4.2.1 Algorithm of Major-Requirement-First Strategy
The algorithm of MRFS is shown in Algorithm 2 and represented by the flowchart in Figure 11. The main algorithm of MRFS is Depth-First-Search (DFS) with heuristic functions to determine the search path. DFS needs a stack to store temporal nodes, and a queue to store the imitating procedure as output. The heuristic functions are based on the class quantity under each node and the weight of each relationship type, where we define the weight of “Use-function” relationship is 2, the weight of “Use-data” relationship is 1, and the others are 0 to schedule the priority of imitation. We think that imitating the functional components first will easily comprehend what is supposed to do in next step, so we set “Use-function” with high priority than “Use-data”. If the relationship types are equal, we will compare the class quantity under the node, where the larger quantity possesses the higher priority.
26
Algorithm 2: Major-Requirement-First Strategy (MRFS) Denotation :
S : The stack which is used for Depth-First Search (DFS) A : The array which is used for heuristic computation Q : The queue which stores the imitating procedure Input: System Requirement Ontology (SRO) Output: Q (Imitating Procedure)
If (There exists a root node ni of SRO) {
Push ni to Q.
While (ni contains any output relationship) {
Do {
For each relationship rj { The output relationships of ni } {
Insert the relationship rj into A.
Compare the rTypej with the type of relationships in A, and sort these relationships according to relationship type from max to min.
(“Use-function” = 2, “Use-data” = 1, others = 0) If (A contains relationships r[] whose type is equal to rTypej)
Compare ClassQuantityj with the class quantity of nodes which are terminal nodes of relationships in r[], and sort these relationships according to class quantity from max to min.
}
Yes
28
4.2.2 Major-Requirement-First Guidance Transformation System (MRFGTS)
In knowledge transformation phase, MRFGTS is composed of MRFS Scheduler and OOLA Transformer. MRFS Scheduler uses the SRO which constructed by RDDA Scaffolding Constructing System to apply MRFS to schedule an imitating procedure, and then OOLA Transformer transform this imitating procedure into a learning activity of OOLA system [14]. The internal procedure of MRFGTS is shown in Figure 12.
Figure 12. Major-Requirement-First Guidance Transformation System Example 4. MRFS Scheduler
Figure 13 presents the example of MRFS Scheduler. Based upon the MRFS algorithm, we get the “VRMS” node which is the root of VRMS_SRO at first and push it into the imitating procedure. And then we check the output nodes and output relationships of “VRMS” node, where the three major functional nodes
“MemberMgr”, “VideoMgr” and “OnlineMgr” contain the same relationships
“be-composed-of”. So we will check the class quantity of these output nodes, and find out the largest one. Suppose that “MemberMgr” node has the largest class quantity of the three output nodes, we push it into the learning precedure, and check the output nodes and relationships again. Suppose there exists “Register” and “Login” method nodes and the relationships are as same as “Contain” relationship, and the “Register”
node has large class quantity than “Login” node, so we push the “Register” node into
the imitating procedure. Accordingly, there are two objects will be used in the
“Register” method, so we choose the “use-function” relationship which has high priority than “use-data” relationship and push “DBMgr” node into the imitating procedure. Rules like that, then we will push “InsertProfile”, “InsertPortfolio”,
“MemberInfo”, “Profile”, “Portfolio” nodes and so on into the learning queue sequentially based on MRFS.
Figure 13. The example of MRFS Scheduler Example 5. OOLA Transformer
In order to use OOLA System to present the learning contents, we need to transform the imitating procedure into an Object-Oriented Learning Activity (OOLA) in advance. As shown in Figure 14, after getting the imitating procedure from MRFS Scheduler, we arrange different learning guidance templates which are presented in Table 3 according to the type of nodes. The imitating procedure will attach different learning contents and learning resources which are constructed in knowledge acquisition phase to create the learning units, and then transform the imitating
30
Afterwards, OOLA Transformer can generate an OOLA based on learning units and OOLA rules.
Figure 14. The example of OOLA Transformer Table 3. Learning guidance templates
Node Type Learning Guidance Template
System impending method tasks, complete method list, guiding information, and task information.
Learning
Resource Class diagram, source code, library package.
Method
Learning Content
Method requirement, usable object interface, usable object requirements, guiding information, and task information.
Learning
Resource Class diagram, source code, library package.
4.3 Learning Phase
4.3.1 Object-Oriented Learning Activity (OOLA) System
Object-Oriented Learning Activity (OOLA) System [14] is an expert system with a graphical authoring tool, which can assist teachers to design adaptive learning activity, and a web based learning system, which can steer learners learning using a rule inference engine. The teacher can arrange learning sequence, edit learning contents and manage the learning resources to provide a learning activity to learners.
Figure 15. The system architecture of OOLA System
Figure 15 shows designing phase and executing phase in OOLA System. In the designing phase, an adaptive learning activity can be designed via the graphical authoring process to teachers easily integrating various learning resources, which are provided by learning resource repositories, and a rule class generating method is also proposed to generate the rule class of learning sequencing controls. In the executing phase, the learning sequencing graph and the rule class are used in rule based adaptive learning method to conduct an adaptive learning to learners.
Therefore, in the learning phase of MRFILS, an OOLA which is already attached necessary learning contents and learning resources will guide the learners to learn the
32
Chapter 5. System Implementation and Experiment
5.1 System Implementation
We have implemented a Major-Requirement-First Imitating Learning System (MRFILS) on web-based environment to evaluate the proposed ideas. The following sections will demonstrate the Teaching Materials Construction Phase and the Software Architecture Design Learning Phase.
5.1.1 Teaching Materials Construction Phase
This phase we use a dialogue mechanism to acquire teachers’ design knowledge of Video Renal Management System (VRMS). MRFILS will ask teachers a series of questions and request them to input the program scaffolds by a systematic process.
As shown in Figure 16, these pictures present the construction process for the teaching materials of VRMS. At first, the teacher is requested to input the system name, system requirement (see Figure 16 (a)), and names of major functionalities (see Figure 16 (b)). Based upon one of major functionalities, MRFILS continues to ask this class requirement, interfaces and relationships (see Figure 16 (c)). Next, choosing one method among the interfaces to ask the method requirement, usable objects, relationships (see Figure 16 (d)), and usable methods (see Figure 16 (e)). And then keeping on asking the questions about the class requirement, interfaces and relationships of usable objects (see Figure 16 (f)). After a series of questions, the teacher is demanded to commit the source codes, and MRFILS will compile them to library packages automatically.
Figure 16. The snapshot of teaching materials construction phase
(a)
(b)
(c)
(d)
(e)
(f) (g)
34
5.1.2 Software Architecture Design Learning Phase
This phase we use Object-Oriented Learning Activity (OOLA) System to present the learning target “VRMS”, which is constructed by teacher in Teaching Materials Construction Phase. OOLA System will provide necessary learning contents and learning resources for learners and guide them to design the system architecture by imitating the compositions of each component and component’s design.
Figure 17 shows the learning process, where OOLA System offers guiding information to instruct the learners why and how the component design is in each step. First of all, the learning system provides the introduction about this imitating learning approach and a task to create a project (see Figure 17 (a)). And then the learners can get the system requirement analysis (see Figure 17 (b)), one of major functional classes introduction with a task and a library download link for learners to start implementing this class with library package supporting (see Figure 17 (c)).
After that, the OOLA System provides the method information of this class and a task (see Figure 17 (d)) for learners to complete this method. Next, it continues to provide the class information which was used by previous method and a library package for task implementation (see Figure 17 (e)). Such as this top-down imitating learning procedure, the learners can gain these software architecture design concepts through a sequence of implementations.
(b)
(e) (d) (a)
(c)
36
5.2 Experiment
To evaluate the efficacy of Major-Requirement-First Strategy (MRFS) in software architecture design learning, we choose 10 graduate students who have enough coding ability of object-oriented programming (C#) from Computer Science in National Chiao Tung University. We design the Video Rental Management System (VRMS) as the teaching case and use Major-Requirement-First Imitating Learning System (MRFILS) to teach software architecture design. After a series of guidance by MRFILS, we use a questionnaire which is shown in Table 4 to evaluate the learning efficacy and satisfaction of learners. We apply the five-level Likert Scale which is the most widely used scale in survey research and it rates from 1 to 5 to specify the respondent’s agreement level to a statement. The five-level Likert degree is shown in Table 5 and the results for learning efficacy and satisfaction is shown in Figure 18.
Table 4. The questionnaire items
Questionnaire Items
Q1. Is the guiding procedure useful to construct the VRMS?
Q2. Is the information provided in each implementation process sufficient to construct the task?
Q3. Do you think that the library provided in each implementation process is useful to complete the task?
Q4. Do you think that using the library first and then construct these objects later will easily comprehend what should be considered in these objects?
Q5. Do you think that this top-down imitating manner will easily understand why and how the software architecture design is than traditional bottom-up implementation?
Q6. Do you think that the learning efficacy of this system is better than other learning approaches such as lectures or case study?
Q7. Please give a grade (1~5) for this learning system.
Table 5. The format of a typical five-level Likert degree
Degree Meaning
1 Strongly disagree
2 Disagree
3 Neither agree nor disagree
4 Agree
5 Strongly agree
Figure 18. The results for learning efficacy and satisfaction
The results show that most of learners think this top-down imitating learning can help them understanding the software architecture design effectively than bottom-up implementation and traditional learning approaches like lectures or case study. And implement the programs with library packages supporting will easily comprehend how to design these used objects. Otherwise, some learners think the information of learning contents need to be more sufficient, and some learners don’t agree with the guiding procedure where the system provided.
38
5.3 Discussion
Finally, we also interview the learners and ask the impressions for MRFILS, there are some comments on this system as below:
Major-Requirement-First Strategy (MRFS)
Several learners think that this top-down imitating manner is a good idea for learning system design. Because traditional implementation manner is bottom-up, even they have the system requirements, architectural blue print, and UML diagrams for reference, it is still difficult to understand how to implement the system for learners who just begin to learn the web-based system design.
Learning contents
Several learners think that we should provide more UML diagrams rather than only one Class Diagram, such as Use Case Diagram, Activity Diagram, and
Because the guiding procedure is scheduled by MRFILS, where we design some heuristic algorithms to prioritize the imitating sequence, several learners think that we can provide more imitating sequences for them to choose rather than only one choice.
The above comments are very significant for improving this computer-assisted learning system, and we will take these comments into account in the future work.
Chapter 6. Conclusion and Future Work
In this thesis, we propose a top-down imitating learning manner named Major-Requirement-First Strategy (MRFS) and apply this teaching approach to construct an intelligent tutoring system named Major-Requirement-First Imitating Learning System (MRFILS) to teach software architecture design of logic tier in web-based system. The teachers can use MRFILS to construct teaching materials, where we adopt a web-based system called “Video Rental Management System (VRMS)” as our teaching case. MRFILS provides learners one-on-one instruction and assistance to guide them imitating the software architecture design of VRMS through a series of implementations with scaffolding instruction, and it will significantly reduce the loading of teachers. Finally, we have done a real experiment to evaluate the learning efficacy and satisfaction of learners. The experimental results show that MRFILS can help learners gaining the software architecture design concepts of VRMS effectively.
In the near future, we would like to embed diagnostic tests in the guiding process to evaluate the learning performance and learning status, and add some imitating learning guidance rules to provide adaptive learning for learners. Thus, the learners can get more flexible guiding procedure and more appropriate learning contents in the learning process.
40
References
1. Grady Booch, Building Web Applications with UML. 2000: Addison Wesley.
2. Grady Booch, Visual Modeling With Rational Rose 2002 AND UML. 2003:
Addison Wesley.
3. Jeff Garland, Richard Anthony, Large-Scale Software Architecture: A Practical Guide using UML. 2003: Wiley.
4. David Garlan, Mary Shaw, An Introduction to Software Architecture. Advances in Software Engineering and Knowledge Engineering, January 1994.
5. Grady Booch, Robert A.Maksichuk, Object-Oriented Analysis And Design With Applications. 2007: Addison Wesley.
6. Woei-Kae Chen, Yu-Chin Cheng, Teaching Object-Oriented Programming Laboratory With Computer Game Programming. IEEE Transactions on Education, AUGUST 2007. VOL.50, NO.3.
7. Liang-Yi Li, Gwo-Dong Chen, A Coursework Support System for Offering Challenges and Assistance by Analyzing Students’ Web Portfolios. Educational Technology & Society, 2009. Vol. 12: p. 205-221.
8. J. Baltasar Garcia Perez-Schofield, Emilio Garcia Rosello, Francisco Ortin Soler, Manuel Perez Cota, Visual Zero: A persistent and interactive object-oriented programming environment. Journal of Visual Languages and Computing 2008.
Vol. 19 p. 380-398.
9. Maria Kordaki, Micael Miatidis, George Kapsampelis, A Computer Environment For Beginners’ Learning of Sorting Algorithms: Design and pilot Evaluation.
9. Maria Kordaki, Micael Miatidis, George Kapsampelis, A Computer Environment For Beginners’ Learning of Sorting Algorithms: Design and pilot Evaluation.