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