YADBrowser: a browser for web-based educational applications.

In this article, the main characteristics of the educational browser YADBrowser are described. One of the main objectives of this project is to define new languages and object models which facilitate the creation of educational applications for the Internet. The fundamental characteristics of the object model of the browser are also described. YADBrowser markup language is inspired by HTML 4. In this article, the main differences between them are mentioned. The fundamentals of the OPScript language are also exposed. It was created to be used as the script language for the browser. The relations between this project and other efforts aiming to define new languages and browsers for domain specific applications are defined.

Introduction

The Internet is currently one of the most effective means to publish information of any kind. The Web is also a natural field for educational hypermedia applications (Montessoro, Pierattoni, & Cicuttini, 2003). The Internet functions due to languages and protocols that have prevailed for their simplicity and generality which allows them to be used in different applications.

One of the main problems of the Internet is the lack of semantic information; there are many efforts on this subject (Van Ossenbruggen, Hardman, & Rutledge, 2002). It is also hard to construct context-based adaptive systems mainly because links between documents are static and sometimes it is desirable to offer different ways to students according to their knowledge and skills. Also, educational applications could be developed more efficiently and in less time if a wider collection of objects adapted to these applications was available in current browsers. There are reports of the development of object models for web applications to save effort and time (Hennen, Ramachandran, & Mamrak, 2000). With investigational objectives, the authors are developing a project to define new object models and languages all oriented to the creation of educational applications. Up to this moment, an object model and a script language have been developed; they are being used in a browser which has taken some characteristics from current web browsers. The browser also uses a markup language that is a subset of HTML 4. Some additions have been made to this subset to better adapt it to educational applications' requirements. Some authors have created new markup languages for domain specific applications--some of them are XML based languages (Wang, Kajler, Zhou, & Zou, 2003). The language named Mathematics Education Markup Language (MeML), was created for publishing mathematical content on the Internet.

There are features covered in this article which allow the programmer to define extensions to the browser object model that persist from document to document. Some authors have stated the advantages of saving some data in the main memory of the browser (Uehara, Mizuno, & Kikuno, 2001). Persistent extensions can be very useful when an application is organized hierarchically. That is why the YADBrowser was created for educational applications where a user must follow a previously defined path, no matter if the path is generated dynamically. In these applications, common elements can be identified and reused. The YADBrowser allows authors to take advantage of this characteristic of educational applications. For example, if the application is an online course and to access topic one the user should visit the introduction page first, the author of the course could define a function that can be used in the introduction document and in every topic. If the definition can persist in time, bandwidth and time can be saved. There is a great interest in saving bandwidth and many techniques including sharing information between browsers have been reported (Xiao, Zhang, & Xu, 2002; Xiao, Zhang, Andrzejak, & Chen, 2004). In particular, persistent additions could be used to develop applications for people with slow Internet connections and/or applications for children where slower responses to events can distract the student. See (Kikuchi, Kato, & Akahori, 2002) for a reference of a study of children's web-browsing behavior. With these features, authors of educational applications can define application characteristics incrementally, and due to the objects of the browser, these applications can be more interactive. This is very important when the target student is a child.

At present, there are important efforts directed to the production of frameworks that facilitate the creation of educational applications using current technologies. In this field, are for example, the MTeach framework (Montessoro, Pierattoni, & Cicuttini, 2003) and the Avante architecture (Theoktisto, Bianchini, Ruckhaus, & Lima, 2003). Another important issue is semantic relationships and consistency in hypermedia, (Mangiaracina & Maioli, 1995).

There is also great interest in lesson components and courseware reusing, for references of learning objects reusing see (Boyle & Cook, 2001) and (Boyle, 2003) in the case of courseware reusing there are studies like (Teixeira, Paris, Madeira, & Brisson-Lopes, 1999) which also address the problem of the estimation of their effectiveness. This necessity has motivated the authors in providing features to facilitate lessons and teaching material reusing.

