ADAPTIVE USER INTERFACES FOR BUSINESS … · Some of them like OpenXava [11] and Mira framework [12] require very good programming skills for creating the description of the models

International Journal of Pure and Applied Mathematics

Volume 116 No. 4 2017, 1015-1034

ISSN: 1311-8080 (printed version); ISSN: 1314-3395 (on-line version)url: http://www.ijpam.eudoi: 10.12732/ijpam.v116i4.17

PAijpam.eu

IRIS STUDIO – IDE PROTOTYPE FOR MODELING

ADAPTIVE USER INTERFACES FOR BUSINESS

INFORMATION SYSTEMS

Margarita Atanasova1 §, Anna Malinova21,2University of Plovdiv Paisii Hilendarski

Plovdiv 4000, BULGARIA

Abstract: Business information systems available today are very complex in regard to

their functionalities and platform requirements. Adding an additional layer of context-aware-

ness makes the development of such systems very expensive, complicated and time-consuming

process. Therefore, we developed a web-based tool for modeling adaptive user interfaces

which provides a library of predefined tasks according to the functional areas in the operation

of businesses. For developing the prototype, we use a model-driven user interface development

approach. The process of creation of the UI using our environment includes four major steps –

building a task tree model, defining abstract and concrete user interface models and retrieving

the final code. All of these models have a bidirectional connection so that they are easily

updated. In the final step of the UI creation process we generate platform-independent XML

specification of the UI as well as HTML and CSS downloadable code for web and mobile

regarding to the specified models. In this code we also include the designer’s input on the

corporate identity of the developed system, including logo, colors, font-family and more. In

this paper we also examine the different situations in which our software prototype can be

used. We provide examples how designers can define tasks according to the users’ culture, level

of experience with the system, physical environment, hardware, software, level of disability,

role within the system and more.

AMS Subject Classification: 68N19, 68U35

Key Words: business information systems, adaptive user interfaces, context of use, user

interface modeling, code generation

Received: 2017-07-09

Revised: 2017-10-28

Published: November 19, 2017

c© 2017 Academic Publications, Ltd.

url: www.acadpubl.eu

§Correspondence author

1016 M. Atanasova, A. Malinova

1. Introduction

With the rapidly evolving technologies and the need of low-cost support ofmulti-device and multi-context software applications, model-driven user inter-face development becomes an important topic not only in scientific researchpapers but also in many business conferences. At the threshold of the Web4.0 era where all devices will be connected in the real and virtual world, andpersonal intelligent assistants will help us in our everyday lives, the creation ofcontext-aware user interfaces will be a mandatory step in the software develop-ment process.

There are many research topics discussing the advantages and the limitationof the model-driven user interface development [1, 2, 3]. As a whole it providesa structured approach where modality and platform independent models can bespecified and used in the real UI development. All stakeholders can take partin this process including clients, users, product managers, software architects,designers and developers. Using a proper tool supporting this process reducesthe cost of adaptive UI creation. But still this approach is not widely adoptedby the majority of software companies. One of the limitations of MBUID is thesteep learning curve. Modeling context-aware user interfaces introduces addi-tional level of complexity which is hard to understand and maintain. Anotherlimitation is the the lack of an easy way to update the existing models whenchanges on the final product are made. Going back and forth between the realprototype and the models increases the time of development which is inefficientwhen the product follows a certain go-to-market strategy.

To address the described challenges, we have developed “Iris Studio”, aweb-based integrated development environment facilitating the user interfacedevelopment. The contributions of this paper include our vision on enhancingthis process especially for building UIs for business information systems, whichusers often find difficult to use according to different studies [4, 5, 6]. Therefore,our contributions cover the aspects described below.

Firstly, we support both the design and implementation phases by pro-viding an integrated tool for maintaining bidirectional connection between allfour levels of abstraction, as suggested by the conceptual Cameleon ReferenceFramework (project by Information Society Technologies): Task and Domain,Abstract User Interface, Concrete User Interface, and Final User Interface [7].For the first step we have partially adopted the ConcurTaskTrees notation [8, 9].

Additionally, the selection of business functional areas of operation in thefirst step of UI creation process, helps us determine what predefined task modelsto propose to the developer/designer. We have built-in library for task models

