Computer Aided Exercise Generation

A Framework for Human Interaction in the Automated Exercise Generation

Process

Valentin Nentwich, Nicolai Fischer, Andreas C. Sonnenbichler and Andreas Geyer-Schulz

Information Services and Electronic Markets, Karlsruhe Institute of Technology, D-76128 Karlsruhe, Germany

Keywords:

Automated Exercise Generator, Generation, Process.

Abstract:

Creating exercises for tutorials and exams is part of lecturers’ daily business. Manually creating new exercises

for each course is very time expensive. Literature shows many technical solutions in terms of online learning

platforms supporting exercise generation, answer checking and students’ progress follow up. Most approaches

solve speciﬁc problems and cannot be generalized in a way that a pattern for system design can be deducted.

In this paper we point out a generic model for human interaction in the automated exercise generation process

by identifying general constructs of exercise generation and by applying them on the outlined user interaction

pattern. The application of the ﬁndings in a prototype for multi-criteria decision analysis indicates viability of

the explained concept.

1 INTRODUCTION

Reaching and offering high quality mentoring and ed-

ucational content is a desirable goal in the teaching

sector of a university. The time consuming process

of repetitive exercise generation captures avoidable

ressources and therefore leads to bad quality of ed-

ucation. Otherwise, one could maintain high-quality

tasks like promotion of talent programs or assistance

of the gifted students.

An information and communication technology

(ICT) driven approach promises to reduce required

manual efforts thus freeing resources and enables

teaching which contains offering educational content

and supporting students’ learning process in a radical

new fashion. Exemplary, students can be offered an

interactive learning infrastructure where self-directed

learning is supported. Despite of learning in a self-

service manner a direct or indirect tutoring system can

be applied. Using ICT in the process of education re-

quires a high automation level. In particular, system

components have to be taken into account: the gen-

eration of exercises is one of the greatest problems

identiﬁed by (Sadigh et al., 2012).

In terms of the problem of automatic exercise gen-

eration literature shows several speciﬁc approaches

for automating task creation itself or parts of the gen-

eration process. In section 2 we examine existing con-

cepts which serve as a basis for the in section 3 ﬁg-

ured out constructs of exercise generation. In our un-

derstanding constructs are reusable components that

can be used as building blocks for educational sys-

tems. Building blocks keep the system maintainable

and enrich an automated exercise generation process.

In section 2 identiﬁed implementations for differ-

ent education systems show a deep variation in its fo-

cus on system aspects and a lack of a common way

in system design. Our main contribution is a frame-

work for human interaction in the automated exercise

generation process. The developed process closes the

gap of interaction between lecturer and educational

system and consequently serves as conceptual basis

for the design of an education system.

The introduction of the exercise generation pro-

cess in section 4 contains a precise explanation of the

four process steps. The identiﬁed constructs of exer-

cise generation (section 3) are associated with each

corresponding process step. The exercise generation

process serves as a basis for the design of our educa-

tion system prototype. The implemented prototype in

the ﬁeld of use multi-criteria decision problems indi-

cates viability and serves as proof of concept to show

that the general idea works.

2 RELATED WORK

Gonzales and Munoz developed a web-based educa-

Nentwich, V., Fischer, N., Sonnenbichler, A. and Geyer-Schulz, A.

Computer Aided Exercise Generation - A Framework for Human Interaction in the Automated Exercise Generation Process.

DOI: 10.5220/0005947700570063

In Proceedings of the 13th International Joint Conference on e-Business and Telecommunications (ICETE 2016) - Volume 2: ICE-B, pages 57-63

ISBN: 978-989-758-196-0

tional software for providing students with statistical

and mathematical exercises. Further features include

evaluations of students answers as well as data man-

agement and support for exercise generation to teach-

ers (Gonzalez and Munoz, 2006).

Aldabe et al. present a question generator which

automatically creates exercises for students. Automa-

tion is reached by making use of natural language

processing (NLP) techniques and corpora. As con-

crete results exercises for ﬁll-in-the-blank, word for-

mation as well as multiple choice and error correction

are constructed (Aldabe et al., 2006).

Sadigh et al. show a template-based approach

to establish automation in the teaching life cycle ad-

dressing creation of problems and corresponding so-

lutions as well as grading (Sadigh et al., 2012).

Merceron and Yacef explain an approach for a

web-based tutoring system giving feedback for stu-

dents and teachers. Students are provided with a step

by step feedback during solving exercises. A mining