There are also reports of the development of browsers for general and domain specific applications. An interesting example is the Grendel browser, (Dennis & Harrison, 1997). This browser allows the user to script the browser user interface, the browser's HTTP interactions, and the browser's rendering of documents. To do so they define a language, CrossJam, similar to Lisp. Using CrossJam, the user can perform a great degree of customization. Other authors have noticed that collaborative browsing is more valuable than stand-alone browsing for educational purposes, so there are reports of tools for collaborative browsers (Hoyos-Rivera, Lima-Gomes, Courtiat, & Benabbou, 2003; Huang & Ma, 2001). Another issue is adapting browsers to computing resources, location of the user, etc., (Henricksen & Indulska, 2001).

Overview of the YADBrowser Project

The YADBrowser project's main components thus far are the object model of the browser and its script language. The project takes some ideas from another project, GraphicalSpriteKernel (GSK), with an objective to create multimedia and hypermedia applications (Romero, 2002; Romero, 2003a). Current work in the GSK project is directed to facilitate the creation of educational applications for the YADBrowser. The objective is that authors of educational applications can use the GSK as an authoring tool. There are studies of the development of educational applications with students using the GSK tool (Romero, 2003b). The authors are creating tools which allow the development of applications for the YADBrowser with the GSK to teachers with less technical knowledge. Currently there are tools which facilitate the creation of hypertext--some wizards for the creation of simple applications, etc., but this is an ongoing process.

The YADBrowser also allows the user to save bandwidth and to respond faster to user generated events. It is also possible to obtain a great interactivity with less programming. Current work on this project is about context-based adaptive applications which are more flexible and let the learning path to be created dynamically according to the knowledge of the student, (Montessoro, Pierattoni, & Cicuttini, 2003).

To make the browser adaptable to a wider number of applications, dynamical persistent additions can be made to the browser object model. This way the objects can be adapted to specific necessities of a given application. The programmer can dynamically add fields and methods to all the classes of the object model and these additions persist in time. Once an addition is made it is reflected in the dynamical model. In Figure 1, the main components of the YADBrowser are shown with the element in the document that is related to every component. As shown, the Document Parser is the main component because it works with the whole document.

The processing of downloaded documents is as follows. The document just downloaded is analyzed by the Document Parser. If there is any code inside it is given to the OPScript compiler. If the code makes dynamical additions then the Dynamical Model is modified, the additions can persist or not. If the addition is persistent it can last for the entire session, or in other cases it will be eliminated when a new document is downloaded. Later it will be shown that with the OPScript language, dynamical additions must be declared explicitly, and using a high level construction, this differentiates it from other script languages like JavaScript.

[FIGURE 1 OMITTED]

Dynamical additions, if they are persistent, save bandwidth and the applications can be adapted with less effort to a given didactical model. In fact, one of the reasons of dynamical persistent additions is to give to authors of teaching materials a browser adaptable to any pedagogical approach. Another issue related with dynamical persistent additions is the reusability of teaching material. A lesson can be dynamically changed according to students' necessities and new data acquired dynamically and related to the student can be added to the object model to be used for the entire session. In Figure 2 it is shown what happens when a new document with dynamical additions is downloaded by the user. Documents without code are easier to process and to display; they just have to pass by the Document Parser. In Figure 3 a screen shot of an application developed for the YADBrowser is shown. It is a course for teaching Spanish to foreign students. The screen shot shows an exercise in which the student completes sentences with the given words by dragging them to the correct position. The menu at the left side and its resources and programming are maintained from page to page.

The Object Model for the Educational Browser

The object model has a class hierarchy that defines its basic structure. The superclass of the hierarchy has been named TRasterObject. It defines the basic functions of the derived classes, as well as common fields such as: position and dimensions of the object, if it is visible or not, etc. Basic event handlers and methods for painting the object are also defined in this class. Objects of this class can contain other objects of its same class. This makes them very general and also makes every algorithm simpler. There is no need to check an object type to be sure that a given operation can be made on it (Martin, 1996).

[FIGURE 2 OMITTED]

The browser user interface depends on the object model. There are studies of the trends and future of browser user interfaces (Rees, 2002). Rees expresses the need for a powerful interactive user interface within a webpage. That is why the object model of the YADBrowser was intended to be powerful and useful for the development of educational applications. There are efforts (Cole, Wainwright, & Schoenefeld, 1998), aiming to create Java applets as a web-based interface to existing platform-dependent software tools. This approach is valuable, but Java applets have security and performance problems.

