An Embedded Domain Specific Language to Model, Transform and Quality Assure Business Processes in Business-Driven Development

Business process models are produced by business analysts to graphically communicate the business requirements to IT specialists. As business processes are updated to meet the new demands in the competitive market, the underlying IT solution is adapted, to reflect precisely the current goals of the organisation. The models should then act as an abstract representation of the solution. It is essential to adapt to Business-Driven Development (BDD), whereby models are refined into the IT solution and implemented in a Service-Oriented Architecture. This means that models must be free from data and control-flow errors, such as deadlocks. If models are not quality assured at the modelling phase, errors would be discovered later and the entire BDD lifecycle would have to be repeated. Combining model transformations with quality assurance would help modellers to preserve the correctness of models and rapidly carry out modifications. Although various modelling languages have been developed to assist modellers in the production of high quality business process models, none of them adopted a functional approach, based on higher-order logic. As BDD is being adopted by most organisations, the need for such a language is becoming more evident. Since specialized functionality is required, a general-purpose language is not really necessary. Instead, a domain-specific language which provides the right abstraction and captures precisely the semantics of the business process modelling domain, should be developed. The definitions of the models would be easy to comprehend and reason about, by anyone who is not necessarily an IT specialist. However, since languages are made up of domain independent and dependent linguistic components, it is more cost effective and feasible to embed the new language in a general-purpose language. In this project we present a domain specific language embedded in the functional language, Haskell, to model, transform and quality assure business processes in Business-Driven Development. By adopting a functional approach, we developed a language: 1) with which various models can rapidly be produced in a concise and abstract manner, 2) allows users to focus on the required behaviour rather than its implementation, 3) ensures that all the required details, to generate the executable code, are specified, 4) the abstract representation can be interpreted, analysed and transformed in various ways, 5) quality assures models by carrying out three types of checks; by Haskell’s type checker, at construction-time through our embedded type system, and by specialised functions that analyse the components in the model. By embedding our language in Haskell, the models, quality assurance checks and transformations are essentially functions which can easily be composed and defined. Connection patterns, defined in the language, play an important role to ensure that definitions are concise, readable and easy to comprehend. Different from other previous modelling tools, users are able to define their own parameterized models and transformations. By generating a directed graph for the models, various types of analysis can be carried out with greater ease. Moreover, quality assurance can be combined to model transformations by declaratively defining pre and post conditions for each transformation. These conditions as well as transformations can easily be composed of other previously defined checks or transformations. With this language, we aim to capture the domain semantics of IBM’s WebSphere Business Modeler Advanced v6.0.2.

[1]  Holger Giese,et al.  Incremental model synchronization with triple graph grammars , 2006, MoDELS'06.

[2]  John T. O'Donnell,et al.  Generating Netlists from Executable Circuit Specifications , 1992, Functional Programming.

[3]  Brian Beckman,et al.  LINQ: reconciling object, relations and XML in the .NET framework , 2006, SIGMOD Conference.

[4]  Jana Koehler,et al.  Using Patterns in the Design of Inter-organizational Systems - An Experience Report , 2004, OTM Workshops.

[5]  Philip Wadler,et al.  How to make ad-hoc polymorphism less ad hoc , 1989, POPL '89.

[6]  Philip Wadler,et al.  Comprehending monads , 1990, Mathematical Structures in Computer Science.

[7]  John W. Backus,et al.  Can programming be liberated from the von Neumann style?: a functional style and its algebra of programs , 1978, CACM.

[8]  Paul Hudak Haskore Music Tutorial , 1996, Advanced Functional Programming.

[9]  Paul Hudak,et al.  Monad transformers and modular interpreters , 1995, POPL '95.

[10]  Cesare Pautasso,et al.  Combining Quality Assurance and Model Transformations in Business-Driven Development , 2008, AGTIVE.

[11]  Eugenio Moggi,et al.  Computational lambda-calculus and monads , 1989, [1989] Proceedings. Fourth Annual Symposium on Logic in Computer Science.

[12]  Koen Claessen Embedded Languages for Describing and Verifying Hardware , 2001 .

[13]  David C. J. Matthews Static and Dynamic Type Checking , 1987, DBPL.

[14]  Peyton Jones,et al.  Haskell 98 language and libraries : the revised report , 2003 .

[15]  Valdis Berzins,et al.  The Realizable Benefits of a Language Prototyping Language , 1988, IEEE Trans. Software Eng..

[16]  Simon L. Peyton Jones,et al.  A history of Haskell: being lazy with class , 2007, HOPL.

[17]  Paul Hudak,et al.  A gentle introduction to Haskell , 1992, SIGP.

[18]  Dániel Varró,et al.  Termination Analysis of Model Transformations by Petri Nets , 2006, ICGT.

[19]  Frank Leymann,et al.  Faster and More Focused Control-Flow Analysis for Business Process Models Through SESE Decomposition , 2007, ICSOC.

[20]  Gordon J. Pace HeDLa : a strongly typed, component-based embedded hardware description language , 2007 .

[21]  John Hughes,et al.  Why Functional Programming Matters , 1989, Comput. J..