IRIS STUDIO – IDE PROTOTYPE FOR MODELING... 1017

that can be reused to speed up the prototyping process. Moreover, the userscan create and save their own task tree models to extend the library.

In “Iris Studio” the designer can add multiple contexts of use to differenttasks on any of the development cycle steps. That way the designer can createand preview different combinations of elements in the user interface, simulatingreal world situations.

Finally, the underlying business logic model enables us to easily extend theIDE to generate and run code written in any modern front-end framework forweb applications. We also provide XML code generation. As an example ofspecific web technology code generation we transform the concrete model intoHTML and CSS pages, using Bootstrap.

The next sections of this paper are organized as follows: Section 2 presentsrelated work and an overview of the existing tools for model-driven UI devel-opment. In Section 3 we present our system – the underlying model, the archi-tecture and the transformations we made on the input data. We also describewhat the steps of generating final UI are. Section 4 shows different real-worldsituations where UI adaptations are needed and how our system handles them.Section 5 concludes the paper and gives an outlook on future work.

2. Related Work Overview

In this section we will make a brief overview of similar model-driven tools for UIgeneration. The strengths and the shortcomings of many early model-based UIdevelopment systems are already a focus of discussion of other scientific papers[2, 10].

The model-driven approach is used to define high-level models, which areused for the creation of a detailed specification and client’s requirements anal-yses from a semantic point of view without a focus on the implementation.There are different tools supporting this process. Each one of them proposesdifferent solutions to their users and puts an emphasis on different artifacts ofthe MBUID.

Some of them like OpenXava [11] and Mira framework [12] require verygood programming skills for creating the description of the models. Theirtarget group of users are rather programmers than designers. The final code isHTML and CSS code. Mira uses Bootstrap so that the result is responsive aswell as modern.

CTTE [13] and Responsive CTT [14] support partially the process of model-driven development by providing tools for task tree modeling using the Con-


curTaskTrees notation. They produce an XML specification.

SketchiXML [15] supports the creation of concrete UI models using a tabletand a stylus. The final specification can be obtained as a usiXML code. Thereare also several other similar applications that support sketching a user interfacewith a tablet and resulting in code generation: SILK [16], JavaSketchIt [17],Freeform [18].

The users in IdealXML [19] can create task models and abstract UIs. Theend result here is also a user interface specification in usiXML.

Supple [20] is another interesting project aiming at the creation of JavaScriptlibrary, which analyses the skill levels of the users and alters the system accord-ing to the results. It mainly gathers input to adapt the system for people withmotor and vision impairments. The authors in the Supple project have devel-oped ARNAULD, a system which changes its graphic interface according to theuser’s behavior [21].

CanonSketch [22] is another tool for defining abstract user interface mod-els. This tool uses Wisdom notation, which is proposed as a UML extension.An additional view is also implemented, which generates a possible specificimplementation of the user interface in the form of HTML.

GrafiXML [23] focuses on the generation of multi-platform context-sensitiveuser interfaces. It is based on usiXML. The final code can be generated in(X)HMLT or Java. One of the outlined perspectives in the paper is to makethe UI adaptations during the runtime while now they are in the design time.

Another system that puts its emphasis on the context-aware user interfacegeneration is MASP [24]. It uses model-driven approach, maintaining all levelsin the Cameleon Reference Framework to support the creation of UIs for smarthomes. The adaptations happen in the runtime. The final code generationsupports XML, WML, HTML, VoiceXML.

Gummy [25] is a visual editor for developing multi-platform user interfacesfacilitating the design process. It is aimed to be user-friendly for designers,hiding details of the abstract model, but providing functionality of editing theconcrete UI model. At the end Gummy “translates” the concrete elements intoUIML (User Interface Markup Language) and XML.

Damask [26] is a tool for creating user interface prototypes for different de-vices implementing partially the model-driven approach. It supports VoiceXMLcommands. Damask does not aim to create final UI or to add any layer ofcontext-awareness, but focuses on the multi-platform UI modeling.

CIAT-GUI [27] and Cedar Studio [28] also adopt the Cameleon ReferenceFramework supporting the four levels of abstraction. The generated final UI inCIAT-GUI is in XAML, while CedarStudio generates XML specification with