Main Classes of the YADBrowser Object Model

There are two important classes derived from TRasterObject: TDocument and TSprite. Objects of the TDocument class represent the documents shown to the users throughout the application. They are the main container objects and the work space provided to the user. This class has methods that eliminate or add a given object, the change is visualized calling the Refresh method, and this way, document modifications can be made dynamically. Figure 4 shows a diagram with some of the main classes of the object model.

[FIGURE 3 OMITTED]

Another important class is the TSprite class; it is used as the base class for a large number of classes like text boxes, list boxes, buttons and so forth. The TSprite class is also very functional and their objects can be used if it is necessary. TSprite class also has properties like CurrentImage to assign an image to a given sprite object. The Boolean property Draggable indicates if a given object can be dragged or not. This property is very important to build interactive applications; it can be used, for example, to create exercises to evaluate the student skills or for educational games.

There is another important class, TDocumentManager. Only one object of this class is created per session and is analogous to the Window object of the Document Object Model (DOM) of most important browsers, this object is called DocumentManager and is the default object. Although it does not belong to the basic hierarchy of the model, the TUser class is also very important. Only an object of this class is created and it is assigned to the User property of the DocumentManager object. This object mostly acquires user generated information such as pages visited by him or her, score obtained in the solution of exercises and other information related to the user profile. This information can be useful to decide what content must be shown to the user. This way, content-based adaptive applications can make use of it to display information according to user knowledge and skills.

[FIGURE 4 OMITTED]

Other Classes That Belong to the Object Model

In addition to the classes mentioned above, in the object model there are also included classes like TButtonSprite to be used as buttons in applications, TEditSprite for text boxes, TListBoxSprite for list boxes, TAnimatedSprite for objects which show an image sequence after a given event is generated by the user, for example, when the mouse moves over it. The object model also includes the class TMemoSprite to show several lines of plain text, and THyperTextSprite to show hypertext, among others. These classes, and others that are constantly added to the model, allow the representation of the graphical interfaces of different applications. One of the most important advantages of these objects is that they can be easily customized according to specific application necessities by just changing object properties. Using objects of these classes it is possible to build applications with a great degree of interactivity, close to CD-ROM multimedia applications.

In the model, there are other classes more oriented to the creation of exercises for student evaluation, for example TCellSprite and TPuzzlePieceSprite. The first one represents the cells used to create crosswords; it is possible to specify for a given cell its neighbors in left, right, up or down direction, the correct answer and so forth. These cells could also be used for true or false exercises, among others. The second class, TPuzzlePieceSprite, is a general class whose objects can be used to create puzzle exercises, simple selection exercises and so forth. For each object, it is possible to specify an initial and a final position. If the student is dragging an object, and he or she releases it in a position different from the final position the object will return to its initial position. This way the student understands that he has mistaken and must try another variant. This behavior can be changed, if it is not wanted, to give any information to the student about the right answer.

These components are really important for the development of educational applications and as long as they do not appear in must known browsers, to include them was a great concern in the development of the YAD-Browser. They facilitate a lot the creation of evaluation exercises which are very useful. Some tools which facilitate the creation of some exercises using these components have been developed. Using these tools authors with no programming knowledge can create these kinds of exercises.

Hierarchical Organization of Objects in a Document

Up to this point, some of the classes belonging to the object model have been mentioned. Now the hierarchical relationships between the objects in real applications will be mentioned. The top of the object hierarchy is occupied by the DocumentManager object. Every time a new document is downloaded, an object of the TDocument class is created. It can be accessed using the ActiveDocument property of the DocumentManager object. Every object included in a document belongs to it and is accessible using the dot operator. For example, if it is necessary to access an object named "Button1" located in the current document, it is just necessary to write: DocumentManager.ActiveDocument.Button1. If it is necessary to access a specific property or method of this object, a dot must be added followed by the name of the property or method.