[22]  P. J. Landin,et al.  The next 700 programming languages , 1966, CACM.

[23]  Jon Louis Bentley,et al.  Programming pearls: little languages , 1986, CACM.

[24]  Paul Hudak,et al.  Conception, evolution, and application of functional programming languages , 1989, CSUR.

[25]  Mary Sheeran,et al.  muFP, a language for VLSI design , 1984, LFP '84.

[26]  Wil M. P. van der Aalst,et al.  Workflow Verification: Finding Control-Flow Errors Using Petri-Net-Based Techniques , 2000, Business Process Management.

[27]  Lowell Jay Arthur Unix Shell Programming , 1997 .

[28]  van der Wmp Wil Aalst,et al.  Workflow data patterns , 2004 .

[29]  Jochen Malte Küster,et al.  Validation of model transformations: first experiences using a white box approach , 2006, MoDELS'06.

[30]  Pascal Raymond,et al.  The synchronous data flow programming language LUSTRE , 1991, Proc. IEEE.

[31]  Paul Hudak,et al.  Functional reactive animation , 1997, ICFP '97.

[32]  James Cheney,et al.  First-Class Phantom Types , 2003 .

[33]  Gordon J. Pace,et al.  An embedded language framework for hardware compilation , 2002 .

[34]  Erik Meijer Dynamic typing when needed: The end of the cold war between programming languages , 2004 .

[35]  Koen Claessen,et al.  Observable Sharing for Functional Circuit Description , 1999, ASIAN.

[36]  van der Wmp Wil Aalst,et al.  Workflow control-flow patterns : a revised view , 2006 .

[37]  Serge Demeyer,et al.  An experimental investigation of UML modeling conventions , 2006, MoDELS'06.

[38]  Tobias Nipkow,et al.  Certifying Machine Code Safety: Shallow Versus Deep Embedding , 2004, TPHOLs.

[39]  Morten Rhiger,et al.  A foundation for embedded languages , 2002, TOPL.

[40]  Ralf Lämmel,et al.  Google's MapReduce programming model - Revisited , 2007, Sci. Comput. Program..

[41]  Gordon J. Pace,et al.  An embedded geometrical language in Haskell : construction, visualisation, proof , 2007 .

[42]  Gregor Engels,et al.  Activity diagram patterns for modeling quality constraints in business processes , 2005, MoDELS'05.

[43]  Joseph Cordina Functional HDLs : A Historical Overview , 2007 .

[44]  J. W. Backus,et al.  Can programming be liberated from the von Neumann style , 1977 .

[45]  Sören Sonntag,et al.  Modular domain-specific implementation and exploration framework for embedded software platforms , 2005, Proceedings. 42nd Design Automation Conference, 2005..

[46]  Mary Sheeran Hardware Design and Functional Programming: a Perfect Match , 2005, J. Univers. Comput. Sci..

[47]  Shane Sendall,et al.  Declarative techniques for model-driven business process integration , 2005, IBM Syst. J..

[48]  John J. O'Donnell From Transistors to Computer Architecture: Teaching Functional Circuit Specification in Hydra , 1995, FPLE.

[49]  Philip Wadler,et al.  The essence of functional programming , 1992, POPL '92.

[50]  Daan Leijen,et al.  Domain specific embedded compilers , 1999, DSL '99.

[51]  Wallace Feurzeig,et al.  LOGO -- A Programming Language for Teaching Mathematics. , 1972 .

[52]  Jochen Malte Küster,et al.  Definition and validation of model transformations , 2006, Software & Systems Modeling.

[53]  Mark P. Jones,et al.  Type Classes with Functional Dependencies , 2000, ESOP.

[54]  Samuel N. Kamin Research on Domain-specific Embedded Languages and Program Generators , 1997, US-Brazil Joint Workshops on the Formal Foundations of Software Systems.

[55]  Tom Mens,et al.  A Taxonomy of Model Transformation , 2006, GRaMoT@GPCE.

[56]  J. Roger Hindley,et al.  To H.B. Curry: Essays on Combinatory Logic, Lambda Calculus, and Formalism , 1980 .

[57]  Simon Thompson,et al.  Haskell: The Craft of Functional Programming , 1996 .

[58]  Jörg Becker,et al.  Guidelines of Business Process Modeling , 2000, Business Process Management.

[59]  Paul Hudak,et al.  Building domain-specific embedded languages , 1996, CSUR.

[60]  Oege de Moor,et al.  Compiling embedded languages , 2000, Journal of Functional Programming.

[61]  Simon L. Peyton Jones,et al.  Composing Contracts: An Adventure in Financial Engineering , 2001, FME.

[62]  Ralf Hinze,et al.  Fun with phantom types , 2003 .

[63]  Paul Hudak,et al.  An Experiment in Software Prototyping Productivity , 1994 .

[64]  Jana Koehler,et al.  The Role of Visual Modeling and Model Transformations in Business-driven Development , 2008, GT-VMT@ETAPS.

[65]  Henrik Nilsson,et al.  Functional reactive programming, continued , 2002, Haskell '02.

[66]  Jan Mendling,et al.  Faulty EPCs in the SAP Reference Model , 2006, Business Process Management.