added attributes to the elements for different contexts of use.

Approaches like GrafiXML, Masp, Supple, Cedar Studio and MIRA presenttools and techniques for supporting the development of adaptive UIs. Thedesigner input in these approaches is very small to none. The final generateduser interface in nearly all of the reviewed systems is not ready to be useddirectly in a real project without any changes. It lacks a way to make visualchanges to the elements or apply corporate identity. Also these tools requireadditional knowledge and are hard to understand from a beginner. Our aimis to propose a solution to these problems by creating an environment, whichsupports the designer/developer of adaptive UIs through the whole cycle in theUI development. The environment has to be self-explanatory and produce finaluser interface according to modern business requirements. We maintain all stepsfrom the clients’ requirements analysis to the downloadable code, which can bedirectly implemented into the product. That is why except the XML generationwe implemented one of the most popular front-end libraries Bootstrap. In thenext section we also explain how we can add new technologies for the final codegeneration.

3. Iris Studio Architecture

We have developed “Iris Studio”, an IDE prototype for building adaptive userinterfaces, by extending the Cameleon Reference Framework’s four levels of UIdevelopment cycle. The aim is to support and accelerate the creation of user in-terfaces for business information systems, thereby we propose a modification tothe CRF on the implementation level by adding an additional step for definingbusiness functional areas of operations. That way “Iris Studio” extracts prede-fined task models depending on the selected industry, therefore speeding up thetask analysis step and respectively the development process. The functionalareas of operations and the task modeling in our IDE prototype as well as thetransformations made between the task model and the abstract user interfacemodel are described in another paper [29].

The workflow of creating user interface in Iris Studio is as follows: First, theuser creates a project and selects functional areas of operations. Than modelsthe user tasks (See Fig. 1), generates abstract UI model (Fig. 2), concrete UImodel (Fig. 3) and final UI (Fig. 4). On the last step the user applies corporateidentity – logo, colors, fonts, repositions the elements if needed and downloadsthe final code.

There is no standard notation for defining concrete UI model. Depending


Figure 1: Iris IDE – first step of the UI modeling process – task modeling

Figure 2: Iris IDE – second step of the UI modeling process – generatingAbstract UI model

on the abstract interactive object type (input, output, control or navigation)and node type (parent or leaf), the tasks can be transformed into different


Figure 3: Iris IDE – third step of the UI modeling process – generatingConcrete UI model

concrete objects. This choice is made by the user as this cannot be automat-ically selected. For example, if we have abstract interactive object from type“output” in the concrete UI model generation in Iris Studio the user can selectfrom multiple types of output concrete objects like: table, pie chart, bar chart,line chart, paragraph, list, etc. We always transform the root element from theabstract UI model into a Window concrete element in the concrete UI model.From the user input we generate the concrete objects and present them in thescreen in a structured way similar to a rapid prototyping tool. We providethe users a toolbox on the top from which they can add different concrete ob-jects in the model. They can also put them in a grid, defined by rows andcolumns. With the implemented bidirectional connections between the models,every added object in the concrete model automatically updates and is addedto the abstract model and the task trees. For example, if the user adds a textarea in the concrete model, it appears in the abstract model as an input facetand as an interaction task type in the task model.

The final user interface (Fig. 4) is automatically generated and loaded into


Figure 4: Iris IDE – fourth step of the UI modeling process – generatingFinal UI

an iframe in the client’s browser. We use a master template as a container ofthe tasks. This template contains header, top navigation with placeholder forlogo, search bar, left navigation, main container and footer. The modeled tasksare placed in the main container section. The designer/developer can hide andshow different contexts, thereby seeing different combinations of UI elementson the screen. Data attributes are added to those elements in the final code sothat they can be managed accordingly by the back-end logic in the real project.This is also the step where the designer can upload logo, add Google fonts,change the font color and background colors to the design. In “Iris Studio” oneproject can have multiple user interface files. That is why all corporate identityparameters are stored in the project’s database and are applied to all files inthe same project so that the designer does not need to apply them every time.We use Google Charts as a charting library for the diagrams representation inthe final UI.