Sometimes there could be a large path to access a given object; it is also possible that this path can be dynamically changed. In order to facilitate the programming and to allow the programmer to generate a more general code the ".." operator can be used. This operator means that a given object is accesible via another object, but it does not specify the exact path to reach it. It is a problem of the language implementation to find the object. Using this operator the example above could be written as: DocumentManager..Button1. This gives an aspect-oriented flavor to the OPScript language. There is a great interest in aspect oriented languages and compilers (Shonle, Lieberherr, & Shah, 2003).

Adding New Class Members to Object Model Classes

It is possible to add new class members, fields and methods, to object model classes dynamically. This functionality has been created in order to provide a general model that is useful in many applications, and that can also be modified dynamically according to specific necessities of a given educational application without complicating the model with deep inheritance hierarchies. Recall that in most used browsers, the programmer can, using a script language, define objects and increment them with methods and fields, but as will be shown later, our approach is more powerful and is a higher level construction. In a section below it is explained how to make dynamical additions using the OPScript language. As long as this browser is intended to be used in educational applications, the user is supposed to log in when he or she starts the application, and at the end he must log out. This means that dynamical persistent additions which are still available can be dropped at that time.

Doer and Shell Methods

In the classes of the object model there are some methods with the following characteristic: they call a list of methods associated to them. First methods have been called shell methods and the associated methods, doer methods. At any time, a new method can be added to the list of methods associated to a shell method and after that the new method will be the last in the list. Whenever the shell method is executed the new functionality specified in the doer method will be executed. It is also possible to eliminate a given method of the list. In addition, it is possible to specify in what position of the list the doer method should be inserted or if it should, from that moment, be the only one to call, ignoring the previous methods.

If a doer method is added to the list without ignoring the previous methods it is similar to override a virtual method calling the inherited ones; otherwise, if a new method is added ignoring the previous ones, it is similar to override a virtual method redefining its behavior in a new way. If it is decided to call the previous methods you can still ignore a given one by eliminating it from the list. Doer methods should have only one parameter--a variant array. One of the main ideas behind the concept of doer and shell methods and also dynamical additions is to substitute inheritance for an easier way to redefine or modify a concept. Represented in object oriented programming by classes, inheritance cannot be fully substituted but it is possible in the majority of cases. Some authors consider the inheritance operation too restrictive and have defined new ones which allow redefining a class without inheritance (Shonle, Lieberherr, & Shah, 2003).

Main Modifications Made to the Browser Markup Language

There are many reports about the definition of new markup languages for new devices or domain specific applications (Huang & Chao, 2001). The markup language for the YADBrowser is as close as possible to HTML 4. A subset of this language has been selected as the markup language for the browser, and additions have been introduced to this subset. In this section, these additions will be described--all of them created to adapt the language better to educational applications.

First, the tags filelist and file have been introduced; they must be used in the header of the document. They define a file list that the browser must download as soon as it loads the document and at the same time as it renders the elements. The files in the list are supposed to be used in the current document and this way they will be available in the browser cache. These files can be images, sounds and so forth; a name can be assigned to them so they can be used in a simple way. To download files in advance is very useful because, when necessary, they can be obtained quickly. There are interests in reducing the delays in web-browsing, and experimental browsers have been developed with this objective (Arellano-Cid & Von Brand, 2000). There are ways to download files in advance in HTML 4, but the proposed approach is to provide a simple way to do it and a simple mechanism to refer later to the downloaded files. In Figure 5 there is an example of the use of these tags. The figure illustrates that the file tag has the attributes name and src respectively, to indicate the name and the source of each file. Using this name, the file can be referenced wherever it is necessary in the document.

[FIGURE 5 OMITTED]

Another tag included is sobject, it means sprite object and it is used when it is necessary to add an object of the object model to a document. It has attributes like class to specify the object class, top and left to indicate the position, width and height for the dimensions, currentimage for the current image and so forth. Another attribute is deltatime it is used to indicate a time interval for the OnTimer event to be executed; this allows executing actions synchronously. These objects have the following events: OnMouseDown, OnMouseUp, OnClick, OnKeyDown, OnTimer and so forth. In Figure 6 there is an example of how the sobject tag can be used.

[FIGURE 6 OMITTED]