component establishes the opportunity for analysing

students answers to feedback teaching methods (Mer-

ceron and Yacef, 2003).

Chrysaﬁadi and Virvou present different ap-

proaches for student modelling. Student modelling

includes initial assessment, tracking and adapting of

the student knowledge level and preparation of exer-

cise presentation for individuals (Chrysaﬁadi and Vir-

vou, 2013).

Lopez et al. designed a coached problem solving

system for teaching the simplex algorithm. The im-

plementation contains a problem generator, a student

model based exercise adaptation and a dynamic help

system for assisting students in improving their mis-

takes (Lopez et al., 1998). Volodina and Borin use

a similar approach for teaching languages (Volodina

and Borin, 2012).

Devedzic describes an intelligent web-based ed-

ucation system by clustering basic components of

today’s educational technology into a framework.

For higher reusability and ﬂexibility the educational

content is described by semantic aspects (Devedzic,

2003).

Melis et al. use a knowledge base for dynam-

ically generating individual, mathematical tutoring

content. Semantic methods serve as a main build-

ing block for the realisation. Additionally, a inter-

face for connecting stand-alone service systems opens

the tutoring tool in terms of public educational mate-

rial (Melis et al., 2001). Almeida et al. propose a

speciﬁc language for designing more complex exer-

cises than multiple choices, data type or ﬁle compar-

isons (Almeida et al., 2013). Further ontology based

approaches can be found in (Holohan et al., 2006).

Adamopoulos’ research paper identiﬁes key char-

acteristics inﬂuencing the long term afﬁnity of users

to web based learning environments. The most im-

portant key characteristics are involved professors,

the students’ attitude towards teaching contents as

well as difﬁculty, workload and duration of a les-

son (Adamopoulos, 2013). Workman depicts how

computer-based education and computer-aided edu-

cation inﬂuence students’ ability to learn (Workman,

2004).

Vossen and Westerkamp propose to publish learn-

ing content through web service interfaces. A learn-

ing content database consisting of e-learning courses

and learning objects serves as a basis for web service

methods. The web service interface implements, inter

alia, content presentation, user tracking and content

creation (Vossen and Westerkamp, 2003).

3 CONSTRUCTS OF EXERCISE

GENERATION

In this section we present constructs that are able to

enrich an automated exercise generation process. Ac-

cording to (Gregor and Jones, 2007) constructs de-

scribe entities of interest related to a speciﬁc design

theory which can be simple terms and mathematical

symbols or complex sub-systems. Identiﬁcation of

these constructs is based on section 2.

The following constructs were identiﬁed: ontolo-

gies, student modelling, feedback mechanisms, web

service interfaces and a help suggestion system.

Gruber describes ontologies as a formal speci-

ﬁcation for classes, relations as well as functions

and objects in a shared domain of interest (Gru-

ber, 1993). Formal speciﬁcation makes ontologies

machine-understandable which is a key functionality

for automation.

A student model is the result of the process for de-

scribing and analysing cognitive skills of a speciﬁc

student (Self, 1990). Chrysaﬁadi and Virvou men-

tion this characteristic as a base for personalisation

and state that it is a decisive factor for adaptive edu-

cational systems (Chrysaﬁadi and Virvou, 2013).

Franklin et al. delineate a feedback mechanism as

a dynamic system where measured output is used for

determining the system’s future behaviour (Franklin

et al., 1994). Such feedback mechanisms are the

foundation for assisting in educational systems as por-

trayed by (Merceron and Yacef, 2003).

Literature shows that the term web service is

ambiguous. For our work we refer to Papazoglou

who outlines service interoperability, service orches-

tration, service transaction management and service

ICE-B 2016 - International Conference on e-Business

coordination as characteristics for web services (Pa-

pazoglou, 2003). These enable simple network ac-

cess on teaching platform components and therefore

reusability.

Lopez et al. consider student assistance by solv-

ing exercises as a necessary element of an educational

system (Lopez et al., 1998). With regard to this fact

the exercise generation process has to provide a func-

tionality for suggesting capabilities to support stu-

dents – a help suggestion system.

The identiﬁed constructs can be used to enrich

automated exercise generation whereas each compo-

nent is part of a speciﬁc solution and realises differ-

ent tasks. Today, there is a lack of design method for

building exercise generation systems on top of mul-

titude system components. In the following sections,

we introduce a generic process for educational system

design to face this challenge.

4 EXERCISE GENERATION

PROCESS

In this section, we introduce our exercise generation

