scholarly journals User Interface Stereotypes: A Model-Based Approach for Information Systems User Interfaces

2014 ◽  
Author(s):  
Sofia Larissa Da Costa ◽  
Valdemar Vicente Graciano Neto ◽  
Juliano Lopes De Oliveira ◽  
Bruno dos Reis Calçado
Keyword(s):  
Information Systems ◽  
User Interface ◽  
Software Development ◽  
Software Architecture ◽  
User Interfaces ◽  
Model Based ◽  
Behavioral Aspects ◽  
Definition Of ◽  
High Level ◽  
And Behavior

This paper presents a model-based approach to build Information Systems User Interfaces (ISUI). In this approach, UI presentation and behavioral aspects are modeled as UI Stereotypes, which are high level abstractions of UI appearance and interaction features. A taxonomy of ISUI elements is proposed as the basis for definition of UI stereotypes. These elements are orchestrated on a software architecture which manages model-based UI building and integration with the IS applications. The proposed approach reduces software development efforts and costs, facilitating maintenance and evolution of ISUI. Moreover, UI stereotypes improve usability, consistency, reuse and standardization of both presentation and behavior of ISUI.

Model-Based Design for Multimodal Interaction in a VE

2010 ◽  
pp. 139-165
Author(s):  
Karin Coninx ◽  
Joan De Boeck ◽  
Chris Raymaekers ◽  
Lode Vanacken
Keyword(s):  
User Interface ◽  
Virtual Environment ◽  
User Interfaces ◽  
Interface Design ◽  
Multimodal Interaction ◽  
User Evaluation ◽  
Model Based ◽  
Development Cycle ◽  
High Level ◽  
Expensive Process

The creation of virtual environments is often a lengthy and expensive process. Especially defining the interaction dialog between the user and the environment is a difficult task, as the communication is often multimodal by nature. In this chapter, we elaborate on an approach which facilitates the development of this kind of user interfaces. In particular, we propose a model-based user interface design process (MBUID), in which the interface is defined by means of high level notations, rather than by writing low level programming code. The approach lifts the design to a higher level of abstraction, resulting in a shortened development cycle leaving the opportunity for creating intermediate prototypes and user evaluation, ultimately resulting in better and cheaper virtual environment interfaces.

scholarly journals Generating Collaborative Systems for Digital Libraries: a Model-Driven Approach

2010 ◽  
Vol 29 (4) ◽  
pp. 171 ◽  
Author(s):  
Alessio Malizia ◽  
Paolo Bottoni ◽  
S. Levialdi
Keyword(s):  
Digital Library ◽  
User Interfaces ◽  
Digital Libraries ◽  
Automatic Generation ◽  
Visual Language ◽  
Domain Experts ◽  
Model Driven ◽  
Neutral Models ◽  
Definition Of ◽  
High Level

The design and development of a digital library involves different stakeholders, such as: information architects, librarians, and domain experts, who need to agree on a common language to describe, discuss, and negotiate the services the library has to offer. To this end, high-level, language-neutral models have to be devised. Metamodeling techniques favor the definition of domainspecific visual languages through which stakeholders can share their views and directly manipulate representations of the domain entities. This paper describes CRADLE (Cooperative-Relational Approach to Digital Library Environments), a metamodel-based framework and visual language for the definition of notions and services related to the development of digital libraries. A collection of tools allows the automatic generation of several services, defined with the CRADLE visual language, and of the graphical user interfaces providing access to them for the final user. The effectiveness of the approach is illustrated by presenting digital libraries generated with CRADLE, while the CRADLE environment has been evaluated by using the cognitive dimensions framework.

State of the Art of Software Architecture Design Methods Used in Main Software Development Methodologies

2015 ◽  
pp. 7359-7370
Author(s):  
Reyes Delgado Paola Yuritzy ◽  
Mora Tavarez José Manuel ◽  
Duran-Limon Hector Alejandro ◽  
Rodríguez-Martínez Laura Cecilia ◽  
Mendoza González Ricardo ◽  
...  
Keyword(s):  
Software Development ◽  
Software Architecture ◽  
Design Methods ◽  
Software Systems ◽  
Design Activity ◽  
Negative Effects ◽  
Modern Development ◽  
Core Components ◽  
Software Development Methodologies ◽  
High Level

The design Software Architecture (SA) is an essential activity in the modern development software systems. This SA design activity defines its core components, the interrelationships among them, and a set of essential attributes expected for the final software. While this design is realized in a high level of abstraction, missing this activity or a wrong conduction of it will have negative effects in further software development phases, and lately in the final software. Thus, SA design methods are relevant to be studied and applied. In this article, we review the SA design methods that are (explicitly or implicitly) included in five well-known Software Development Methodologies (SDMs). We report: (1) a brief description of the five SDMs; (2) a substantial description of the SA design methods used in each SDM; and (3) a comparative analysis among them using an evaluation template posited by well-recognized experts in this topic. Our results suggest that SA design methods, while sharing a similar design purpose and some activities, they also present a varied structured and nomenclature.