In Figure 6, the creation of an object of the TSprite class is being indicated, with Sprite 1 as its name, and that the Sprite1 OnTimer function will handle the time events for this object. In other section it will be shown how to implement functions. It can also be seen that an image file name is assigned to the currentimage attribute; this name must be defined using the filelist tag.

The Tags: Pattern and Include

Almost every web application, and an educational application in particular, has objects and/or handlers to user events, etc., that repeat themselves from page to page. There are no high level features for reusing all the elements already defined in a webpage. In order solve this problem, the pattern tag has been defined; it must be used in the document header. In Figure 7, an example of its use is shown.

[FIGURE 7 OMITTED]

Figure 7 illustrates the use of the tags pattern, patternhead and patternbody. Everything defined within the patternhead tag will be considered as included in the document header and everything defined within the patternbody tag will be considered as included in the document body. Once a pattern has been defined, other pages can use it; this can be done by referencing the pattern's name using the include tag, as in Figure 8.

[FIGURE 8 OMITTED]

Elements defined outside the pattern in the header or in the body of the page are considered as particular characteristics of the given page. These characteristics differentiate them from other pages that use the same pattern. The use of patterns implies a better use of the bandwidth. When the browser receives a pattern, it registers it because it should be used again in the application. Once the session is closed or the user logs out the memory assigned to the pattern is freed.

Patterns allow lesson elements to be reused within the application. When a student interacts with an educational application for the Internet there are many interactions with the web server: pages and teaching material downloads, data uploading, etc., but there are elements that remain the same during more than one interaction. Those elements can be objects that provide links to didactic material or can be resources like images, among others. Sometimes not only the objects remain the same, but also the basic performance in general is the same with minor changes. Current browsers do not allow the reuse of these elements, content and behavior in an easy to use way. Patterns make this possible in an easy and more general way than the use of frames, because inside a pattern can be included with any element no matter its physical location in the application. If it is necessary to make a changed to any object included in a pattern after a given interaction this can be done using dynamical additions. This way, for example, an OnClick event of a button inside the pattern can be change to redirect a link to a resource or to a new content according to students' skills and knowledge. In doing so, it is possible to generate parallel navigation paths dynamically, adapted to the students' necessities and aims. If, in the example just given, the button is outside the pattern it is easier to generate a parallel path. This can be done when the new page is generated in the server. There is a great interest in parallel path generation, such as the work of Atif, Benlamri, and Berri (2003). These authors also state that tools for the development of educational applications must allow the implementation of as many educational models as possible.

Main Characteristics of the OPScript Language

OPScript is a client-side scripting language for web applications. Up to now, there are two popular client-side languages for the Web: Java and JavaScript. Java is an object-oriented language, JavaScript is simpler, but has an advantage--there is no need for plug-ins to run the JavaScript code. There is an important project oriented to create a language which allows object-oriented programming without the need of plug-ins (Hennen, Ramachandran, & Mamrak, 2000). Hennen et al. define a new language named Object-JavaScript. The approach is to later convert the code to JavaScript. The problem with this is that the final code has the same limitations as JavaScript; the advantage is that compatibility is assured.

OPScript and Pascal syntax are very similar. See (Katrib & Quesada, 1991) for a reference of the Pascal language. Here, some of the main characteristics of OPScript will be discussed; the compiler for the language has been developed using the techniques in (Aho, Ravi, & Ullman, 1998).

It must be said that OPScript is not a strongly typed language like Pascal is. It means that a given variable can hold a value of any type at any time during code execution. Like Pascal, OPScript allows object-oriented and procedural programming. As in other script languages for the Web, events are handled using functions. The OPScript code is added using the script tag. In addition, the code is written between comments and in the header of the document. Figure 9 illustrates this fragment of code that is very similar to a function written in Pascal. The main difference is that there is no result type declared. It is because the language is not strongly typed, so the result type is variant by default. If it is not necessary to receive any data as the result of the function, a procedure could be implemented.

[FIGURE 9 OMITTED]

Adding New Class Members to Object Model Classes Using OPScript

One of the main differences between OPScript and Pascal is the dynamic addition of new class members to classes. The syntax of the addition of class members in OPScript is very similar to the syntax of the inheritance in Pascal. However, in this case a new class is not created, but a previously created class is modified. See Figure 10 for an example. This figure shows how to add new members to a given class. These are the steps:

