A model based approach to semi-automated user interface generation for process control interactive applications (original) (raw)
Related papers
Implementing a model-based generic user interface for computer integrated manufacturing systems
Proceedings of the Institution of Mechanical Engineers, Part B: Journal of Engineering Manufacture, 1998
Computer integrated manufacturing (CIM) systems are complex in terms of performing a variety of activities, maintaining a range of information and involving various classes of users with differing levels of knowledge and skills, and different levels and time spans of decision making. Much investment and effort has been made to formalize and automate the performance of the CIM elements in a manufacturing system. However, each CIM subsystem will typically have its own terminology, procedures and presentation formats. This places a heavy and unnecessary burden on users, resulting in frustration and reduced effectiveness. Research has been carried out by the Manufacturing Systems Integration Research Institute at Lough-borough University towards the generation of a user-oriented interface for CIM systems. This research has resulted in a conceptual approach, which incorporates a generic user—task model, which enables the generation of flexible and reusable software components to form a s...
Model-based automated generation of user interfaces
1994
User interface design and development for knowledgebased systems and most other types of applications is a resource-consuming activity. Thus, many attempts have been made to automate, to certain degrees, the construction of user interfaces. Current tools for automated design of user interfaces are able to generate the static layout of an interface from the application's data model using an intelligent program that applies design rules. These tools, however, are not capable of generating the dynamic behavior of the interface, which must be specified programmatically, and which constitutes most of the effort of interface construction. Mecano is a model-based userinterface development environment that uses a domain model to generate both the static layout and the dynamic behavior of an interface.
An Interactive Framework for Design Automation
Annual Review in Automatic Programming, 1981
The paper presents a pilot study of the possibility to design an integrated interactive system for computer aided design of control computer systems, all the way from object system modelling and control system design to electronic design and software production, The study is concentrate on discussing suitable information structures and programming languages for implementation of such a system.
Automatic Generation of User Interfaces from Rigorous Domain and Use Case Models
User interface (UI) development, in the scope of data intensive interactive applications, is a time consuming but repetitive task. Nevertheless, few research projects address its automatic generation. Existing model-driven approaches to the UI automatic generation either demand the full construction of a UI model, which, with data intensive applications, corresponds to moving the repetitiveness of the UI construction to the modeling level, or demand a set of complex sub-models polluted with concrete UI information. This situation sets aside a more generalized utilization of such approaches. A few solutions found in the literature try to simplify the demanded sub-models by generating other sub-models from the previous ones, but they have revealed to be very inflexible, making it hard to work around less ``standard" problems. Based on the identification and comparison of the state-of-art tools and approaches to the automatic generation of user interfaces, this Ph.D. research work addresses the automatic generation of data driven interactive applications, including its user interface, following a model-driven paradigm. The proposed approach starts from platform independent non-UI models of the system under development, namely its domain model and its use case model, and generates a UI model, which is used, together with the domain model and use case model, to generate the completely functional final code, which may be used as a prototype or as a step for posterior refinements towards the final application. An iterative development process for data intensive interactive applications, aligned with the model-driven architecture (MDA), is also addressed, comprising model validation through a generated prototype at the end of each iteration. The presented approach shall be viewed in an evo\-lu\-tio\-na\-ry development perspective, starting with a prototype that enables the validation and execution of executable system models, in an early phase of the software development process, and being possible to use it as a base for subsequent developments, by refining the previous models or complementing them with new sub-models. OCL and an action semantics language are used to add rigor and semantic richness to the system model, and allow the generation of features derived, for instance, from the operations' body, invariants and preconditions defined in the model, that contribute to the enhancement of the UI usability and acceptability. Two case studies are presented to validate the proposed approach.
An approach to support automatic generation of user interfaces
ACM Transactions on Programming Languages and Systems, 1990
In traditional interactive programming environment, each application individually manages its interaction with the human user. The result is duplication of effort in implementing user interface code and non-uniform-hence confusing-input conventions. This paper presents an approach to support automatic generation of user interfaces in environments based on algebraic languages.
The BATIC 3 S project 5 (Building Adaptive Three-dimensional Interfaces for Controlling Complex Control Systems) proposes a methodology to prototype adaptive graphical user interfaces (GUI) for control systems. We present a domain specific language for the control systems domain, including useful and understandable abstractions for domain experts. This is coupled with a methodology for validation, verification and automatic GUI prototype generation. The methodology is centered on metamodel-based techniques and model transformations, and its foundations rely on formal models. Our approach is based on the assumption that a GUI can be induced from the characteristics of the system to control.
DESIGN OF A GRAPHICAL USER INTERFACE FOR DESIGN AUTOMATION
In research and development field, many research efforts have been made to save the overall time of product design and development of any product. As we know that design phase has a lot of potential where overall time can be saved. Hence, design automation has been the best concept came into picture which involves integration of different software like product design software developed, modeling software and analysis software. It has been observed that many researchers are taking efforts in the area of design automation like integration of different tailor made software developed using different computer programming languages like Visual Basic, Java, C++ with different CAD software like Pro/E, CREO Parametric, CATIA, SolidWorks .But it is observed that Visual Basic is having some better advantages over others like it will give dot frame work for design of product input base as well as it can be easily interface with intermediate software like Microsoft excel which provides an input to other modeling or analysis software and among all available parametric modeling software CREO is widely used in industries because it has best parameterization quality. In this paper, integration of product design software developed using Visual Basic as computer programming language and CREO Parametric as modeling software by taking the case study of design of CI Engine parts has been done to validate the concept. Simulation of CI Engine is added in developed GUI which gives results of pressure, temperature, volume at each crank angle of crankshaft in the form of graphs and maximum value of pressure and temperature got are being used for structural and thermal analysis of major components.
A language and a methodology for prototyping user interfaces for control systems
2009
Abstract. The BATIC 3 S project 1 (Building Adaptive Threedimensional Interfaces for Controlling Complex Control Systems) proposes a methodology to prototype adaptive graphical user interfaces (GUI) for control systems. We present a domain specific language for the control systems domain, including useful and understandable abstractions for domain experts. This is coupled with a methodology for validation, verification and automatic GUI prototype generation.
Automatic Generation of User Interface Models and Prototypes from Domain and Use Case Models
The model-driven automatic generation of interactive applications has been addressed by some research projects, but only few propose the model-to-model generation of a graphical user interface (UI). Existing solutions generate only part of the interactive application and most of them require as input the full specification of a UI model. This paper proposes an iterative and incremental approach that enables the modeler to generate a form-based executable prototype from the constructed models, favouring an evolutionary construction of models starting with a domain model, proceeding with an extended domain model and finally complementing it with a use case model. The approach derives a UI model from the previously referred models and allows its execution by generating an executable description of the UI in a XML-based UI description language, together with code for the specified logic and for persisting the data entities. The generated UI description may be further refined and supplemented with style definitions in order to obtain a final UI.
Springer eBooks, 2013
During design of rich internet applications (RIA) it is important to integrate in one model the description of both the interactions of the user with the system, and the processes (considering data flow, control flow, and possibly, detailed autonomous task descriptions), for having a very rich set of relations between modeling elements that can be inspected. Such integrated models consider both UI aspects, and user interaction aspects; therefore, their construction needs the participation of both graphic designers and analysts, leading possibly to communication problems, less productivity, and perhaps to introduce errors. To treat these problems, we propose a method consisting of: process requirements description, traces definition from requirement elements into either UI elements (UIE)/events on UIEs (provided by UI designers), or to autonomous actions design (provided by analysts); in addition, we present a transformation from the deliverables of this process onto an integrated model.