All user interface files in a single project can be downloaded as a .zip archive,containing HTML, CSS and JavaScript files with linked Bootstrap library fromits’ CDN. The final user interface can also be downloaded as an XML file. Weprovide a detailed explanation in the studio’s help section how this file can betransformed into executable code.

The business logic behind abovementioned steps is shown in Fig. 5. Wemaintain different users with multiple projects each. Each project can havemany user interface files. The UI file Class is responsible for model transfor-mations, data validation and code generation. Every UI file can be added toa personal library of predefined tasks and reused in different projects. The UInodes store all attributes of the task tree model, abstract and concrete mod-els. They are connected to the contexts of use. Each node can have none,one or more contexts to which it belongs. The UI nodes are linked betweeneach other so that the workflow between the tasks can be specified during therequirements analysis phase. The corporate identity is linked to the project sothat all files in a single project have the same logo, font style and colors. Everyproject has a functional area so that the user has access to predefined selectionof ready-to-use task models. The Technology Parser Class is responsible for thecode generation. It transforms the concrete objects into code depending on thetechnology. Currently we have implemented parsers for XML and web (HTML,CSS).

4. User Tasks Modeling for Different Contexts of Use in Iris Studio

In this section we present various examples of task models from the perspectiveof different contexts of use that are created using “Iris Studio”. Moreover, thishelps designers focus on the user tasks rather than the implementation.

Task modeling helps user experience designers understand what people wantand how to design the business requirements into a usable, friendly product.Task analysis is an effective process where UX designers decompose complextasks into simpler ones. In this process stakeholders and clients might also beinvolved as no coding is required for the tasks’ description.

Designing such task structures is not always easy, especially when differentuser profiles and contexts of use should be defined at the same time. Thedeveloped software system enables its users to define each of the tasks to whichcontext of use is applied. One task might be applicable to several contextsor to none. The behavior of the final user interface depends on the specificparameters sent from the back-end during the run-time.


Figure 5: Class diagram of the business logic tier of “Iris Studio”

In the following sections we will try to give as many as possible live examplesfor a variety of situations where UI adaptations are needed.


Figure 6: Task model of user task “Search”. Context of use named“South Korea” for users located in this country is applied

4.1. Cultural Adaptivity

Systems with culturally adaptive user interface can adapt according to thecultural characteristics of their users [30]. Applications that take into accountthe location and the country of their users are considered to be much moreefficient and convenient. A simple example is the user interface of Google.While the clean design of the search engine is preferred in Europe, the leadingsearch engine in Russia is Yandex, in China is Baidu and in South Korea is thecolourful Naver [31]. Naver offers to its users many images, advertisements anddifferent search categories – common technique for websites in South Korea.

An example diagram with described user tasks and their contexts of use,representing a similar case, is presented below (See Fig. 6). Using our proto-type, designers can describe user tasks using ConcurTaskTrees notation whichmeans that we have four main types of tasks (Abstraction, Interaction, Systemand User) and different kind of operators between them. In addition to this weimplemented a mechanism for adding contexts to the nodes in the tree. Everynode can be part of different contexts. The result is a combination of varietyof contexts. Contexts might be switched on and off so that the designer mightpreview the different combinations in the next steps of the UI modeling processwhich are the Abstract User Interface and the Concrete User Interface. In Fig.6 we are showing how easy it is to determine that these particular tasks (Bannerand News) are related only to the context of use named “South Korea”.


Figure 7: Model of Dashboard for business information system showingthree contexts of use according to different user roles within the system– Executive Director, Human Resources Manager and Administrator.

4.2. User Roles

Most of the web sites and business information systems have different userroles and permissions. Carefully planning the visibility of different parts of theapplication in early stage of user experience design is essential as the systemgrows. Different aspects of this issue are shown in [40, 41] concerning theDistributed Platform for E-learning (DisPeL). In Fig. 7, by using our softwareprototype, we’ve managed to describe a dashboard task model with differentUI components, visible for different user groups. The executive director cansee all reports, while the HR specialist can see only the hiring and headcountreport. The administrator can view Settings and Users links. If the user of thesystem does not apply to any of these contexts, they can only see the News andSearch.