1. First, a class addition must be declared. Its name should be a valid identifier--a sequence of letters and numbers that begins with a letter or "_". The word addition must be used to indicate that an addition will be made.

2. The reserved word fields is used when new fields must be added. Next, field names are declared. The use of the modifier static means that the modified field will be used in upcoming documents and, therefore, it must be kept as part of the indicated class (in this example, TSprite). These additions persist during the session or up to the moment when the user quits the educational application. If the modifier is not used, when another page is downloaded the field will be eliminated from the given class. In the case of the second field, SecondName, it is not static, but after its declaration a function to access it has been declared; this allows some code to execute when the field is accessed. As shown in the example, fields already presented in the original class can be accessed as well. This way new members can be related with old members. Methods to access a given field must be declared in the fields part and must start with Get plus the name of the field for getting the value of the field, or with Set plus the name of the field for setting a new value to the field. If no such methods are provided for a given field it can be accessed freely by the programmer.

3. The reserved word methods is used to add new methods, and next, methods are declared and their implementation is made in-line. The static modifier can also be used for methods; in this case it means that the method will be used in upcoming documents.

[FIGURE 10 OMITTED]

Declaration of Doer and Shell Methods

The previous section mentioned the existence of two special kinds of methods in the classes of the object model: shell and doer methods. The combined use of them can give more versatility to the objects used in an application. Figure 11 has a fragment of code showing how to include new methods to a class, specifying if they belong to one or other category. The first method, RefreshDoer, has been defined as a doer method and it will be added to the list of doer methods of the Refresh method present in TDocumentManager class. Due to the presence of the IgnoreAll modifier it will be the only one to call. The second method, Display, is defined as a shell method; everything implemented in the method will be executed before its list of doer methods. Currently, a more powerful approach has been developed. It will allow the definition of some code to be executed after the list of doer methods. This way, simple aspects can be implemented in an easy way in the language. Aspects are now very popular (Shonle, Lieberherr, & Shah, 2003). The last declaration in Figure 11 defines the DisplayDoer method that will be added to the list of doer methods of the Display method just added; in this case it will be the first and only one method in the list.

Also, in this fragment of code a field is added to the TDocumentManager class. This field has the static modifier; this implies that it can be used in other documents of the application. This way, application specific variables can be defined. These variables can be shared between documents because they will belong to the DocumentManager object. They can be objects that will be used in various documents, or data to be passed from document to document and so forth. This feature can be used to share information between documents which can help in adapting lessons better to the special necessities of a given student.

Actually, doer and shell methods are objects. They can be declared and called as normal methods, but they are instances of the Shell and Doer classes belonging also to the object model. These classes inherit from the Method class. At this moment, the programmer cannot define its own method classes, but in the future this will be possible. The use will be similar to that of the Doer and Shell classes. A new class is defined and later its name can be used as a method modifier; anything the programmer puts after the modifier is passed as a parameter to the constructor of the class. The programmer will be able to define methods with special characteristics and optimizations. For example, it will be possible to optimize special cases of recursive methods, saving time and stack space.

[FIGURE 11 OMITTED]

YADBrowser and its Relation with Didactic Models

The generality of the OPScript language and the adaptability of the object model of the YADBrowser make them suitable to be used in various didactic methods and for a wide range of students' age. Parallel learning path can be defined, although more development is needed to achieve more generality, in order to adapt a given educational product better to the skill level of the user.

It is very important for teachers to be able to reuse teaching material. For example, it could be necessary to explain some lessons in different ways using the same multimedia materials or lesson content. With the YADBrowser, this can be achieved by using two features: patterns and dynamical additions. With these features, any lesson content that is common for more than one topic can be defined as a pattern, and the content that depends on the given topic can be defined with dynamical additions.

The authors are also working in providing an interface with expert systems. The expert system would receive information acquired from the user. The class TUser provided by the object model of the browser will supply that information to the expert system.

CONCLUSION

In this article, the object model, some characteristics of the markup language and the script language for the educational browser, YADBrowser, have been exposed. They are part of an investigational project directed to the creation of new languages which facilitate the creation of educational applications for the Internet.