process referring to ﬁgure 1. We explain every pro-

cess step and associate the constructs identiﬁed in sec-

tion 3 giving a short example. Furthermore, we point

out the necessary technical aspects for the realisation

as a web educational system serving as a foundation

for our prototype.

4.1 Select and Modify Exercise Context

First step of the exercise generation process is the se-

lection and modiﬁcation of the exercise context.

The exercise context speciﬁes the exercise frame-

work and thus builds the association to a certain ﬁeld

of use. For example we have the problem to purchase

a car. In this situation the purchaser has to choose be-

tween several alternatives and selects the one which

meets best his requirements. This example shows a

speciﬁc exercise context for the abstract problem of

decision making. Further problems of this category

could be an investment decision or choosing the right

university.

For building an exercise context two different ap-

proaches are conceivable: manually or automated. A

naive method is to manually build up and maintain

a context database by lecturers. Automated context

generation can be reached by making use of the con-

struct ontologies. Technically, we call this component

a context generator.

Applying these approaches on the sub process

”Select and Modify Exercise Context” both human

and machine have different tasks to complete. In case

of manually created exercise contexts lecturers have

to imagine and construct ﬁctitious ﬁelds of use to feed

an exercise context database. For automated gener-

ated exercise contexts machines take this part. How-

ever we assume, that an exercise context database ex-

ist and for the manually as well as the automated ap-

proach the lecturers simply choose a suitable context

for building up his exercise during the exercise gener-

ation process. In this step, modiﬁcation gives the op-

portunity to correct mistakes and to apply lecturers’

own style.

Select and Modify

Exercise Context

Select and Modify

Exercise Type

Edit Generated

Parameters

Export and Archive

Exercise

Figure 1: Exercise generation process.

4.2 Select and Modify Exercise Type

Second step of the exercise generation process is the

selection and modiﬁcation of the exercise type.

An exercise type deﬁnes a general structure of

an exercise. For the mentioned example of purchas-

ing a car as a multi-criteria decision problem multi-

ple strategies for making the decision exist. Exem-

plary one could sum up the values-in-use for each al-

ternative and choose the best one. Another example

could be choosing the alternative which has the high-

est score for the leading goal. Each decision strategy

leads to a different general exercise type which can

be implemented by different instances. Instances of

the same general exercise type can differ in their spe-

ciﬁc structure. Exercise types serve as input for the

automated creation of students’ exercises by the com-

ponent exercise generator.

Computer Aided Exercise Generation - A Framework for Human Interaction in the Automated Exercise Generation Process

Controller

Model

View

Update

Notify

User Action

Update

models.py

calculator.py

generator.py

views.py

urls.py

inputparameter.html

edit.html

export.html

contextgeneration.html

Figure 2: Prototype scheme (MVC as described in (Ullenboom, 2014)).

The characteristics for lecturers’ interaction in the

sub process ”Select and Modify Exercise Type” are

selecting an appropriate exercise type and deﬁning its

speciﬁc structure by establishing individual parame-

ters. Referred to our example, a lecturer can choose

target weighting as exercise type and set as parame-

ters the individual weights for each target. In accor-

dance with this input the exercise generator compo-

nent automatically creates the exercise.

4.3 Edit Generated Parameters

Third step of the exercise generation process is editing

the parameters generated by the exercise generator.

The exercise generator’s output is a complete task

for students including exercise text, questions, hints

for solution and solutions themselves. We assume that

developers’ cognitive skills are limited and even mak-

ing use of ontologies and natural language processing

in automated exercise generation leads to inaccurate

or unfair produced exercises, respectively exercise pa-

rameters. Considering this, the basic idea of this pro-

cess step is to give lecturers the chance to adjust pa-

rameters.

In this process step it is possible to install three

constructs presented in section 3: feedback mech-

anisms, the help suggestion system and the student

model.

As mentioned in (Merceron and Yacef, 2003),

stored student answers can be mined to gather infor-

mation about typical problems or mistakes which oc-

cur while solving an exercise. Properly processed, the

information can be used as feedback for the lecturer

and help him to adjust parameters of a certain exercise

type accordingly.

There are two different approaches to work with

the help suggestion system. Firstly, it is conceiv-

able that a lecturer is able to turn on or to turn off

speciﬁc features of the help suggestion system man-

ually – as a consequence the lecturer determines how

much students are supported. An automated approach

is to support students dynamically according to their

knowledge level represented by a student model – as