All the other roles can see these two tasks (News and Search) as well astheir own. The final user interface is once again generated run-time accordingto the parameters that the back-end sends to the front-end. In this example,we might have 14 different combinations of user interfaces for the dashboarddepending on what user roles are assigned to the person. This will help the UXdesigner easily test their prototype with representatives of their personas1.

1“Persona” is a descriptive model of a certain type of user based on data from a customersurvey [32]


Figure 8: Simple Production task with two contexts of use dependingon the environment – in or outside the factory

4.3. Environment

Nowadays information technologies have the resources and the capability to cre-ate Rich Internet Applications, to personalize the experience, to analyze realtime data while gathering information from different sources (website, sensorsin the mobile devices and many other). That way designers have unlimited pos-sibilities to prototype adaptive user interfaces in order to improve the usabilityof the system.

One of the first examples of worldwide popular adaptive systems is the GPSnavigation. Using the location of the user, the system draws the shortest routeto the end point. When the sun goes down or the car enters a tunnel, the systeminterface directly switches to night mode in order not to dazzle the driver. Thisis a good example of a user interface that adapts to environmental changes (oneof the four components of the context of use).

Other change of the environment might be the different Internet connectionspeed. A context for low Internet speed might be defined where the imagesmight use lazy-loading mechanism or to not load at all so that the whole websiteloads faster.

For business information systems there could also be different changes ac-cording to the environment. For example, systems, which are responsible forthe manufacturing and production process, can offer different UI functionalitiesdepending on the user’s location – in the factory or outside the factory. Infor-mation about the user’s location is typically gathered from global navigationsatellite systems. In Fig. 8 we describe a simple task for a production processin a web based industrial application.


Figure 9: Task “Add new networking device for monitoring”. Contextof use “Beginner” is added for the Start-up wizard, including tutorials,videos and help

4.4. Level of Experience

No matter what the target group of an application is there are always threetypes of users: beginners, intermediates or experts. Usually UX designers man-age to combine different UI elements so that the user interface is friendly formost of the users [42]. A good design approach is adding tasks for beginnerswhen the user logs into the system for the first time. A quick guide, video tuto-rial or different notification messages might lead the users through the systemso that they learn quickly the functionality without making unnecessary errors.

Completing a new task for the first time is difficult for the average user ofbusiness information systems. Most of the business applications do not evensupport adaptive user interface for users with different skills such as beginnersor experts [33]. On Fig.9 we describe a simple task model for monitoring anetworking device. When a user tries to add a new device in the monitoringsoftware a choice for how-to tutorial or video appears. Here the UX designermight add additional “Do not show this tutorial again” checkbox or there mightbe different parameters indicating that the user is no longer in the beginnersgroup. The other two subtasks below the “Add new device for monitoring”are for entering new device and monitoring meta data information. They arevisible for the default context – for all users that are not beginners.

4.5. Hardware and Software

Mobile and user devices faced significant changes during the last two decades.They differ not only by screen size and resolution, but also by RAM mem-ory, battery time, Internet connection capabilities, operating system and many


Figure 10: “Track a Training” user task. Added a context of use “SmartWatch” which includes only parts of the functionality that can be sup-ported by the device

more. Designing a software for many different devices requires good planningin order to deliver the specific functionality which can be supported by thesedevices. Usually the focus is one or several device groups that have similarhardware parameters [34].

Using our software tool for prototyping adaptive user interfaces we proposea sample model for task “Track a Training”. The device target of the app aredevices, that might track the distance and the duration of the training. Thisincludes smartphones and smart watches. The default user interface for mobilephones includes all the functionality, as shown in Fig. 10: track the time and thedistance, enter pulse, show tracking chart, take a photo, show burnt calories,play music during the training and manage a training with start, pause andstop buttons. We added context of use for smart watches which includes onlythe functionality that can be supported by that particular device – track thetime and the distance, enter pulse, show burnt calories and manage a training.

4.6. People with Disabilities

Adaptive user interfaces for people with disabilities are a common research topicof many projects as the percentage of this group of people is quite high – 15%of the world population lives with some form of disability [35]. The users mightdiffer in traits such as tactile perception, memory, vision, hearing, ability tonavigate in unfamiliar environments and others. The contexts of use for peoplewith disabilities should be very carefully examined by the UX designers beforeany prototyping. Also, whenever possible, accessibility specialist(s) should beincluded in the design process. There are different guidelines for the differentdisabilities that should be followed in order to create a user-friendly software