The browser offers characteristics that make it suitable for a wide variety of educational applications and for many didactic approaches. Among them, dynamical persistent additions and the presence of the doer and shell methods are the most important. It also offers a wide collection of objects for the creation of educational applications.

References

Aho, A., V., Ravi, S., & Ullman, J., D. (1998). Compiladores: Principios, tecnicas y herramientas. Addison Wesley Longman.

Arellano-Cid, J., & Von Brand, H. H. (2000). Network programming internals of the Dillo web browser. [Online]. Available: http://csdl.computer.org/comp/proceedings/sccc/2000/0810/00/08100178abs.htm

Atif, Y., Benlamri, R., & Berri, J. (2003). Learning objects based framework for self-adaptive learning. Education and Information Technologies 8(4), 345-368.

Bosak, J. (1997). XML, Java, and the future of the web. [Online]. Available: http://www.ibiblio.org/pub/sun-info/standards/xml/why/xmlapps.htm

Boyle, T. (2003). Design principles for authoring dynamic, reusable learning objects. Australian Journal of Educational Technology, 19(1), 46-58. [Online]. Available: http://www.ascilite.org.au/ajet/ajet19/boyle.html

Boyle, T., & Cook, J. (2001). Towards a pedagogically sound basis for learning object portability and re-use. [Online]. Available: http://www.ascilite.org.au/conferences/melbourne01/pdf/papers/boylet.pdf

Cole, D., Wainwright, R., & Schoenefeld, D. (1998). Using Java to develop web based tutorials. Technical Symposium on Computer Science Education. Proceedings of the Twenty-Ninth SIGCSE Technical Symposium on Computer Science Education, pp 92-96.

Dennis, B., M., & Harrison, M., A. (1997). Grendel: A web browser with end user extensibility. [Online]. Available: http://csdl.computer.org/comp/proceedings/compcon/1997/7804/00/78040074abs.htm

Hennen, D., S., Ramachandran, S., & Mamrak, S., A. (2000). The object-JavaScript language. [Online]. Available: http://acuity.cis.ohio-state.edu/Nois/Tguide/ojs.ps

Henricksen, K., & Indulska, J. (2001). Adapting the web interface: An adaptive web browser. [Online]. Available: http://www.dstc.edu.au/m3/papers/AUIC2001.pdf

Hoyos-Rivera, G., J., Lima-Gomes, R., Courtiat, J. P., & Benabbou, R. (2003). The web as a tool for collaborative e-learning: The case of CoLab. [Online]. Available: http://csdl.computer.org/comp/proceedings/icalt/2003/1967/00/19670312abs.htm

Huang, C., & Chao, Y. (2001). Universal WWW access for heterogeneous client devices. [Online]. Available: http://csdl.computer.org/comp/proceedings/euromicro/2001/1236/00/12360315abs.htm

Huang, R., & Ma, J. (2001). A Java technology based shared browser for tele-lecturing in University 21. [Online]. Available: http://csdl.computer.org/comp/proceedings/iccima/2001/1312/00/13120298abs.htm

Java World Wide Web Site. [Online]. Available: http://java.sun.com

Katrib, M., & Quesada, O. (1991). Programacion con Pascal. Editorial Pueblo y Educacion.

Kikuchi, H., Kato, H., & Akahori, K. (2002). Analysis of children's web browsing process: ICT education in elementary schools. [Online]. Available: http://csdl.computer.org/comp/proceedings/icce/2002/1509/00/15090253abs.htm

Mangiaracina, S., & Maioli, M. (1995). Building hypermedia for learning: A framework based on the design of user interface. Technical Report UBLCS-95-8. [Online]. Available: ftp://ftp.cs.unibo.it/pub/TR/UBLCS/95-08.ps.gz

Martin, R. (1996). The open-closed principle. [Online]. Available: http://www.objectmentor.com/resources/articles/ocp.pdf

Montessoro, P., Pierattoni, D., & Cicuttini, R. (2003). MTeach: A simple production framework for context-based educational hypermedia. Journal of Educational Multimedia and Hypermedia 12(4), 335-359. [Online]. Available: http://dl.aace.org/14211

