23 research outputs found
Considerations of service assembly based on the analysis of data flows between services
Service composition research mostly focuses on the dynamic (workflow) aspects of compositions. In this paper we consider the static component of service composition and focus on analyzing the data flows between services within a composition. We argue that compatibility of service interfaces is a necessary precondition for service composability, and we show that data flow analysis can be applied to the problem of service composition design to identify compatible service interfaces and to minimize data coupling between services. © 2008 IEEE
Design of composable services
Service composition methods range from industry standard approaches based on Web Services and BPEL to Semantic Web approaches that rely on AI techniques to automate service discovery and composition. Service composition research mostly focuses on the dynamic (workflow) aspects of compositions. In this paper we consider the static component of service composition and discuss the importance of compatibility of service interfaces in ensuring the composability of services. Using a flight booking scenario example we show that reducing the granularity of services by decomposition into service operations with normalized interfaces produces compatible interfaces that facilitate service assembly. We then show how relational algebra can be used to represent service operations and provide a framework for service assembly. © 2009 Springer Berlin Heidelberg
Prototypical composition ontology for rule-based languages
This paper presents an ontology for the composition of rule-based ontology languages. Since typing compositions is an important issue, the ontology consists of components: two upperlevel ontologies, the metamodel of the ontology language, and a metamodel of reuse constructs that play an important role in composition. With the interplay of these components, type-safe composition of ontology components can be achieved.peer-reviewe
PEArL: a systems approach to demonstrating authenticity in information systems design
The process of information systems (IS) design has been dominated by the demands inherent in providing a technical solution to a perceived problem or need. Engineering IS design methods applied in order to satisfy the problem situation tend to have a preoccupation with verifying specifications as being mathematically correct. Diffculties arise when the ideas underpinning verification are extended in an attempt to ‘prove’ the validity of a proposed design for an IS. A pure engineering approach does not facilitate a response to the subjective elements within social situations, which experience has shown to be essential in demonstrating the pertinence of new designs to those concerned. We suggest that, by applying interpretivist systems ideas, it is possible to support concerned individuals in reflecting upon crucial aspects of the inquiry, enabling those individuals to judge the relevance or ‘authenticity’ of the learning, according to their own values and beliefs. The elements of participants, engagement, authority, relationships and learning are suggested as being crucial. These make up the mnemonic PEArL, which is offered as an aide-mémoire for those concerned with IS design
Incremental composition process for the construction of component-based management
Cyber-physical systems (CPS) are composed of software and hardware components. Many such systems (e.g., IoT based systems) are created by composing existing systems together. Some of these systems are of critical nature, e.g., emergency or disaster management systems. In general, component-based development (CBD) is a useful approach for constructing systems by composing pre-built and tested components. However, for critical systems, a development method must provide ways to verify the partial system at different stages of the construction process. In this paper, for system architectures, we propose two styles: rigid architecture and flexible architecture. A system architecture composed of independent components by coordinating exogenous connectors is in flexible architecture style category. For CBD of critical systems, we select EX-MAN from flexible architecture style category. Moreover, we define incremental composition mechanism for this model to construct critical systems from a set of system requirements. Incremental composition is defined to offer preservation of system behaviour and correctness of partial architecture at each incremental step. To evaluate our proposed approach, a case study of weather monitoring system (part of a disaster management) system was built using our EX-MAN tool
Meta-programming composers in 2nd generation component systems
Future component systems will require that components can be composed
flexibly. In contrast to current systems which only support a fixed set of
composition mechanisms, the component system should provide a composition
language in which users can define their own specific composers. It is
argued for an object-oriented setting that this will be possible by
meta-programming the class-graph.
Composers will be based on two important elements. First, they will express
coupling by graph-based operators which transform parts of the class-graph
(coupling design patterns). Second, during these transformations, elementary
meta-operators will be used to transform data and code, rearranging slots and
methods of parameter-components. Thus during their reuse, components are
queried by introspection and transformed by meta-programming.
Composers that use meta-programming generalize connectors in architectural
languages. Hence they encapsulate context-dependent aspects of a system, and
make components independent of their embedding context. Since
meta-programming composers may change behavior of components transparently,
meta-programming composers will lead to a nice form of grey-box reuse, which
supports embedding of components (and classes) into application contexts in a
new and flexible way
A model for widget composition in the OutSystems Platform
Developers use visual programming languages for faster development of user interfaces
due to better ease of use, readability, component reusability – widgets –, and an
instant preview of the desired effects. However, the most common composition models
to form user interfaces are black-box: combine existing widgets to form new widgets, but
generally do not allow indiscriminate modification of their internal components.
The OutSystems platform provides a What You See Is What You Get (WYSIWYG) experience
where developers can build user interfaces by assembling user interface elements
from predefined building blocks: the more fundamental and native components (widgets)
represent HTML elements, and custom-made building blocks (web blocks) represent
reusable compositions. However, web blocks and widgets are not uniform. Currently,
through some workarounds, creators can define compositions that, after instantiated,
their inside components can be customizable by other developers, but they either do not
follow OutSystems’ good practices for creating web applications, do not show the user’s
customizations – no preview –, or need expertise that citizen developers do not have.
Our objectives with this work are to develop a new composition model for user interface
components that allows to customize the properties of the inner elements of reusable
compositions at the places where they are instantiated, integrate the model with the platform
in a visual and interactive way where creators can control what can be modified,
and users can customize respectively while getting a consistent preview.
Reusable compositions in the OutSystems language are unique and static. Thus, for
developers to be able to change internal components of a composition and get a preview
of that change, the underlying models must explicitly receive and transmit properties of
the components internal state to the composition elements.
The work was validated by usability testing and by comparison between our solution
with widgets that are specialized by OutSystems for specific use cases. The new presented
approach is faster and more intuitive to use than what is currently offered by OutSystems.
We also observed it works best in tandem with mechanisms already in place (e.g., input
parameters) to offer more complete reusable compositions.
In the end, all objectives were met, providing a working solution which enables users
to customize their or other’s web blocks. With this work, reusable composition creators
and users will get more control, customization possibilities, and user experience more
intuitive, increasing productivity and user satisfaction.Os programadores usam linguagens de programação visual para um desenvolvimento
mais rápido das interfaces de utilizador devido à maior facilidade de uso, legibilidade,
reutilização de componentes – widgets – e uma visualização instantânea dos efeitos desejados.
No entanto, os modelos de composição mais comuns para formar interfaces de
utilizador são black-box: combinam os widgets existentes para formar novos widgets, mas
geralmente não permitem modificações indiscriminadas dos seus componentes internos.
A plataforma OutSystems fornece uma experiência What You See Is What You Get
(WYSIWYG), na qual os programadores podem criar interfaces de utilizador ao montar
elementos da interface de utilizador a partir de blocos de construção predefinidos: os
componentes mais básicos e nativos (widgets) representam elementos HTML e blocos
de construção personalizados (web blocks) representam composições reutilizáveis. No
entanto, web blocks e widgets não são uniformes. Atualmente, por meio de soluções alternativas,
os criadores podem definir composições que, após instanciadas, os componentes
internos podem ser customizados por outros programadores, mas estas não seguem as
boas práticas da OutSystems para criar aplicações Web, não mostram as customizações
do utilizador – sem preview –, ou são necessários conhecimentos que os programadores
podem não possuem.
Os nossos objetivos com este trabalho são desenvolver um novo modelo de composição
para componentes da interfaces de utilizador que permita customizar as propriedades
dos elementos internos das composições reutilizáveis nos locais em que são instanciadas,
integrar o modelo à plataforma de maneira visual e interativa, onde os criadores podem
controlar o que pode ser modificado e os utilizadores podem customizar respectivamente
enquanto obtêm uma visualização consistente.
As composições reutilizáveis na linguagem OutSystems são únicas e estáticas. Assim,
para que os programadores possam alterar os componentes internos de uma composição
e obter um preview dessa alteração, os modelos subjacentes devem receber e transmitir
explicitamente propriedades do estado interno dos componentes para os elementos da
composição.
O trabalho foi validado através de testes de usabilidade e comparação entre a nossa
solução e com widgets especializados pela OutSystems para casos de uso especÃficos. A
nova abordagem apresentada é mais rápida e mais intuitiva para usar do que o modelo
de composição que é atualmente oferecido pela OutSystems. Também observámos que
é mais eficiente usar em conjunto com os mecanismos já existentes (e.g., parâmetros de
entrada) para oferecer composições reutilizáveis mais completas.
No final, todos os objetivos foram alcançados, fornecendo uma solução funcional que
permite aos utilizadores customizar os seus web blocks ou os de outros. Com este trabalho criadores e utilizadores de composições reutilizáveis terão mais controlo, possibilidades
de customização e experiência do utilizador mais intuitiva, aumentando a produtividade
e a satisfação do programado