Figure 11: “Read a Tale” task with added context of use for peoplewith ASD

system. For example, the UK Department of Health proposed a methodologyfor creation of documents for people with learning disabilities [36].

People with Autism Spectrum Disorders have very different personal pref-erences and needs. That is why personalization for such users is a key elementfor the success of the project [37]. In Fig. 11 we describe a “Read a Tale” taskwith added context for people with ASD. Depending on the design guidelinesfor such people [38, 39], the text for them should be simplified and should con-sist of more images. Also a nice to have feature is the system to be able to readthe text to the users with ASD.

5. Conclusion and Future Work

The creation of adaptive user interfaces for different contexts of use benefits alot from the model-driven development, especially when the designers have aproper tool facilitating the process. It this paper we describe “Iris Studio” theauthors’ software prototype that supports the adaptive user interface modelingprocess. We also describe different situations that require adaptations accordingto contexts of use. There are many possibilities for defining adaptive behavior:hardware and software, social and physical environment, user skills level, users’culture, disabilities, roles and other. In this paper we make an overview of othersystems facilitating the model-driven user interface design process. As a futurework we are going to implement a functionality of generating multiple pages


from a single task model. We also intend adding more master page templatesfor the final UI. In addition, an evaluation study with real users has to beconducted so that we analyze the usability of “Iris Studio” and the overalldevelopment time of a final user interface.

6. Acknowledgement

The work described in this paper has been partially supported by the projectFP17-FMI-008 of the Scientific Fund of the University of Plovdiv “Paisii Hilen-darski”, Bulgaria.

References

[1] J. Van den Bergh, G. Meixner, K. Breiner, A. Pleuss, S. Sauer, H. Hussmann, ModelDriven Development of Advanced User Interfaces, Conference on Human Factors in Com-puting Systems – Proceedings, (2010), 4429-4432, doi:10.1145/1753846.1754166.

[2] A. Akiki, A. Bandara, Y. Yu, Adaptive Model-Driven User Interface Development Sys-tems, ACM Computing Surveys, ACM, 47(1), (2014), 64:164:33.

[3] E. Yigitbas, H. Stahl, S. Sauer, G. Engels, Self-adaptive UIs: Integrated Model-DrivenDevelopment of UIs and Their Adaptations, (2017), 126-141, doi:10.1007/978-3-319-61482-3 8.

[4] H. Topi, W. Lucas, T. Babaian, Identifying Usability Issues with an ERP Implementation,In Proceedings of the 7th International Conference on Enterprise Information Systems,Miami, USA: SciTePress, (2005), 128133.

[5] B. Lykkegaard, A. Elbak, IDC – Document at a Glance – LC52T, International DataCorporation (IDC), (2011).

[6] A. Singh, J. Wesson, Evaluation Criteria for Assessing the Usability of ERP Systems,In Proceedings of the 2009 Annual Research Conference of the South African Instituteof Computer Scientists and Information Technologists, Emfuleni, South Africa: ACM,(2009), 8795.

[7] G. Calvary, J. Coutaz, D. Thevenin, Q. Limbourg, L. Bouillon, J. Vanderdonckt, Aunifying reference framework for multi-target user interfaces, Interacting with computers15 (3), (2003), 289-308.

[8] W3C, Concur Task Trees (CTT) W3C Working Group Submission.https://www.w3.org/: https://www.w3.org/2012/02/ctt/ (2012), last accessed2017/05/27.

[9] F. Paterno, ConcurTaskTrees: An Engineered Notation for Task Models. D. Diaper; N.A. Stanton, The Handbook of Task Analysis for Human-Computer Interaction (483-503).Mahwah, New Jersey: Lawrence Erlbaum Associates, Inc. (2003).

[10] G. Meixner, F. Paterno, J. Vanderdonckt, Past, Present, and Future of Model-BasedUser Interface Development, i-com, 10(3), (2011), 211.


[11] OpenXava Framework for Rapid Development of Enterprise Web Applications.http://www.openxava.org/