Netscape Corporation. JavaScript Central [Online] Available: http://devedge.netscape.com/central/javascript/

Pressman, R., & Ince, D. (2000). Software engineering: A practitioner's approach. 5th ed. European edition. McGraw-Hill.

Rees, M., J. (2002). Evolving the browser towards a standard user interface architecture. [Online]. Available: http://crpit.com/confpapers/CRPITV7Rees.pdf

Romero, V., A. (2002). SpriteKernel: Herramienta para el desarrollo de multimedia. In Calderon, C. A. & Ledo Mezquita, L. Y. (Eds.), La telematica y su aplicacion en la educacion a distancia y en la informatizacion de la sociedad. Tomo I. Editorial Felix Varela, pp. 49-54.

Romero, V., A. (2003a). Biblioteca GraphicalSpriteKernel (GSK): Implementacion de una arquitectura de tres modelos para crear multimedia educativa. In Dias, P., Varela, C. (Orgs.), Challenges 2003 e 5.[degrees] SIIE. Actas da III Conferencia Internacional de Tecnologias de Informacao e Comunicacao na Educacao e 5.[degrees] Simposio Internacional em Informatica Educativa. Centro de Competencia Nonio Seculo XXI da Universidade do Minho, pp. 663-673.

Romero, V., A. (2003b). Experiencias sobre la creacion de multimedia con grupos de estudiantes en la Casa del Software de la Universidad de Cienfuegos. Submitted for publication.

Shonle, M., Lieberherr, K., & Shah, A. (2003). XAspects: An extensible system for domain-specific aspect languages. [Online]. Available: http://www.cs.ucsd.edu/users/mshonle/p28-shonle.pdf

Teixeira, J.C., Paris, C., Madeira, J., & Brisson Lopes, J. (1999). Courseware reuse or courseware to reuse? Proceedings of GVE '99--Computer Graphics and Visualization Education '99, 199-202.

Theoktisto, V., Bianchini, A., Ruckhaus, E., & Lima, L. (2003). AVANTE: A web based instruction architecture based on XML/XSL standards, free software and distributed CORBA components. UPGRADE 4(5), 29-38. [Online]. Available: http://www.upgrade-cepis.org/issues/2003/5/up4-5Theoktisto.pdf

Uehara, S., Mizuno, O., & Kikuno, T. (2001). An implementation of electronic shopping cart on the web system using component-object technology. [Online]. Available: http://www-kiku.ics.es.osaka-u.ac.jp/paper/data/pdf/10.pdf

Van Ossenbruggen, J., Hardman, L., & Rutledge, L. (2002). Hypermedia and semantic Web: A research agenda. Journal of Digital Information, 3(1).

Wang, P., S., Kajler, N., Zhou, Y., & Zou, X. (2003). WME: Towards a web for mathematics education. [Online]. Available: http://ox.cs.kent.edu/~pwang/47wang.pdf

W3C HTML 4.01 Specification [Online]. Available: http://www.w3.org/TR/html4/

Xiao, L., Zhang, X., & Xu, Z. (2002). On reliable and scalable peer-to-peer web document sharing. [Online]. Available: http://csdl.computer.org/comp/proceedings/ipdps/2002/1573/00/15730023babs.htm

Xiao, L., Zhang, X., Andrzejak, A., & Chen, S. (2004). Building a large and efficient hybrid peer-to-peer internet caching system. [Online]. Available: http://csdl.computer.org/comp/trans/tk/2004/06/k0754abs.htm

Acknowledgements

This work is partially funded by the University of the Basque Country (UPV00141.226-T-14816/2002), the Spanish CICYT (TIC2002-03141) and the Gipuzkoa Council in a European Union program. Also the authors would like to thank the anonymous referees for they insightful comments and suggestions that greatly helped us improving the quality and presentation of the paper.

VICENTE ARTURO ROMERO ZALDIVAR

University of Cienfuegos 

Cuba

[e-mail]

JON ANDER ELORRIAGA ARANDIA

University of the Basque Country

Spain

[e-mail]

MATEO LEZCANO BRITO

University of Las Villas

Cuba

[e-mail]