A Human Readable Platform Independent Domain Specific Language for BPEL
07 Jul 2010-pp 537-544
TL;DR: The domain specific language introduced in this paper uses a Java and C#-like language for describing web service interfaces that has the same descriptive power as WSDL while maintaining simplicity and readability.
Abstract: The basic building blocks of SOA systems are web services. WSDL, the standard language for defining web services, is far too complex and redundant to be efficiently handled by humans. Existing solutions use either graphical representations (UML, etc.), which are again inefficient in large scale projects, or define web services in the implementation’s native language, which is a bottom-up approach risking interface stability. Both lack support for concepts like conditions, access-rights, etc. The domain specific language introduced in this paper uses a Java and C#-like language for describing web service interfaces. It has the same descriptive power as WSDL while maintaining simplicity and readability. Examples show how to use the language, and how it can be compiled into WSDL.
Citations
More filters
01 Dec 2013
TL;DR: The present article defines the full metamodel, it specifies the corresponding programming language formally, and it shows the productivity of the framework built around the metAModel through real-life examples.
Abstract: Web services provide distributed communication in a platform independent way. The WS-* standards define how middleware aspects (security, reliability, transactions, etc.) can be realized through web services. Although the WS-Policy standard family can be used to configure the various WS-* protocols, they are very hard to construct and to maintain manually. In addition, most SOA products and Grid systems implementing these standards provide their own methods for configuring these protocols, making it very difficult to match the various configuration options of different products. This fact inspired us to propose a platform independent metamodel for describing distributed systems of web services including the most important WS-* standards. The present article defines the full metamodel, it specifies the corresponding programming language formally, and it shows the productivity of the framework built around the metamodel through real-life examples. The framework is capable of generating product specific configuration files and source codes, resulting in directly interoperable applications even between different SOA products. The framework could also promote interoperability with Grid systems built on WS-* protocols.
11 citations
Book•
19 Apr 2016
TL;DR: This thesis contributes to the development of portable service-oriented and process-aware software in two ways: it provides evidence for the existence of portability issues and the insufficiency of standards for guaranteeing software portability, and derives and validates a novel measurement framework for quantifying portability.
Abstract: Modern software systems are becoming increasingly integrated and are required to operate over organizational boundaries through networks. The development of such distributed software systems has been shaped by the orthogonal trends of service-orientation and process-awareness. These trends put an emphasis on technological neutrality, loose coupling, independence from the execution platform, and location transparency. Execution platforms supporting these trends provide context and cross-cutting functionality to applications and are referred to as engines. Applications and engines interface via language standards. The engine implements a standard. If an application is implemented in conformance to this standard, it can be executed on the engine. A primary motivation for the usage of standards is the portability of applications. Portability, the ability to move software among different execution platforms without the necessity for full or partial reengineering, protects from vendor lock-in and enables application migration to newer engines. The arrival of cloud computing has made it easy to provision new and scalable execution platforms. To enable easy platform changes, existing international standards for implementing service-oriented and process-aware software name the portability of standardized artifacts as an important goal. Moreover, they provide platform-independent serialization formats that enable the portable implementation of applications. Nevertheless, practice shows that service-oriented and process-aware applications today are limited with respect to their portability. The reason for this is that engines rarely implement a complete standard, but leave out parts or differ in the interpretation of the standard. As a consequence, even applications that claim to be portable by conforming to a standard might not be so. This thesis contributes to the development of portable service-oriented and process-aware software in two ways: Firstly, it provides evidence for the existence of portability issues and the insufficiency of standards for guaranteeing software portability. Secondly, it derives and validates a novel measurement framework for quantifying portability. We present a methodology for benchmarking the conformance of engines to a language standard and implement it in a fully automated benchmarking tool. Several test suites of conformance tests for two different languages, the Web Services Business Process Execution Language 2.0 and the Business Process Model and Notation 2.0, allow to uncover a variety of standard conformance issues in existing engines. This provides evidence that the standard-based portability of applications is a real issue. Based on these results, this thesis derives a measurement framework for portability. The framework
10 citations
Cites background or result from "A Human Readable Platform Independe..."
...Process code reduction and compilation [255] is similar to [253,254], although the authors take the opposite direction....
[...]
...[254] takes the same approach, by defining a domain specific language that should make BPEL programming easier....
[...]
01 Dec 2016
TL;DR: This paper defines several software quality metrics that quantify the degree of portability of an executable, service-oriented process from different viewpoints and shows how integrated into a development environment, such metrics can help to improve theportability of the outcome.
Abstract: A key promise of process languages based on open standards, such as the Web Services Business Process Execution Language, is the avoidance of vendor lock-in through the portability of processes among runtime environments. Despite the fact that today various runtimes claim to support this language, every runtime implements a different subset, thus hampering portability and locking in their users. It is our intention to improve this situation by enabling the measurement of the portability of executable service-oriented processes. This helps developers to assess their implementations and to decide if it is feasible to invest in the effort of porting a process to another runtime. In this paper, we define several software quality metrics that quantify the degree of portability of an executable, service-oriented process from different viewpoints. When integrated into a development environment, such metrics can help to improve the portability of the outcome. We validate the metrics theoretically with respect to measurement theory and construct validity using two validation frameworks. The validation is complemented with an empirical evaluation of the metrics using a large set of processes coming from several process libraries.
8 citations
Cites background from "A Human Readable Platform Independe..."
...[58] takes the same approach, by defining a domain specific language that should make BPEL programming easier....
[...]
...[58], but propose metrics based on empirical findings for measuring the portability of process code....
[...]
...Højsgaard andHallwyl [24] falls into the same category as [9,58], although the authors take the opposite direction....
[...]
01 Jan 2017
TL;DR: This chapter presents an approach for the measurement of process portability that builds on the recently revised version of the renowned ISO/IEC software quality model and describes how this model is in line with techniques of continuous inspection.
Abstract: Runtimes for process-aware applications, ie, process engines, constantly evolve and in the age of cloud-enabled process execution, the need to change a runtime quickly becomes even more evident To cope with this fast pace, it is desirable to build processes in a way that makes them easily portable among engines Reliance on process standards is a step in the right direction, but cannot solely solve all problems Standards are just specifications from which implementations will naturally deviate, thus fueling the problem of process portability Here, the field of software measurement can provide some remedy Metrics for process portability can help to make intelligent decisions on whether to invest in porting or rewriting process-aware applications What is more, if integrated into the development process through agile techniques like continuous inspection, portability metrics can help in the implementation of more portable processes from the very beginning In this chapter, we present an approach for the measurement of process portability and explain how this can improve decision making and process quality in general The approach builds on the recently revised version of the renowned ISO/IEC software quality model and we describe how this model is in line with techniques of continuous inspection We discuss what constitutes process portability and present a set of newly proposed software metrics for quantifying portability
6 citations
Cites background from "A Human Readable Platform Independe..."
...[80] takes the same approach, by defining a domain specific language that should make programming easier....
[...]
TL;DR: A performance model with which the response time overhead of web services with arbitrary interfaces can be predicted if the coefficients of the model are calculated from some simple measurements for the given set of test cases is proposed.
Abstract: Web services are built on XML. They use XML for describing the service interface, they use XML for message exchange and the WS- $^*$ protocols that provide addressing, security and reliable messaging also use XML. This burdens the communication with a large response time overhead compared to binary distributed communications like CORBA or RMI. Therefore, it is important to know how to design the interface of a web service so we can minimize the communication overhead. In this paper we propose a performance model with which the response time overhead of web services with arbitrary interfaces can be predicted if the coefficients of the model are calculated from some simple measurements for the given set of test cases. The paper shows the measurement results for two web service frameworks and also gives a detailed description of the performance model.
3 citations
References
More filters
01 Jan 2010
TL;DR: The plattformunabhangige Beschreibung von Schnittstellen is ein wichtiger Baustein fur eine Service-orientierte Architektur as mentioned in this paper.
Abstract: Die plattformunabhangige Beschreibung von Schnittstellen ist ein wichtiger Baustein fur eine Service-orientierte Architektur. Eine derartige Spezifikation beinhaltet alle wesentlichen Informationen, um die entfernte Dienstschnittstelle ohne weiteres Implementationswissen nutzen zu konnen. Auf diese Weise konnen Anwendungen flexibel aus Diensten unterschiedlicher Kommunikationspartner zusammengesetzt werden.
1,108 citations
17 May 2004
TL;DR: It is shown that a large class of composite web services with unbounded input queues can be completely verified using a finite state model checker such as SPIN, and a set of sufficient conditions that guarantee synchronizability and that can be checked statically are given.
Abstract: This paper presents a set of tools and techniques for analyzing interactions of composite web services which are specified in BPEL and communicate through asynchronous XML messages. We model the interactions of composite web services as conversations, the global sequence of messages exchanged by the web services. As opposed to earlier work, our tool-set handles rich data manipulation via XPath expressions. This allows us to verify designs at a more detailed level and check properties about message content. We present a framework where BPEL specifications of web services are translated to an intermediate representation, followed by the translation of the intermediate representation to a verification language. As an intermediate representation we use guarded automata augmented with unbounded queues for incoming messages, where the guards are expressed as XPath expressions. As the target verification language we use Promela, input language of the model checker SPIN. Since SPIN model checker is a finite-state verification tool we can only achieve partial verification by fixing the sizes of the input queues in the translation. We propose the concept of synchronizability to address this problem. We show that if a composite web service is synchronizable, then its conversation set remains same when asynchronous communication is replaced with synchronous communication. We give a set of sufficient conditions that guarantee synchronizability and that can be checked statically. Based on our synchronizability results, we show that a large class of composite web services with unbounded input queues can be completely verified using a finite state model checker such as SPIN.
713 citations
"A Human Readable Platform Independe..." refers background in this paper
...There are a lot of efforts [13,14] to transform BPEL processes in...
[...]
Book•
[...]
15 Jun 2002
TL;DR: This book explains XML Schema foundations, a variety of different styles for writing schemas, simple and complex types, datatypes and facets, keys, extensibility, documentation, design choices, best practices, and limitations.
Abstract: The W3C's XML Schema offers a powerful set of tools for defining acceptable XML document structures and content. While schemas are powerful, that power comes with substantial complexity. This book explains XML Schema foundations, a variety of different styles for writing schemas, simple and complex types, datatypes and facets, keys, extensibility, documentation, design choices, best practices, and limitations. Complete with references, a glossary, and examples throughout.
525 citations
05 Sep 2005
TL;DR: A Petri net semantics for the Business Process Execution Language for Web Services (BPEL) that covers the standard behaviour of BPEL as well as the exceptional behaviour (e.g. faults, events, compensation).
Abstract: We present a Petri net semantics for the Business Process Execution Language for Web Services (BPEL) Our semantics covers the standard behaviour of BPEL as well as the exceptional behaviour (eg faults, events, compensation) The semantics is implemented as a parser that translates BPEL specifications into the input language of the Petri net model checking tool LoLA We demonstrate that the semantics is well suited for computer aided verification purposes
325 citations
"A Human Readable Platform Independe..." refers background in this paper
...There are a lot of efforts [13,14] to transform BPEL processes in...
[...]
18 Sep 2006
TL;DR: This paper proposes a technique that overcomes limitations in existing methods for mapping BPMN to BPEL and addresses difficult problems that arise generally when translating between flow-based languages with parallelism.
Abstract: The Business Process Modelling Notation (BPMN) is a graph-oriented language in which control and action nodes can be connected almost arbitrarily. It is supported by various modelling tools but so far no systems can directly execute BPMN models. The Business Process Execution Language for Web Services (BPEL) on the other hand is a mainly block-structured language supported by several execution platforms. In the current setting, mapping BPMN models to BPEL code is a necessary step towards unified and standards-based business process development environments. It turns out that this mapping is challenging from a scientific viewpoint as BPMN and BPEL represent two fundamentally different classes of languages. Existing methods for mapping BPMN to BPEL impose limitations on the structure of the source model. This paper proposes a technique that overcomes these limitations. Beyond its direct relevance in the context of BPMN and BPEL, this technique addresses difficult problems that arise generally when translating between flow-based languages with parallelism.
242 citations
Additional excerpts
...Usually other languages (e.g. BPMN [8,9], UML activity diagrams [9], etc.) are used to define the business process, then this representation is converted into BPEL....
[...]
...BPMN [8,9], UML activity diagrams [9], etc....
[...]