[12] E. Bertti, D. Schwabe, MIRA: A Model-Driven Framework for Semantic Interfaces forWeb Applications, In book: Web Engineering, (2016), 40-58, doi:10.1007/978-3-319-38791-8 3.

[13] F. Paterno, G. Mori, R. Galiberti, CTTE: An Environment for Analysis and Developmentof Task Models of Cooperative Applications. In: CHI 2001 Extended Abstracts on HumanFactors in Computer Systems, ACM, ACM Press, New York, (2001), 21-22.

[14] D. Anzalone, M. Manca, F. Paterno, C. Santoro, Responsive Task Modelling, In proceed-ings of the 7th ACM SIGCHI Symposium on Engineering Interactive Computing Systems,ACM, New York, (2015), 126-131, doi:10.1145/2774225.2775079.

[15] A. Coyette, J. Vanderdonckt, Q. Limbourg, SketchiXML: A Design Tool for InformalUser Interface Rapid Prototyping. In: Guelfi N., Buchs D. (eds) Rapid Integration ofSoftware Engineering Techniques. RISE 2006, Springer, Berlin, Heidelberg, Lecture Notesin Computer Science, vol. 4401, (2007), 160-176.

[16] J. Landay, B. Myers, Sketching Interfaces: Toward More Human Interface Design, IEEEComputer 34 (3), (2001), 5664.

[17] A. Caetano, N. Goulart, M. Fonseca, J. Jorge, JavaSketchIt: Issues in Sketching the Lookof User Interfaces, In: Proc. of the 2002 AAAI Spring Symposium – Sketch Understand-ing, Palo Alto, March 2002, AAAI Press, Menlo Park (2002), 914.

[18] B. Plimmer, M. Apperley, Software for Students to Sketch Interface Designs, In: Proc. of9th IFIP TC 13 Int. Conf. on Human-Computer Interaction INTERACT’2003, Zurich,1-5 September, 2003, IOS Press, Amsterdam (2003), 7380.

[19] F. Montero, Vıctor Lopez Jaquero, IDEALXML: An Interaction Design Tool and a Task-based Approach to User Interface Design, In: Proc. of the 6th International Conferenceon Computer-Aided Design of User Interfaces, CADUI’2006, Bucharest, Romania, June5-8, 2006, Kluwer Academic Publishers, Boston (2006), 245-252.

[20] SUPPLE: Automatically Generating Personalized User Interfaceshttp://iis.seas.harvard.edu/projects/supple/

[21] K. Gajos, D. Weld, Preference elicitation for interface optimization, In proceedings of the18th annual ACM symposium on User interface software and technology (2005), 173-182,doi:10.1145/1095034.1095063.

[22] P. Campos, N. Nunes, Canonsketch: a User-Centered Tool for Canonical Abstract Pro-totyping, In Proceedings of DSV-IS’2004, 11th International Workshop on Design, Spec-ification and Verification of Interactive Systems, Springer, Berlin (2004), 146-163.

[23] B. Michotte, J. Vanderdonckt, GrafiXML, A Multi-Target User Interface Builder basedon UsiXML, Book title: ICAS, Publisher: IEEE Computer Society Press, Los Alamitos,Journal: Proc. of 4th International Conference on Autonomic and Autonomous SystemsICAS’2008, (2008), 15-22, ISBN: 978-0-7695-3093-2.

[24] S. Feuerstack, M. Blumendorf, V. Schwartze, S. Albayrak, Model-based layout genera-tion, In Proceedings of the working conference on Advanced visual interfaces, May 28-30,Napoli, Italy (2008), doi:10.1145/1385569.1385605.


[25] J. Meskens, J. Vermeulen, K. Luyten, K. Coninx, Gummy for multi-platform userinterface designs: shape me, multiply me, fix me, use me, In Proceedings of theworking conference on Advanced visual interfaces, May 28-30, Napoli, Italy (2008),doi:10.1145/1385569.1385607.

[26] J. Lin, J. Landay, Employing Patterns and Layers for Early-Stage Design and Proto-typing of Cross-Device User Interfaces, In Proceedings of the ACM SIGCHI Confer-ence on Human Factors in Computing Systems, ACM, Florence, Italy, (2008), 13131322,doi:10.1145/1357054.1357260.

