5 research outputs found
GUI generation based on language extensions: a model to generate GUI, based on source code with custom attributes
Due to data-driven application nature and its increasing complexity, developing its user interface can be a
repetitive and time-consuming activity. Consequently, developers tend to focus more on the user interface
aspects and less on business related code. In this paper, we’re presenting an alternative approach to graphical
user interface development for data-driven applications, that allows developers to refocus on the source code
and concentrate their efforts on application core logic. The key concept behind our approach is the generation
of concrete graphical user interface from a source code based model, which includes the original source
code metadata and non-intrusive declarative language extensions that describes the user interface structure.
Concrete user interface implementation will be delegated to specialized software packages, developed by
external entities, that provides complete graphical user interfaces services to the application. When applying
our approach, we’re expecting faster graphical user interface development
A proposal to delegate GUI implementation using a source code based model
In this paper we propose an architecture whose main
goal is to improve productivity in user interface development
for data-intensive applications. This objective is to be
achieved by defining a high level model that describes the
user interface structure. That model will be integrated in the
source code through non-functional language extensions.
Our final goal is allowing developers to define user interface
model by adding language extensions to the source
code and then acquiring an external software package to
which they delegate the implementation of the concrete user
interface
A source code based model to generate GUI: GUI generation based on source code with declarative language extensions
Due to data-driven application nature and its increasing complexity, developing its user interface can be a
repetitive and time-consuming activity. Consequently, developers tend to focus more on the user interface
aspects and less on business related code. In this paper, we present an alternative approach to graphical user
interface development for data-driven applications, where the key concept is the generation of concrete graphical
user interface from a source code based model. The model includes the original source code metadata
and non-intrusive declarative language extensions that describes the user interface structure. Some Object
Relational Mapping tools already use a similar concept to handle interoperability between the data layer and
the business layer. Our approach applies the same concept to handle business and presentation layer interoperability.
Also, concrete user interface implementation will be delegated to specialized software packages,
developed by external entities, that provide complete graphical user interfaces services to the application.
When applying our approach, we expect faster graphical user interface development, allowing developers to
refocus on the source code and concentrate their efforts on application core logic
The Future of Component-Based Development is Generation, not Retrieval
Component-Based Development (CBD) has not redeemed its promises of reuse and flexibility. Reuse is inhibited due to problems such as component retrieval, architectural mismatch, and application specificness. Component-based systems are flexible in the sense that components can be replaced and fine-tuned, but only under the assumption that the software architecture remains stable during the system's lifetime. In this paper, we argue that systems composed of components should be generated from functional and nonfunctional requirements rather than being composed out of existing or newly developed components. We propose a generation technique that is based on two pillars: Feature-Solution (FS) graphs and top-down component composition. A FS-graph captures architectural knowledge in which requirements are connected to solution fragments. This knowledge is used to compose component-based systems. The starting point is a reference architecture that addresses functionality concerns. This reference architecture is then stepwise refined to cater for non-functional requirements using the knowledge captured in a FS-graph. These refinements are the architecture-level counterpart of aspect weaving as found in Aspect-Oriented Programming (AOP)