Augmenting UML to Support the Design and Evolution of User Interfaces

2011 ◽  
pp. 275-285
Author(s):  
Chris Scogings ◽  
Chris Phillips
Keyword(s):  
User Interface ◽  
User Interfaces ◽  
Design And Implementation ◽  
Interface Modeling ◽  
Dialogue Structure ◽  
Primary Focus ◽  
User Tasks ◽  
High Level

The primary focus in UML has been on support for the design and implementation of the software comprising the underlying system. Very little support is provided for the design or evolution of the user interface. This chapter commences with a brief review of UML and its support for user interface modeling. Lean Cuisine+, a notation capable of modeling both dialogue structure and high-level user tasks, is described. It is shown through a case study that Lean Cuisine+ can be used to augment UML and provide the user interface support that is currently lacking.

FROM SCENARIOS TO HIERARCHICAL BROADCASTING SOFTWARE ARCHITECTURES USING UML-RT

2002 ◽  
Vol 12 (02) ◽  
pp. 155-174 ◽  
Author(s):  
INGOLF KRÜGER ◽  
WOLFGANG PRENNINGER ◽  
ROBERT SANDNER ◽  
MANFRED BROY
Keyword(s):  
Software Architecture ◽  
Early Development ◽  
Software Systems ◽  
Software Architectures ◽  
Sequence Diagrams ◽  
Communication Models ◽  
Behavioral Aspects ◽  
Key Issues ◽  
Development Phases ◽  
Definition Of

The definition of a transparent software architecture is one of the key issues in the early development phases for complex distributed and reactive software systems. In this paper, we show how to derive an architecture systematically for systems with communication models based on broadcasting. Adequate graphical description techniques for capturing interaction requirements and logical component architectures for broadcasting systems are unavailable so far. We introduce an extension to UML's sequence diagrams to capture broadcasting scenarios. Furthermore, we present methodological steps for constructively deriving structural and behavioral aspects of the architecture under consideration from the captured scenarios.

Enterprise Architecture Characteristics in Context Enterprise Governance Base On COBIT 5 Framework

2016 ◽  
Vol 3 (1) ◽  
pp. 240 ◽  
Author(s):  
Heru Nugroho ◽  
Tutut Herawan
Keyword(s):  
Information Systems ◽  
Enterprise Architecture ◽  
Model Based ◽  
Definition Of ◽  
Enterprise Governance

<em><span>The existence of the enterprise architecture is an attempt of managing and planning over the evolution of information systems in the sphere of an enterprise with model-based. In developing the enterprise architecture, there are several tools definition of components in the system. This tool is known as enterprises architecture (EA) framework. In this paper, we present a method to build a model of enterprise architecture in accordance with the needs of the Organization by Understanding the characteristics of the EA framework such as Zachman, TOGAF, and FEAF. They are selected as the EA framework will be used to determine the characteristics of an EA because the framework is most widely used in corporate or Government. In COBIT 5 framework, there is a process associated with enterprise architecture it is APO03 Manage Enterprise Architecture. At this stage of the research, we describe the link between the characteristics of the EA with one process in COBIT 5 framework. The results contribute to give a recommendation how to design EA for organization based on the characteristic of EA in Context Enterprise Governance using COBIT 5 Framework.</span></em>

Generating Interactive Prototypes from Query Annotated Discourse Models

i-com ◽  
2015 ◽  
Vol 14 (3) ◽  
Author(s):  
Filip Kis ◽  
Cristian Bogdan
Keyword(s):  
User Interface ◽  
User Interfaces ◽  
Transformation Process ◽  
Model Transformations ◽  
Interactive System ◽  
User Centered Design ◽  
Levels Of Abstraction ◽  
Domain Experts ◽  
Application Logic ◽  
High Level

AbstractModel Based User Interface Development offers the possibility to design User Interfaces without being concerned about the underlying implementation. This is achieved by devising models at a high level of abstraction, thus creating the potential for involving users or domain experts to achieve a user-centered design process. Obtaining a running interactive application from such models usually requires several model transformations. One of the current problems is that while a user interface is generated after these transformations, other parts of the interactive system such as the application logic need to pre-exist or they must be written manually before the interface can be tested in a realistic scenario. This leaves the domain experts dependent on programmers and increases the time between iterations. In this paper we work with Query Annotations, which were previously used only for modeling at low levels and for generating fully functional interfaces, and we aim to generalize them for the high-level modeling approach called Discourse Modeling. The direct expected benefit of this generalization is the possibility to generate complete, readily testable interactive prototypes, rather than just their user interfaces. In addition, Query Annotations can serve as the mapping between the various levels of abstraction and bring to the domain experts a better understanding of the transformation process, as well as the possibility to modify the interfaces and models directly.