[27] A. Molina, W. Giraldo, J. Gallardo, M. Redondo, M. Ortega, G. Garcıa, CIAT-GUI:A MDE-compliant environment for developing Graphical User Interfaces of informationsystems, Advances in Engineering Software, 52, (2012), 10-29.

[28] P. Akiki, A. Bandara, Y. Yu, Cedar studio: an IDE supporting adaptive model-drivenuser interfaces for enterprise applications, In Proceedings of the 5th ACM SIGCHI sym-posium on Engineering interactive computing systems, London, United Kingdom (2013)doi:10.1145/2494603.2480332

[29] M. Atanasova, A. Malinova, Transforming Concur Task Trees Model Into an AbstractUser Interface, In CBU International Conference Proceedings, Natural Sciences and ICT,vol. 5, (2017).

[30] K. Reinecke, S. Schenkel, A. Bernstein, Modeling a User’s Culture, In: The Handbookof Research in Culturally-Aware Information Technology: Perspectives and Models, IGIGlobal, (2010).

[31] Search Engine Market Share by Country: 2015 Update, Austin Return On Now Inter-net Marketing LLC, http://returnonnow.com/internet-marketing-resources/2015-search-engine-market-share-by-country/, last accessed 2017/05/20

[32] R. Marshall, Sh. Cook, V. Mitchell, S. Summerskill, V. Haines, M. Maguine, R. Sims, D.Gyi, K. Case, Design and evaluation: End users, user datasets and personas, In AppliedErgonomics, vol. 46, Part B, Special Issue: Inclusive Design, (2015), 311-317.

[33] A. Singh, J. Wesson, Evaluation Criteria for Assessing the Usability of ERP Systems,In Proceedings of the 2009 Annual Research Conference of the South African Instituteof Computer Scientists and Information Technologists, Emfuleni, South Africa: ACM,(2009), 8795.

[34] M. Behan, O. Krejcar, Adaptive Graphical User Interface Solution for Modern UserDevices, In: Pan JS., Chen SM., Nguyen N.T. (eds) Intelligent Information and DatabaseSystems. ACIIDS 2012. Lecture Notes in Computer Science, vol. 7197, Springer, Berlin,Heidelberg, (2012).

[35] The World Bank Disability Overview Page, http://www.worldbank.org/en/topic/disabi-lity/overview, last accessed 2017/29/05.

[36] Department of Health (UK), “Basic Guidelines for People Who Commission Easy ReadInformation”, Department of Health, UK, (2009).

[37] P. Stern, L. Shalev, The Role of Sustained Attention and Display Medium in ReadingComprehension among Adolescents with ADHD and without It, Research in DevelopmentDisabilities, Vol. 34, No. 1, (2013), 431-439.

[38] N. Pavlov, User Interface for People with Autism Spectrum Disorders, Journal of Soft-ware Engineering and Applications (JSEA), Vol. 7, No. 2, 2014, (2014), 128-134.


[39] N. Pavlov, A. Rahnev, K. Mirchev, T. Gardjeva, D. Krushkova, Responsive User Interfacefor People with ASD, International Journal of Pure and Applied Mathematics – IJPAM,Vol. 111, No. 1, (2016), 105-119.

[40] A. Rahnev, N. Pavlov, V. Kyurkchiev, Distributed Platform for e-Learning – DisPeL,European International Journal of Science and Technology (EIJST), Vol. 3, No. 1, 2014,(2014), 95-109.

[41] V. Arnaudova, T. Terzieva, A. Rahnev, A methodological approach for implementationof adaptive e-learning, CBU International Conference on Innovations in Science andEducation, March 23-25, 2016, Prague, Czech Republic, Vol. 4 (2016): CBU InternationalConference Proceedings 2016, (2016), 480-487.

[42] S. Stavrev, T. Terzieva, Virtual environment simulator for educational safety crossing,Proceedings of the 11th Annual International Conference on Computer Science and Ed-ucation in Computer Science (CSECS 2015), June 4th to June 7th, 2015, Boston, MA,USA, (2015), 92-98.

Documents

ADAPTIVE USER INTERFACES FOR BUSINESS … · Some of them like OpenXava [11] and Mira framework [12] require very good programming skills for creating the description of the models