Johannes Neubauer

Active continuous quality control

We present Active Continuous Quality Control (ACQC), a novel approach that employs incremental active automata learning technology periodically in order to infer evolving behavioral automata of complex applications accompanying the development process. This way we are able to closely monitor and steer the evolution of applications throughout their whole life-cycle with minimum manual effort. Key to this approach is to establish a stable level for comparison via an incrementally growing behavioral abstraction in terms of a user-centric communication alphabet: The letters of this alphabet, which may correspond to whole use cases, are intended to directly express the functionality from the user perspective. At the same time their choice allows one to focus on specific aspects, which establishes tailored abstraction levels on demand, which may be refined by adding new letters in the course of the systems evolution. This way ACQC does not only allow us to reveal serious bugs simply by inspecting difference views of the (tailored) models, but also to visually follow and control the effects of (intended) changes, which complements our model-checking-based quality control. All this will be illustrated along real-life scenarios that arose during the component-based development of a commercial editorial system.

Prototype-Driven Development of Web Applications with DyWA

In this paper we present an approach to the user-driven development of process-oriented web applications that combines business process modeling with user-side application domain evolution. In the center is the DyWA framework that accompanies the prototype-driven web-application development from the domain modeling through the development and deployment phase to the actual runtime and later product evolution: Using DyWA, application experts without programming knowledge are able to model according to their professional knowledge and understanding both domain-specific data models and the business process models that act on the data via automatically generated elementary data operations. The resulting business processes integrate data access and manipulation, and directly constitute executable prototypes of the resulting web application. All this is illustrated for OCS-lite, a cut-down version of Springers online editorial system.

Higher-Order Process Modeling: Product-Lining, Variability Modeling and Beyond

We present a graphical and dynamic framework for binding and execution of (business) processmodels. It is tailored to integrate 1) ad hoc processes modeled graphically, 2) third party servicesdiscovered in the (Inter)net, and 3) (dynamically) synthesized process chains that solve situation-specific tasks, with the synthesis taking place not only at design time, but also at runtime. Key toour approach is the introduction of type-safe stacked second-order execution contexts that allow forhigher-order process modeling. Tamed by our underlying strict service-oriented notion of abstrac-tion, this approach is tailored also to be used by application experts with little technical knowledge:users can select, modify, construct and then pass (component) processes during process execution asif they were data. We illustrate the impact and essence of our framework along a concrete, realistic(business) process modeling scenario: the development of Springer’s browser-based Online Confer-ence Service (OCS). The most advanced feature of our new framework allows one to combine onlinesynthesis with the integration of the synthesized process into the running application. This abilityleads to a particularly flexible way of implementing self-adaption, and to a particularly concise andpowerful way of achieving variability not only at design time, but also at runtime.

Plug-and-Play Higher-Order Process Integration

Unexpected hurdles in dealing with integration, variability, and interoperability in software development can be overcome using higher-order process integration. Even in its simplicity-oriented, tamed version, this approach fosters a powerful plug-and-play discipline, where processes and services are moved around like data.

Reusing System States by Active Learning Algorithms

In this paper we present a practical optimization to active automata learning that reduces the average execution time per query as well as the number of actual tests to be executed. Key to our optimization are two observations: (1) establishing well-defined initial conditions for a test (reset) is a very expensive operation on real systems, as it usually involves modifications to the persisted state of the system (e.g., a database). (2) In active learning many of the (sequentially) produced queries are extensions of previous queries. We exploit these observations by using the same test run on a real system for multiple “compatible” queries. We maintain a pool of runs on the real system (system states), and execute only suffixes of queries on the real system whenever possible. The optimizations allow us to apply active learning to an industry-scale web-application running on an enterprise platform: the Online Conference Service (OCS) an online service-oriented manuscript submission and review system.

Risk-based testing via active continuous quality control

In this paper, we show how our approach to active continuous quality control (ACQC), which employs learning technology to automatically maintain test models along the whole life cycle, can be extended to include risk analysts for supporting risk-based testing. Key to this enhancement is the tailoring of ACQC’s characteristic automata learning-based model extraction to prioritize critical aspects. Technically, risk analysts are provided with an abstract modeling level tailored to design test components (learning symbols) that encompass data-flow constraints reflecting a given risk profile. The resulting alphabet models are already sufficient to steer the ACQC process in a fashion that increases the risk coverage, while it at the same time radically reduces the testing effort. We illustrate our approach by means of case studies with Springer’s Online Conference Service (OCS) which show the impact of the risk prioritization on the performance: risk-based regression testing tailored for system migration and for pure functional evolution.

Simplicity-first model-based plug-in development

In this article, we present our experience with over a decade of strict simplicity orientation in the development and evolution of plug‐ins. The point of our approach is to enable our graphical modeling framework jABC to capture plug‐in development in a domain‐specific setting. The typically quite tedious and technical plug‐in development is shifted this way from a programming task to the modeling level, where it can be mastered also by application experts without programming expertise. We show how the classical plug‐in development profits from a systematic domain‐specific API design and how the level of abstraction achieved this way can be further enhanced by defining adequate building blocks for high‐level plug‐in modeling. As the resulting plug‐in models can be compiled and deployed automatically, our approach decomposes plug‐in development into three phases where only the realization phase requires plug‐in‐specific effort. By using our modeling framework jABC, this effort boils down to graphical, tool‐supported process modeling. Furthermore, we support the automatic completion of process sketches for executability. All this will be illustrated along the most recent plug‐in‐based evolution of the jABC framework, which witnessed quite some bootstrapping effects. Copyright

DIME: A Programming-Less Modeling Environment for Web Applications

We present DIME, an integrated solution for the rigorous model-driven development of sophisticated web applications based on the Dynamic Web Application (DyWA) framework, that is designed to accelerate the realization of requirements in agile development environments. DIME provides a family of Graphical Domain-Specific Languages (GDSLs), each of which is tailored towards a specific aspect of typical web applications, including persistent entities (i.e., a data model), business logic in form of various types of process models, the structure of the user interface, and access control. They are modeled on a high level of abstraction in a simplicity-driven fashion that focuses on describing what application is sought, instead of how the application is realized. The choice of platform, programming language, and frameworks is moved to the corresponding (full) code generator.

Meta-Level Reuse for Mastering Domain Specialization

We reflect on the distinction between modeling and programming in terms of what and how and emphasize the importance of perspectives: what is a model (a what) for the one, may well be a program (a how) for the other. In fact, attempts to pinpoint technical criteria like executability or abstraction for clearly separating modeling from programming seem not to survive modern technical developments. Rather, the underlying conceptual cores continuously converge. What remains is the distinction of what and how separating true purpose from its realization, i.e. providing the possibility of formulating the primary intent without being forced to over-specify. We argue that no unified general-purpose language can adequately support this distinction in general, and propose a meta-level framework for mastering the wealth of required domain-specific languages in a bootstrapping fashion.

Second-Order Servification

In this paper we present second-order servification, a business process modeling paradigm for variability. Key to this paradigm is to consider services and even whole subprocesses as ‘resources’ of a (second-order) business process, which can be created, selected, and moved around just like data. This does not only allow us to easily define new variants of a business process simply via second-order parameterization, but also to exchange its constituent services (and even sub-processes) dynamically at runtime. In fact, the concrete implementation of a second-order activity in a process model may be unknown when the process starts, and built-up and exchanged while the process is running. We will illustrate the ease of the new paradigm along a flight booking scenario, where our corresponding second-order process model allows us to dynamically instantiate the payment process even with process implementations that were not available when the overall process started.