What can you Learn from a Low-Fidelity Prototype?

1989 ◽  
Vol 33 (4) ◽  
pp. 224-228 ◽  
Author(s):  
Robert A. Virzi
Keyword(s):  
User Interface ◽  
Design Process ◽  
User Interfaces ◽  
Design Principles ◽  
Design Phase ◽  
Central Tendency ◽  
Design Decisions ◽  
Design Information ◽  
High Level ◽  
Interface Designs

A case is made for using low-fidelity prototypes early in the design phase of new services. The rationale for this is based upon (1) a model of how user interface designs progress and (2) a call to expediency. The design process is viewed as the successive application of constraints that serve to prune the space of all user interfaces. Some constraints are external (i.e., placed on the service by limits of technology or cost). Other constraints are derived by application of heuristic design principles. Even after these constraints have been applied, the design is still not fully constrained and the designer must make high-level design decisions. At these choice points, I propose that low-fidelity prototyping is an appropriate means of gathering design information as it is an expedient solution and may serve as a method of testing the central tendency of entire classes of user interfaces.

DATA-DRIVEN COORDINATION IN PEER-TO-PEER INFORMATION SYSTEMS

2004 ◽  
Vol 13 (01) ◽  
pp. 63-89 ◽  
Author(s):  
NADIA BUSI ◽  
ALBERTO MONTRESOR ◽  
GIANLUIGI ZAVATTARO
Keyword(s):  
Information Systems ◽  
Peer To Peer ◽  
Data Driven ◽  
P2p Networks ◽  
Coordination Model ◽  
Coordination Language ◽  
Model Based ◽  
Scalable Networks ◽  
P2p Applications ◽  
High Level

Peer-to-peer (P2P) has recently emerged as a promising model for supporting scalable networks composed of autonomous and spontaneously cooperating entities. The key concept in P2P is decentralization: the resources, the services, as well as the control are not in charge of specialized nodes in the network, but each node (called peer in this context) is directly involved in the management of all these aspects. Besides the advantages of decentralization (autonomy, adaptability, collaboration, and dinamicity just to mention few of them) one of the main drawbacks is the impossibility to predict the topology of the network, thus leaving at run-time any decision about the management of the interaction among the peers. For this reason, we consider useful to provide the developers of P2P applications with a high-level coordination language to be exploited to program the coordination among the peers. In this paper, we present [Formula: see text], a new data-driven coordination model suitable for P2P networks, and we describe [Formula: see text], an implementation of the [Formula: see text] coordination model based on the JXTA peer-to-peer technology.

A Specification and Detection Approach for Parallel Evolution Conflicts of Software Architectures

2017 ◽  
Vol 27 (03) ◽  
pp. 373-398 ◽  
Author(s):  
Hongzhen Xu ◽  
Wenlin Song ◽  
Zhiqiang Liu
Keyword(s):  
Software Development ◽  
Software Architecture ◽  
Software Evolution ◽  
Parallel Evolution ◽  
Critical Pair ◽  
Tool Support ◽  
Software Architectures ◽  
Detection Approach ◽  
Architecture Evolution ◽  
Definition Of

Software evolution has been a necessary part of the software development, while software architecture evolution is an important issue of software evolution. Software architecture evolution is generally realized through some evolution operations such as adding components or connectors, removing components or connectors. However, when some evolution operations are applied to the same software architecture in parallel, they sometimes make conflicting modifications, which will hinder the correctness of software architecture evolution. Although different approaches have been proposed to describe and analyze software architecture evolution, little work has been made to address evolution conflicts of software architectures. Focusing on parallel evolution conflicts of software architectures, firstly the paper establishes definitions and characterizations of parallel evolution conflicts of software architectures based on hypergraph morphisms and set theories, and describes parallel evolution conflicts of software architectures through these definitions and characterizations. Secondly the paper constructs the critical pair definition of parallel evolution conflicts of software architectures based on hypergraphs and hypergraph morphisms, analyzes the completeness of the critical pair, designs and optimizes an algorithm to detect efficiently parallel evolution conflicts of software architectures using the critical pair. Finally, a tool support is used to evaluate the effectiveness of the proposed method.

Sign in / Sign up

Export Citation Format

Share Document