a consequence the students are supported individually

by the help suggestion system.

Lecturers interact in this process step by evalu-

ating machine produced exercises and by adjusting

phrasing as well as input parameters for calculations.

According to the previous example, the exercise gen-

erator creates the textual description of the exercise

as well as the matrix containing the values-in-use for

the target weighting decision problem. Lecturers’ are

ICE-B 2016 - International Conference on e-Business

able to edit the exercise text and the generated values

of the matrix. If there are changes in input values for

calculation the exercise generation component has to

automatically adapt proposed solutions and assistance

for solving the problem.

4.4 Export and Archive Exercise

Fourth step of the exercise generation process is ex-

porting and archiving the generated exercise.

Basic idea of this step is, that done work has to be

saved for further use. The export functionality gives

tutors the ability to convert the generated exercise into

a speciﬁc data format like the portable document for-

mat (PDF) or L

X. Archiving means to store the

generated exercise in a database for future lookup and

processing.

In the sub process ”Export and Archive Exercise”

lecturers’ interaction in the simplest case is choosing

the data format for exporting and to record general

data like the lecturer’s name or the description of the

semester. Technically, a component for archiving and

a component for exporting have to exist to perform

machine parts in this process step.

In our example, the lecturer chooses L

X as ex-

port format. As a result the lecturer gets a L

X ﬁle

containing the exercise description, questions, a ma-

trix with values-in-use and a solution outline adjusted

for the case of the target weighting decision problem

”purchasing a car”.

5 PROTOTYPE

In this section we present a prototype which indicates

viability of the explained exercise generation process.

We ﬁll up the prototype by an example in the ﬁeld of

use multi-criteria decision problems. We explain the

technical set up of our prototype pointing out the gen-

eral as well as the detailed structure. In each step we

show how the exercise generation process can be ref-

erenced to the prototype in the scope of an economic

example.

5.1 General Structure

This section gives a short overview about the gen-

eral structure of the prototype and its implemen-

tation. Vossen and Westerkamp propose web ser-

vice interfaces for realisation of educational sys-

tems (Vossen and Westerkamp, 2003). Furthermore,

the model-view-controller pattern (MVC) is a com-

mon agreed design pattern for designing a compo-

nent based application where each component can

be developed independently (Ullenboom, 2014). We

use Django (Django Documentation, 2015) as a sim-

ple web framework based on Python (Python, 2015)

which supports MVC and thus reusability.

Figure 2 shows the general scheme of the proto-

type considering the MVC pattern as described in (Ul-

lenboom, 2014): the model represents the internal

state of an object for enabling persistent data storage

and manipulation. Views deﬁne how data is presented

in the user interface. The controller processes the user

interaction including model and view updating.

5.2 Model

This section includes a detailed explanation of the

model’s structure. Every class describing a model

object in Django is placed into the models.py

ﬁle (Django Documentation, 2015). We use the data

model shown in ﬁgure 3 to describe these classes.

Exercise type

Exercise context

Target

Scale

Value

Alternative

Figure 3: Data model used for implementing models.py.

An exercise type deﬁnes the general structure of

an exercise. In case of the example ”purchasing a car”

as a multi-criteria decision problem the following ex-

ercise types are conceivable: target weighting, lexi-

cographical ordering, maximum of the minimal target

achievement, goal programming and mixed up exer-

cise type consisting of the types mentioned.

The scenario of an exercise plays in a speciﬁc con-

text. Therefore we introduced the generic component

exercise context, which can be applied on several ex-

ercise types. The scenario in our example plays in the

context of ”purchasing a car”. As exercise type tar-

get weighting is selected. It is possible to choose e.g.

goal programming as exercise type by using the same

context of ”purchasing a car”.

A generic exercise context is composed by sev-

eral targets and alternatives. Targets in the sense of

a multi-criteria decision problem display the value

Computer Aided Exercise Generation - A Framework for Human Interaction in the Automated Exercise Generation Process

proposition of a decision maker for solving the de-

cision problem. The value of a target is expressed by

a scale which is implemented by discrete or continu-

ous values. Alternatives represent options that can be

chosen by a decision maker.

To complete our example, we add alternatives, tar-

gets, scales and values. Alternatives in our case could

be the cars ”Audi A3”, ”VW Golf” and ”Scoda Oc-

tavia”. Attributes the cars have in common can be

viewed as desired goals to achieve. Let’s say we con-

sider ”PS”, ”fuel consumption”, ”mileage” and ”CO2

conformity” as viewed targets to compare the cars.

To achieve the processing of given targets we add a

scale to each target. Processing means the selection

of the best alternatives according to the exercise type’s

methods. A scale e.g. can be kilometers with the val-

ues 10km, 100km and 1000km in case of the target

”mileage” or boolean (true/ false) in case of the target

”CO2 conformity”.

5.3 View

Views deﬁne how data is presented in the user inter-

face. For the view component in the prototype we

designed different HTML templates (as in ﬁgure 2)

matching the requirements of the exercise generation

process.

The ﬁrst step of the exercise generation process is

realised by the inputparameter.html. Within this tem-

plate a existing exercise context can be chosen and

targets as well as alternatives can be adapted for the

speciﬁc exercise type. If there is no appropriate ex-

ercise context, the user can navigate to contextgen-

eration.html which is a template for manually creat-

ing generic exercise contexts. Moreover, inputparam-

eter.html includes the second step of the exercise gen-

eration process. Our protoype contains the following

choosable and editable exercise types: target weight-

ing, lexicographical ordering, maximum of the mini-

mal target achievement, goal programming and mixed

up exercise type consisting of the types mentioned.

Input parameters are processed by the controller

to generate an exercise. The user is navigated to

the edit.html where automatically created exercise pa-

rameters can be viewed and adjusted by the lecturer.

In our prototype the entries of the use matrix can be

edited.

After editing users have the opportunity to export

and to archive the complete exercise (export.html).

Export formats that can be chosen are PDF and L

5.4 Controller

The controller navigates the user and processes input

parameters. Django realises navigation by the use of

views.py and urls.py. Url requests are catched by the

urls.py and directed to the mapped view. Views are

build by views.py which is responsible for parameter

processing. Processing work is assisted by calcula-

tor.py and generator.py. HTML templates of the view

component are enriched by generated parameters.

The supporting component generator.py automat-

ically creates the exercise including exercise text, in-

put values for calculation, questions as well as a so-

lution outline. Generator.py ﬁlls a static exercise text

with the values of the selected exercise context. Addi-

tionally, a use matrix is set up with random values. To

each exercise type static questions are assigned. As

a naive approach for the implementation of the help

suggestion system, we provide an solution outline au-

tomatically composed by generator.py.

The supporting component calculator.py offers

different mathematical methods that can be used for

calculation in generator.py. Example methods are:

generating random values, ﬁnding minimum or maxi-

mum values with respect to targets’ scales and solving

decision problems.

6 CONCLUSION

In this article, we described a framework for human

interaction in the automated exercise generation pro-

cess. We examined current approaches for educa-

tional system design (section 2) to identify basic com-

ponents realising different tasks within the speciﬁc

solutions reviewed. Our contribution lies in the cre-

ation of a generic process as a design method for de-

veloping educational systems.

In section 3, we presented constructs that are able

to enrich an automated exercise generation process.

The following constructs were identiﬁed: ontologies,

student modelling, feedback mechanisms, web ser-

vices interfaces and a help suggestion system.

In section 4, we introduced our generic exercise

generation process. Furthermore, an associations be-

tween each process step and its corresponding con-

structs is made. Additionally, we pointed out nec-

essary technical aspects for the realisation as a web

educational system.

In section 5, we presented our prototype indicat-

ing viability of the explained concept. Therefore, we

described the prototype’s set up basing on the exer-

cise generation process. Firstly, we pointed out the

general structure of our Python/Django implementa-

tion. Secondly, we give a detailed insight into the

used structure for implementing our protoype: the de-

sign according to the exercise generation process is

ICE-B 2016 - International Conference on e-Business

transferred into the technical view of the model-view-

controller pattern.

The paper at hand presents a process on a high

level of abstraction including general concepts of

technical solution for educational systems. Regard-

ing future work, a more extensive analysis by expand-

ing the review of existing theoretical and practical ap-

proaches can lead to a more precise shape of our ex-

ercise generation process.

REFERENCES

Adamopoulos, P. (2013). What makes a great mooc? An

interdisciplinary analysis of student retention in online

courses. In Thirty Fourth International Conference on

Information Systems, pages 1–21, Milan.

Aldabe, I., de Lacalle, M., Maritxalar, M., Martinez, E.,

and Uria, L. (2006). Arikiturri: An automatic ques-

tion generator based on corpora and nlp techniques. In

Intelligent Tutoring Systems, volume 4053 of Lecture

Notes in Computer Science, pages 584–594. Springer

Berlin Heidelberg.

Almeida, J. J., Araujo, I., Brito, I., Carvalho, N., Machado,

G. J., Pereira, R., and Smirnov, G. (2013). Passarola:

High-order exercise generation system. In Eighth

Iberian Conference on Information Systems and Tech-

nologies (CISTI), 2013, pages 1–5, Lisboa. IEEE.

Chrysaﬁadi, K. and Virvou, M. (2013). Student modeling

approaches: A literature review for the last decade.

Expert Systems with Applications, 40(11):4715–4729.

Devedzic, V. B. (2003). Key issues in next-generation web-

based education. IEEE Transactions on Systems, Man,

and Cybernetics, Part C, 33(3):339–349.

Django Documentation (2015). [online]. available:

https://docs.djangoproject.com/en/1.8/. Requestdate:

2015-10-04.

Franklin, G. F., Powell, J. D., and Emami-Naeini, A. (1994).

Feedback control of dynamics systems. Addison-

Wesley, Reading, MA.

Gonzalez, J. A. and Munoz, P. (2006). e-status: An au-

tomatic web-based problem generatorapplications to

statistics. Computer Applications in Engineering Ed-

ucation, 14(2):151–159.

Gregor, S. and Jones, D. (2007). The anatomy of a design

theory. Journal of the Association for Information Sys-

tems, 8(5):312–335.

Gruber, T. R. (1993). A translation approach to portable

ontology speciﬁcations. Knowledge acquisition, 5(2):

199–220.

Holohan, E., Melia, M., McMullen, D., and Pahl, C. (2006).

The generation of e-learning exercise problems from

subject ontologies. In Sixth International Conference

on Advanced Learning Technologies (ICALT), 2006,

pages 967–969, Kerkrade. IEEE.

Lopez, J., Millan, E., Perez-De-La-Cruz, J., and Triguero,

F. (1998). Ilesa: a web-based intelligent learning en-

vironment for the simplex algorithm. In Computer

Aided Learning and Instruction in Science and Engi-

neering, volume 98, pages 399–406, Gothenburg.

Melis, E., Andres, E., Budenbender, J., Frischauf, A., God-

uadze, G., Libbrecht, P., Pollet, M., and Ullrich, C.

(2001). Activemath: A generic and adaptive web-

based learning environment. International Journal

of Artiﬁcial Intelligence in Education (IJAIED), 2001,

12:385–407.

Merceron, A. and Yacef, K. (2003). A web-based tutor-

ing tool with mining facilities to improve learning and

teaching. In Eleventh International Conference on Ar-

tiﬁcial Intelligence in Education, volume 97, pages

201–208, Sydney. IOS Press.

Papazoglou, M. P. (2003). Service-oriented computing:

Concepts, characteristics and directions. In Fourth In-

ternational Conference on Web Information Systems

Engineering (WISE), 2003, pages 3–12, Rom. IEEE.

Python (2015). [online]. available: https://www.

python.org/. Requestdate: 2015-10-04.

Sadigh, D., Seshia, S. A., and Gupta, M. (2012). Au-

tomating exercise generation: A step towards meeting

the mooc challenge for embedded systems. In Pro-

ceedings of the Workshop on Embedded and Cyber-

Physical Systems Education, pages 1–8, Tampere.

ACM.

Self, J. A. (1990). Bypassing the intractable problem of

student modelling. In Intelligent tutoring systems: At

the crossroads of artiﬁcial intelligence and education,

pages 107–123. Citeseer.

Ullenboom, C. (2014). Java SE 8 Standard-Bibliothek : das

Handbuch fuer Java-Entwickler. Galileo Computing.

Galileo Press, Bonn.

Volodina, E. and Borin, L. (2012). Developing a freely

available web-based exercise generator for swedish.

In EUROCALL Conference, Gothenburg, Sweden, 22-

25 August 2012 – CALL: Using, Learning, Knowing,

Gothenburg.

Vossen, G. and Westerkamp, P. (2003). E-learning as a web

service. In Seventh International Database Engineer-

ing and Applications Symposium, 2003, pages 242–

249, Hong Kong. IEEE.

Workman, M. (2004). Performance and perceived effec-

tiveness in computer-based and computer-aided edu-

cation: do cognitive styles make a difference? Com-

puters in Human Behavior, 20(4):517–534.

Computer Aided Exercise Generation - A Framework for Human Interaction in the Automated Exercise Generation Process