Abstract Indentation is an old technique that emphasizes elements in source code using white spaces or tabs. But while this technique has been taught and applied for decades, evidence for its effectiveness is weak: up to 2022 relatively few experiments can be found – the present authors are only aware of one single experiment that revealed an effect of indentation and reported the effect size, but even in that experiment the effect of indentation was found to be weak. The situation changed recently, where an experiment was published that suddenly revealed a strong and large effect of indentation in control flows on reaction time. However, although the experiment provided an initial indication of a possible cause for the difference between indented and non-indented code (the length of the code that can be skipped in indented code), the evidence for this indicator was rather weak. The present paper presents a formal model on the differences in reading times (measured in terms of reaction times) between indented and non-indented code. Based on that model a controlled experiment on generated tasks was designed and executed on 27 participants (undergraduate students, PhD students, professionals). The experiment (again) confirms a strong (p < .001) and large ( $$\eta _{p}^{2}$$ ηp2 = .198, $$\frac{M_{Non-Indented}}{M_{Indented}}$$ MNon-IndentedMIndented = 2.13) effect of indentation. Furthermore, it confirms that the larger the skippable code is, the larger is the difference between reading time of indented and non-indented code (p = .001, $$\eta _{p}^{2}$$ ηp2 = .072). I.e., the experiment goes beyond the point “indented vs non-indented code” and explains the difference by revealing a factor that controls this difference. However, although the previous statements holds true for the whole sample in the experiment, this effect could only be shown for a subset of individual participants.

Java's Stream API, that massively makes use of lambda expressions, permits a more declarative way of defining operations on collections in comparison to traditional loops. While experimental results suggest that the use of the Stream API has measurable benefits with respect to code readability (in comparison to loops), a remaining question is whether it has other implications. And one of such implications is, for example, tooling in general and debugging in particular because of the following: While the traditional loop-based approach applies filters one after another to single elements, the Stream API applies filters on whole collections. In the meantime there are dedicated debuggers for the Stream API, but it remains unclear whether such a debugger (on the Stream API) has a measurable benefit in comparison to the traditional stepwise debugger (on loops). The present papers introduces a controlled experiment on the debugging of filter operations using a stepwise debugger versus a stream debugger. The results indicate that under the experiment's settings the stream debugger has a significant ($\mathrm{p} < .001$) and large, positive effect$(\eta_{p}^{2}=.899;\ \frac{M_{stepwise}}{M_{stream}} \sim 204\%)$. However, the experiment reveals that additional factors interact with the debugger treatment such as whether or not the failing object is known upfront. The mentioned factor has a strong and large disordinal interaction effect with the debugger ($\mathrm{p} < .001; \eta_{p}^{2}=.928$): In case an object is known upfront that can be used to identify a failing filter, the stream debugger is even less efficient than the stepwise debugger$(\frac{M_{stepwise}}{M_{stream}}\sim 72\%)$. Hence, while we found overall a positive effect of the stream debugger, the answer whether or not debugging is easier on loops or streams cannot be answered without taking the other variables into account. Consequently, we see a contribution of the present paper not only in the comparison of different debuggers but in the identification of additional factors.

Wind energy is an important source of renewable and sustainable energy and therefore an elementary component of any future energy supply. However, the operation of large wind farms places high demands on reliability and is often impacted by high maintenance and repair costs in the event of a failure. A frequency converter is one of the most important components of each wind turbine, which ensures that the frequency of the generated energy synchronises with the grid frequency and thus enables the flow of energy into the power grid. The detection of anomalies in these devices is complex due to the high frequency and multidimensionality of different sensor information from the energy control units and requires fault patterns to be discovered and detected in large time series. In this paper, we show how state-of-the-art self-supervised-learning techniques, namely LSTM autoencoders, can be successfully applied to real-world data. We describe the extensions we have made to deal with the often very noisy sensors and describe the construction of the training data set. The trained system was first tested and evaluated on synthetic data and subsequently on a large real-world data set. In both cases, it was shown that outliers can be reliably identified using our presented approach.

Users must pay a fee depending on resource consumption when using smart contracts on the Ethereum blockchain. As even the most basic operations cost several dollars under moderate network load, developers may actively reduce user-paid fees by optimizing the smart contract resource consumption (’gas costs’). Previous works suggested patterns and tools supporting developers in gas cost optimization, but up to now a comprehensive analysis of their real-world impact is missing. Another gap is the maintenance and evolution support for smart contracts leveraging the publicly available usage data. We propose high-level gas cost profiles and review which profiles are considered in the existing literature. Additionally, we sampled around 68,000 smart contract interactions from three years, analyzed them using the gas cost profiles, and compare the findings to the current focus in literature. In our data set, external code, storage, and the transaction base fee are first-level cost drivers in terms of absolute gas usage, but contract deployment becomes also costly when considering the average gas usage per transaction. Our analysis also shows that plenty of previous work focused cost categories barely influencing resource consumption.

With the increased availability of solutions using Artificial Intelligence and Machine Learning, more and more business processes are based on technical components delivering probabilistic results. A prominent examples are applications from the Internet of Things that heavily rely on sensor information and data stream processing. Another trend that is gaining more traction is the use of No- and Low-Code-Platforms to create applications. Such approaches focus on defining the business logic via business process modeling and automatically create a corresponding executable application. We argue that using components based on Artificial Intelligence and Machine Learning in such applications requires to handle uncertainty resulting from probabilistic results accordingly. This means to introduce, e.g., fallback mechanisms if results delivered from composing using Artificial Intelligence err into modeled business processes. In this position paper, we discuss scenarios, arising problems, and potential solutions.

Cyber-Physical Systems change at runtime, so errors are very difficult to trace. The Information Flow Monitor is a tool that captures semantic dependencies between exchanged information. To do so, we use spy nodes as observing instances distributed throughout the network. The positioning of the spies is thus important to cover as many information paths as possible. In this paper, we examine guidelines to achieve high path coverage with as less as possible spies. Using an evolutionary algorithm, a machine learning technique, we develop a metaheuristic that enables us to quickly select such spy sets.

Augmented reality changes the way we perceive reality and how we interact with computers. However, we argue that to create augmented reality solutions, we need to rethink the way we develop software. In this paper, we review the state of the art in software engineering for augmented reality applications, derive open questions, and define a research agenda. For this purpose, we consider different engineering phases and evaluate conventional techniques regarding their applicability for AR development. In requirements engineering, we found the integration of AR experts and the associated collaboration between actors to be of key aspect in the development process. Additionally, requirements about the physical world must be considered, which in turn has a huge impact on UI design. The relevance of the physical environment is not yet sufficiently addressed in applicable techniques, which also applies to current implementation frameworks and tools, complicating the AR development process. When evaluating AR software iterations, we found interaction testing and test automation to have great potential, although they have not yet been sufficiently researched. Our paper contributes to AR research by revealing current core challenges within the AR development process and formulating explicit research questions that should be considered by future research.

Abstract To gain a common understanding of an application’s layouts, dialogs and interaction flows, development teams often sketch user interface (UI). Nowadays, they must also define multi-touch gestures, but tools for sketching UIs often lack support for custom gestures and typically just integrate a basic predefined gesture set, which might not suffice to specifically tailor the interaction to the desired use cases. Furthermore, sketching can be enhanced with digital means, but it remains unclear whether digital sketching is actually beneficial when designing gesture-based applications. We extended the AugIR, a digital sketching environment, with GestureCards, a hybrid gesture notation, to allow software engineers to define custom gestures when sketching UIs. We evaluated our approach in a user study contrasting digital and analog sketching of gesture-based UIs.

The Information Flow Monitor (IFM) is a protocol and tool that can record dependencies between exchanged information in Cyber-Physical Systems (CPS). This makes it possible to determine the original source of faulty information in case of an error and to correct errors at their origin. However, the IFM protocol also requires additional resources in terms of processing time and network traffic. In this paper, we measure the additional resources required using an example network and discuss how these resources can affect the operation of a CPS.

Describing gestures in detail has various advantages for project teams: communication is simplified, interaction concepts are documented, and technical decisions are supported. Common gesture notations focus on textual or graphical elements only, but we argue that hybrid approaches have various advantages, especially because some gesture traits are easier to describe with text and others with arrows or icons. We present GestureCards, a hybrid gesture notation mixing graphical and textual elements we developed to describe multi-touch gestures. To evaluate our approach, we compared how users perceive and are affected by different notations. First, we compared GestureCards with a textual notation and observed advantages in terms of speed, correctness, and confidence. Second, we asked participants to compare GestureCards, a textual, and a graphical notation and rate them. The results indicate that the participants' perception depends on the gesture, but GestureCards received consistently good ratings. Third, we monitored several participants working with GestureCards solving practical development tasks for gesture-based applications and they felt well supported by GestureCards.

Summary Sooner or later, in almost every company, the maintenance and further development of large enterprise information technology (IT) applications reaches its limit. From the point of view of cost as well as technical capability, legacy applications must eventually be replaced by new enterprise IT applications. Data migration is an inevitable part of making this switch. While different data migration strategies can be applied, incremental data migration is one of the most popular strategies, due to its low level of risk: the entire data volume is split into several data tranches, which are then migrated in individual migration steps. The key to a successful migration is the strategy for decomposing the data into suitable tranches. This paper presents a method for data decomposition where the entire data volume of a monolithic enterprise IT application is split into independent data migration tranches. Each tranche comprises the data to be migrated in one migration step, which is usually executed during the application's downtime window. Unlike other methods, which describe data migration in a highly abstract way, we propose specific heuristics for data decomposition into independent data packages (tranches). The data migration approach described here is being applied in one of the largest migration projects currently underway in the European health care sector, comprising millions of customer records.

Observing semantic dependencies in large and heterogeneous networks is a critical task, since it is quite difficult to find the actual source of a malfunction in the case of an error. Dependencies might exist between many network nodes and among multiple hops in paths. If those dependency structures are unknown, debugging errors gets quite difficult. Since CPS and other large networks change at runtime and consists of custom software and hardware, as well as components off-the-shelf, it is necessary to be able to not only include own components in approaches to detect dependencies between nodes. In this paper we present an extension to the Information Flow Monitor approach. Our goal is that this approach should be able to handle unalterable blackbox nodes. This is quite challenging, since the IFM originally requires each network node to be compliant with the IFM protocol.

Cyber-Physical Systems (CPS) are interconnected systems, that adapt to their environment. They are quite challenging to engineer and to test, because the its interconnected and networked structures changes at runtime. Dependencies and influencing between nodes in the network might be difficult to test, because there are many hidden impacts on not directly connected nodes. In this paper, we present our experimentation environment which we use to simulate different CPSs. The focus of the development of this environment is to be able to rapidly generate, deploy and change software and network connections within the CPS and to observe resulting impacts on the network.

Program comprehension is an important skill for programmers - extending and debugging existing source code is part of the daily routine. Syntax highlighting is one of the most common tools used to support developers in understanding algorithms. However, most research on code highlighting is more than 20 years old, when programmers used a completely different tool chain. Newer results on the effect of syntax highlighting as used in modern Integrated Development Environments (IDEs) are inconclusive.

Developing CPS means uniting multiple engineering disciplines: mechanical, electrical and software engineering. Each of them provides a set of models, guidelines and processes crucial for a projects success. Consequently, CPS development is heavily influenced by processes known in either engineering discipline. There is currently no coherent software engineering approach to develop CPS, making it very hard to align the aforementioned domain experts in a controlled and repeatable process. This paper takes a step towards filling this gap by providing the insights during the development of a CPS in the form of an experience report. Based on our findings we validated the use of the Double TwinPeaks model and contribute to the field of software engineering for CPS the Matrix of Granularity to assess the components of a CPS in terms of customizability, risk and constraints.

In this paper, we describe how mobile learning sets new impulses for teaching and learning in project-oriented higher education. In our project clavis, we support the self-directed learning, deepening and application of knowledge and skills in project phases of the master program of “Applied Computer Science and Systems Engineering” (AI-SE) at the University of Duisburg-Essen. Therefore, we want to provide practical examples and relevant learning units in a mobile multimedia toolbox. Students can come back to the small learning chunks during their master projects regardless of time and place. The development of our learning platform is an agile and iterative process model that is tailored to the needs of the target group. To ensure user-friendly implementation and to increase the acceptance, we involve members of the target group continuously throughout the development and implementation process. We raised the requirements in workshops with the participation of future users and the development team. Based on the findings we became aware of the requirements related to the content, didactic methods and technical concepts, that form the basis for the implementation. In this article, we provide a brief insight into our approach, the concept and the students' requirements for the development of the micro learning units and mobile learning platform.

Linked data is a data publishing method that can be used to connect any kind of globally available data into a single multigraph. This kind of graph provides enormous opportunities for machine learning and data mining techniques to train models with large heterogenous types of data and find new relationships. Both are however strongly dependent on the engineering of high quality features and therefore requires knowledge of the domain. Recent advances in the field of representation learning has led to significant progress in automating the feature engineering process. Neural word embedding techniques from the natural language processing domain have been used to learn representations of graph nodes and subsequently applied to linked data nodes. In contrast to natural language where sentences serve as natural boundary for the context of a word, in a graph – boundaries are not clearly defined and multiple context sampling strategies exist. Applying different context sampling strategies on graph nodes result in different context sentences and subsequently different features. In this work, we explore two different context sampling strategies: predicate removal from random walks as well as breadth first search based sampling and compare them to the state of the art based on random walks. The quality of the generated features is evaluated indirectly by measuring the performance of machine learning models on a classification task across multiple data sets. Furthermore, we explore the effect of generating embeddings only for the entities that have to be classified and their neighbors, instead of generating embeddings for every node in a possibly large RDF graph. The results suggest that for classification of same typed entities the inclusion of predicates in the sampled walks for generating embeddings is of little use and can be omitted without losing classification accuracy. Results also show that the in-degree and out-degree of the entities may be useful hint for selecting the optimal sampling technique.

Cyber-Physical Systems are distributed, heterogeneous, decentralized and loosely coupled networks in which individual systems measure physical processes, exchange information, and influence processes. Sensors measure these physical processes, while aggregators process them and actuators perform resulting actions. Decisions are often based on sensor data collected by other systems. Furthermore, the aggregators also interchange information and use them to derive own decisions. Decisions must be comprehensible. However, this is only the case if all data dependencies are known. Due to the size of these networks, their loose coupling and their dynamic behavior, decisions made by a system are not always easy to understand. If an error occurs in the system, the error source must be identified. It must be known on which data a decision was based. However, since the decision can be based on information from other nodes, the search for the error source is not a trivial task. Keep in mind, that dependent nodes can have dependencies themselves as well. We present the Information Flow Monitor (IFM) that collects information about semantic data dependencies in dynamic networks. The collected dependency information is provided at a central network location. Subsequently, semantic dependencies between information can be visualized.

Cyber-physical systems are context-aware networked systems containing sensors, aggregators and actuators. Raw sensor data and aggregated information are spread among the network and processed in multiple nodes to result in an action, which is possibly executed at a different physical location in the network. Due to the flexible topology and the emergent features of CPS, decisions within the network that trigger actions are not always trivial to understand. These decisions are based on raw sensor data which are not clearly visible at the location of their execution. This can be problematic if decisions have to be justifiable. It becomes even more difficult if decisions has been flawed, and it is not ascertainable why they were made. In order to determine the reasons for incorrect decisions in the network, the dependencies and input values of a decision must be known. Without this information, debugging is quite difficult. In this paper, we present the Information Flow Monitor, which can capture and visualize dependencies between nodes and information in CPS.

Connecting digital information systems with real world objects and processes is the core of the digital transformation. New business models and opportunities thrive on the various options that the resulting information offers. Cyber-Physical Systems (CPS) are the most prominent incarnation and – in contrast to various other aspects of the digital transformation – really new: sensors and actors allow information systems to monitor the real world and will profoundly change most markets and business domains. However, developing CPS involves different specialists and various technical challenges. Software and hardware engineers, network specialists, and data scientists have to work hand in hand and combine their specialties to incorporate the different perspectives into one team. We present EngCPS, an engineering approach to develop CPS that enhances classic software engineering methods with CPS-specific extensions.

Security is an important feature of the software. Integrating security requirements right at the beginning not only ensure secure software but also save a lot of precious time and reduce the effort of rework of software development team. However, to build a secure system is not an easy task and it is extremely difficult to develop a secure system, especially in the case of cyber-physical systems (CPS). In this paper, we propose a security requirements engineering framework that provides ways to determine security requirements throughout the requirements engineering phase which consists of a number of activities to elicit and finalize the security requirements for CPS. Additionally, we determine the activities that need to be implemented in the security requirements engineering framework to address security requirements for CPS. We compare our proposed security requirements engineering framework with other existing software security frameworks. The result shows that not all software security frameworks perform all the basic and important activities in the development of secure software systems. This may also result in a development of an unsecure cyber-physical systems. Furthermore, this comparison survey helps us to identify the short-comings in SRE frameworks which has been rectified in our proposed security requirements engineering framework for CPS.

There has been extensive research on the the factors that motivate software developers to contribute to an Open Source Software (OSS) project. Contribution barriers are the counter-side to motivations and prevent newcomers from joining the OSS project. This study searches for relations between motivations and contribution barriers with a web-based survey of 117 developers who had recently contributed their first patch to either Mozilla or GNOME.

The accuracy of effort estimates is an important factor for the success of a project. In agile projects, these estimates are often obtained through the structured group estimation process of planning poker. To increase the accuracy of such estimates, we propose to annotate user stories with symbols that highlight risk and effort drivers and thus give all team members a better understanding of a project's challenges. In this paper, we report on the results of a study that examines the effect of using risk and effort annotations on project teams' level of shared understanding, estimation accuracy and estimation bias. Our results show that the use of annotations in planning poker increases estimation accuracy.

Code reviews are an essential part of quality assurance in Free, Libre, and Open Source (FLOSS) projects. However, finding a suitable reviewer can be difficult, and delayed or forgotten reviews are the consequence. Automating reviewer selection with suitable algorithms can mitigate this problem. We compare empirically six algorithms based on modification expertise and two algorithms based on review expertise on four major FLOSS projects. Our results indicate that the algorithms based on review expertise yield better recommendations than those based on modification expertise. The algorithm Weighted Review Count (WRC) recommends at least one out of five reviewers correctly in 69 % to 75 % of all cases, which is one of the best results achieved in the comparison.

Testing is a crucial activity to maintain high quality standards and achieve long-lasting economic success. However, integrating voice control into apps prevents the use of test automation tools. Testing speech-based interaction is still manual work: repetitive, time-consuming, and error-prone. Consequently, a need for specialized software engineering methods exists. We present an approach to test automation for speech-based applications by integrating an audio injection test interface into the Android operating system. Our approach enables developers to integrate voice control into automatically executed user acceptance tests using the Calabash test automation framework.

Newcomers are faced with contribution barriers when they want to join a Free/Libre and Open Source Software (FLOSS) project. Using wiki principles in software development has been proposed as one approach to lower contribution barriers. This approach requires a Wiki Development Environment (WikiDE), which is both a wiki and an Integrated Development Environment (IDE). This paper presents a Proof of Concept (PoC) realization of a WikiDE comprising three main components: a software forge, a Continuous Integration (CI) system, and a reviewer recommendation system.

While the motivations of Free/Libre and Open Source Software (FLOSS) developers have been the subject of extensive research, the motivations for their initial contribution to a FLOSS project has received only little attention. This survey of 94 newcomers to the FLOSS projects Mozilla and GNOME identifies the motivations for the modification of the FLOSS components and for the submission of these modifications back to the FLOSS project. With the responses, we test a hypothesis based on the previous qualitative research on newcomer motivations: Most newcomers modify a component because they need the modification for themselves. Surprisingly, this is not the case for our respondents, who have a variety of primary modification motivations. Newcomer occupation is discussed as a reason for this difference to previous results.

Touch- and gesture-based interfaces are common in applications for mobile devices. By evolving into mass market products, smartphones and tablets created an increased need for specialized software engineering methods. To ensure high quality applications, constant and efficient testing is crucial in software development. However, testing mobile applications is still cumbersome, time-consuming and error-prone. One reason is the devices' focus on touch-based interaction - gestures cannot be easily incorporated into automated application tests. We present an extension to the popular Calabash testing framework solving this problem by allowing to describe gestures with a formal language in tests scripts.

In complex business modelling and software development projects, we often observe that teams focus on those aspects of a system that are well understood or easy to resolve, while a blind eye is turned (consciously or subconsciously) to the actual value and effort drivers – i.e. those components that require higher effort due to their intrinsic value, risk, complexity or uncertainty. In this paper, we introduce a pragmatic approach for highlighting elements of high-level business and system models with visual annotations that mark particular issues, requirements or complexities that would otherwise not immediately meet the eye, and would thus present risks to a project's successful completion if uncovered too late.

The success of a “Free, Libre and Open Source Software” (FLOSS) project depends on its ability to attract new developers. However, before prospective developers can contribute their first patch, they have to overcome the contribution barriers of the FLOSS project. This paper presents two patterns. Each pattern identifies a possible problem in the contribution processes of FLOSS projects and shows a practice to alleviate this problem. The first pattern helps prospective developers compile the FLOSS project's source code and build an executable application. The second pattern encourages prospective developers to submit their modifications back to the FLOSS project and at the same time fosters integration of these modifications into the main development branch of the FLOSS project.

Continuous Integration (CI) and Free, Libre and Open Source Software (FLOSS) are both associated with agile software development. Contradictingly, FLOSS projects have difficulties to use CI and software forges still lack support for CI. Two factors hamper widespread use of CI in FLOSS development: Cost of the computational resources and security risks of public CI services. Through security analysis of public CI services, this paper identifies possible attack vectors. To eliminate one class of attack vectors, the paper describes a concept that encapsulates a part of the CI system via virtualization. The concept is implemented as a proof of concept.

Large-scale information system development is often plagued by defects and deadline overruns that can be traced to insufficient communication within the project team, particularly between stakeholders from the business, technical and management side. Although agile process models put a strong emphasis on team communication, they provide only little support for focusing the communication on the most relevant issues. We therefore introduce the concept of so-called "interaction rooms", where teams work with a pragmatic combination of model sketches and annotations to foster understanding of the system and its business domain, to reveal risks and uncertainties, and discuss those system aspects that are most critical for project success.

Joining existing software development teams usually comes with a difficult and time-consuming setup of the technical development environment. Before new software developers can contribute their first line of code to the project, they must install the complete technical development environment on their computers. To support software developers becoming productive as fast as possible, we apply the wiki concept to software development projects. This paper introduces the concept of a Wiki Development Environment (WikiDE): A wiki system with which software developers can edit, compile, and debug applications using a standard web browser. We analyze the technological requirements for the realization of a WikiDE as well as the conceptual differences between a WikiDE and other wikis.

Cars offer an increasing number of infotainment systems as well as comfort functions that can be controlled by the driver. In our research, we investigate new interaction techniques that aim to make it easier to interact with these systems while driving. We suggest utilizing the steering wheel as an additional interaction surface. In this paper, we present two user studies conducted with a working prototype of a multi-touch steering wheel. In the first, we developed a user-defined steering wheel gesture set, and in the second, we applied the identified gestures and compared their application to conventional user interaction with infotainment systems in terms of driver distraction. The main outcome was that driver's visual demand is reduced significantly by using gestural interaction on the multi-touch steering wheel.

Despite numerous software engineering problems, the software development community as a whole still suffers from delayed and canceled software projects. The basic idea of this paper is that this is – besides other potential reasons – also due to little focus on how people participating in software processes interact. These interactions seem crucial to the success of software processes and in fact they are very often only poorly supported.

A tremendous amount of software models has been created so far. This growing number of models adds to the fact that it gets more and more difficult to organise, structure, and reuse them. Thereby new software development projects cannot profit from existing knowledge. In our research we will study existing natural language processing techniques for their adaptability in the reuse of software models. We will research methods to group existing models according to their functionality.

There is a lot of research anticipating a "Free, Libre and Open Source Software" (FLOSS) development process and recurring characteristics of FLOSS projects have been discussed by various authors. Research suggests that a unique FLOSS development approach does not exist and there is a family of different development processes instead. Pattern Languages have been used to describe distinctive and common features of processes. In this paper, we identify four FLOSS development patterns derived from related work and discussion about FLOSS in the communities. Building on that, we propose methods to verify the patterns.

In this paper we tackle the question how early phases of software projects can be improved by applying methodologies provided by psychological science. We show an approach for developing business information systems, called No-Frills Software Engineering, which benefits from systemic approaches. These approaches allow to resolve communication and interaction issues still persistent in early phases of software projects, which are normally not addressed by conventional software process models.

Abstract In this article, we present the prototype of a modeling tool that applies graph‐based rules for identifying problems in business process models. The advantage of our approach is twofold. First, it is unnecessary to compute the complete state space of the model to find errors. Second, our technique can even be applied to incomplete business process models. Thus, the modeler can be supported by direct feedback during the model construction. This feedback not only reports problems, but also identifies their reasons and gives suggestions for improvement. Copyright © 2010 John Wiley & Sons, Ltd.

The complexity of data-intensive business processes is typically reflected in the user interfaces of the information systems supporting them. To facilitate ease of use despite the visual and semantic complexity of dialog forms, users should be guided in ways such as highlighting and describing invalid input, showing/hiding or enabling/disabling particular UI widgets. Manual implementation of the rules governing these user interface responses typically requires considerable effort, as they involve business and presentation concerns, and are often dependent on each other. In addition, users expect the interface to respond immediately to any input, which can be especially challenging in web applications. In this paper, we formalize the aspects that must be considered in formulating input evaluation rules, and present a run-time framework that encapsulates the necessary logic, enabling domain experts to specify the business rules instead of requiring developers to implement them.

After years of heavyweight software process models there is a trend in industry towards agile methods for the development of business information systems. Experience shows that these approaches are promising, but there is still the demand for a lean and practicable, yet predictable approach for developing business information systems.

Development and maintenance of complex web interfaces containing hundreds of input fields typically causes huge development effort. Changing the layout or adding input fields to complex user interfaces are especially tedious tasks are, because these changes affect the alignment of many other interface elements. To reduce this effort, we developed a ruler guide-based approach that combines the efficiency of automatic generation of complex user interfaces from an XML-based specification with the flexibility of a manually layouted user interface. First experiences with a proof-of-concept implementation show that the effort needed for development and maintenance can be significantly reduced.

Information systems for the support of complex business processes are often equipped with web-based front-ends to allow convenient user access. To produce executable specifications of the users' interactions with such web-based applications, we use a visual language that enables developers to model their complex dialog structures. In this paper, we introduce the formal semantics of the core constructs of this Dialog Flow Notation: We define its syntax in terms of invariants about the permitted elements and their relations, and show how any words of the language (i.e. any syntactically correct dialog flow specifications) can be mapped to a deterministic pushdown automaton whose behavior defines the notation's semantics. This gives us and other tool developers a formal basis for the design and implementation of tools and frameworks that mirror the precise meaning of all DFN constructs.

In ubiquitous environments, users are exposed to public spaces and places where they are supposed to interact and provide also private information. In order to enhance user acceptance of such ubiquitous appliances they have to be designed to consider trust and trustworthiness already in the design phase. We focus on regarding trust in early phases and provide tools for designers by describing trust issues through patterns which are made available through design repositories. Such patterns help designers of ubiquitous applications to create designs quicker based on the availability of already proven solutions they can rely on.

The emerging behavior of a mobile system–where hardware devices of different types interoperate–is determined by its software architecture (structure, dynamics, deployment), the underlying communication networks (topology, properties like bandwidth etc.) and interactions undertaken by the users of the system. In order to assess whether a mobile system fulfills its non-functional requirements like response times or availability already at design time, the emergent behavior of such a system can be simulated by using an architectural model of the system and applying an simulation approach where a network model and a user interaction model are used for providing the contextual information.

Today, we are seeing an increasing number of software applications that users want to use anywhere, anytime. Such mobile applications often deliver their user interfaces (UIs) to client devices over the World Wide Web. However, Web-based UIs cannot provide the same level of usability as window-based UIs on mobile devices with their small screens and occasional network dropouts. To address this challenge, we present a UI framework that combines the usability of a full-featured UI with the flexibility of a thin presentation logic: We exchange interface specifications and events between the application logic on the server and a generic UI rendering engine on the client device using an instant messaging infrastructure. The paper gives an overview of the framework architecture and the features of the communication protocol, and discusses performance measurements obtained on a public network.

Mobile B2E-applications (business-to-employee) can add significant value to a company's business, when large workforce divisions are involved in the execution of certain business processes. From a technical point of view, the major issues are solved (e.g. solutions for connectivity, broadband mobile networks, synchronization mechanisms, secure protocols etc.). But from a business point of view there is a lack of methodology regarding the alignment of technical solutions to the business needs. As companies face a continuously faster change in business models, legal constraints and customer needs, highly flexible systems are needed to react to changing business processes. Furthemore, the introduction of new mobile systems is often a technology-driven process, pushing the alignment of software and systems to the highly specific, fast changing business needs into the background. This paper introduces a framework summarizing the findings from earlier research and case studies related to this topic. The framework consists of a general reference process for mobile work and of a model explaining influencing factors, optimization goals and their relationships for mobile processes. The framework can be applied for process modeling, simulation and optimization as well as for requirements analysis and return on investment calculations.

In this paper we introduce an analysis framework for mobile workforce automation. The framework is based on the findings from earlier research as well as on an analysis of 27 recent case studies conducted within the field of mobile workforce automation. It consists of a general reference process for mobile work and of a model explaining influencing factors (worker, task, coordination system, information system), optimization goals and their relationships in mobile business processes. The framework can be applied to process modeling, simulation, and optimization as well as to requirements analysis and return on investment calculations. Based on the results of case study evaluation, it is furthermore shown, that recent mobile IT solutions are mainly built for relatively simple processes and cooperation models. Mobilizing more complex processes still seems to be a challenge.

This paper introduces a graphical modeling notation based on coloured Petri nets for the performance and cost evaluation of mobile applications. When developing such an application some restrictions due to the low bandwidth of mobile networks need to be considered. The notation can be used to model the workflow of a mobile application with just a small effort. The resulting model can be (automatically) transformed into a coloured Petri net for simulating the communication behaviour depending on typical user interactions. The simulation results are an important basis for improving the applications performance and the occurring costs for using mobile networks

In Web-based applications, most user interactions take the form of navigating between Web pages. The structure of the navigation model thus has a strong impact on a Web application's usability. However, specifying a user-friendly navigation model for complex applications can be time-consuming, especially when designing for multiple presentation channels. We therefore present the formal semantics of the dialog flow notation (DFN) that provides constructs for the design of modular navigation models, and especially focus on constructs that reduce the specification redundancy within and between channels, thus reducing the design effort for Web-based user interfaces

When building enterprise applications that need to be accessed through a variety of client devices, developers usually strive to implement most of the business logic device-independently while using a Web browser to display the user interface. However, when those Web-based front-ends shall be rendered on different devices, their differing I/O capabilities may require device-specific interaction patterns that still need to be specified and implemented efficiently. We present an approach for specifying the dialog flows in multichannel Web interfaces with very low redundancy and introduce a framework that controls Web interfaces' device-specific dialog flows according to those specifications, while keeping the enterprise application logic completely device-independent

When building web applications for use on different devices, developers need to deal with a wide range of input/output capabilities that affect how users interact with the application: A dialog that can be completed in one step on a desktop client may have to be broken up into a number of steps on a small-screen mobile device. Since it is time-consuming to define all the possible dialog masks and dialog flow variants for different channels manually, it would be desirable to automate the adaptation of dialog masks and flows.To address this need, we introduce the DiaDef language for the abstract, device-independent definition of the widgets in a dialog, and the DiaGen framework that automatically breaks this abstract dialog definition down into sufficiently small dialog masks for the users' mobile devices and incorporates them into suitable micro dialog flows that are generated at run-time in order to be handled by our Dialog Control Framework.

Today, thin client applications often rely on the infrastructure of the WWW to deliver their user interfaces (UIs) to clients. While this approach does not require the deployment of application logic on the client, Web-based UIs typically do not provide the same level of usability as window-based UIs. We therefore present a UI framework that combines the flexibility of a thin presentation logic with the usability of a full-featured UI: Our approach uses an XMPP-based instant messaging infrastructure to exchange XUL interface descriptions and events between the application logic on the server and a generic UI rendering engine on the client

Many commercial off-the-shelf fleet telematics systems can provide basic tracking & tracing functionalities for vehicle fleets. These systems, however, require that dispatchers manually identify any discrepancies between the actual data available in the fleet telematics system and the planned data in the logistics system. Furthermore, actual data such as arrival and departure times at customer locations must be transferred manually between the fleet telematics system and the logistics system. In this paper we present a Fleet Monitoring System which can be used for advanced tracking of commercial vehicles. The Fleet Monitoring System can analyse messages sent from the vehicles in order to identify discrepancies between actual and planned data. Furthermore, it can be used to revise the planned data and to update the database of the logistics system, e.g. to store exact arrival and departure times at customer locations. As unexpected incidents and ambiguities are automatically detected, dispatchers do not need to manually analyse all messages sent by the vehicles and can quickly react on possible disturbances in the transportation processes.

When considering the addition of a mobile presentation channel to an existing web-based application, a key question that has to be answered even before development begins is how the mobile channel's characteristics will impact the user experience and the cost of using the application. If either of these factors is outside acceptable limits, economical considerations may forbid adding the channels, even if it would be feasible from a purely technical perspective. Both of these factors depend considerably on two metrics: The time required to transmit data over the mobile network, and the volume transmitted. The PETTICOAT method presented in this paper uses the dialog flow model and web server log files of an existing application to identify typical interaction sequences and to compile volume statistics, which are then run through a tool that simulates the volume and time that would be incurred by executing the interaction sequences on a mobile channel. From the simulated volume and time data, we can then calculate the cost of accessing the application on a mobile channel, and derive suitable approaches for optimizing cost and response times.

We present a dialog-driven process model for the development of Web-based applications that uses a graphical notation to model and iteratively refine the application's dialog flow, and communicate with non-technical stakeholders in the development process. This way, the user interface can drive the design and implementation of the application logic and data model instead of being dictated by it. After an introduction of the underlying notation and dialog control framework, we present how these tools can support the phases of the development process and discuss experiences gained from the implementation of a Web application that was built using this approach.

We present a pattern system for property specification. It extends the existing patterns identified by M.B. Dwyer, G.S. Avrunin, and J.C. Corbett (1998) which allow to reason about occurrence and order of events, but not about time conditions. Introducing time-related patterns allows the specification of real-time requirements.

One of the important tasks during software testing is the generation of test cases. Various approaches have been proposed to automate this task. The approaches available, however, often have problems limiting their use. A problem of dynamic test case generation approaches, for instance, is that a large number of iterations can be necessary to obtain test cases. This article proposes a novel algorithm for path-oriented test case generation based on binary search and describes a possible implementation.

Most techniques proposed for regression testing are either black- or white-box techniques, i.e. they solely consider either the specification or implementation of a program. However a combined technique can lead to significant savings in testing costs as some testing tasks need to be carried out once. Furthermore, the same test cases can cover both specification and implementation, reducing the total number of test cases. This paper shows the application of class specification implementation graphs (CSIGs) in regression testing. The distinguishing feature of CSIGs front existing representations is that each method of a class is shown from two perspectives, namely the specification and implementation view. Moreover a test suite reduction strategy has been incorporated to the CSIG construction algorithm to decrease the total number of test cases required. In this paper we show how CSIGs can be combined with an existing test case selection algorithm for regression testing.

The main idea of component-based development is to use existing components for building software. The resulting software often has features which complicate testing, such a feature is, for example, the absence of component source code. This article proposes an approach for testing, which explicitly takes into account testing-relevant features of component-based software and thus allows more rigorous testing. The basic constituent of the approach is a graphical representation combining black- and white-box information from specification and implementation, respectively. This graphical representation can then be used for test case identification based on well-known structural techniques.

In recent years, several techniques have been proposed for class-level regression testing. Most of these techniques focus either on white- or black-box testing, although an integrated approach can have several benefits. As similar tasks have to be carried out for both white- and black-box testing, an integrated approach can improve efficiency and cost effectiveness. The article explains an approach for class-level regression testing, integrating existing techniques. Particularly, those of Rothermel et al. (2000) and Hong et al. (1995) for white-box regression testing and black-box testing, respectively, have been integrated into a single technique. The benefits of the resulting technique are shown by example.

Although both black- and white-box testing have the same objective, namely detecting faults in a program, they are often conducted separately. In our opinion, the reason is the lack of techniques and tools integrating both strategies, although an integration can substantially decrease testing costs. Specifically, an integrated technique can generate a reduced test suite, as single test cases can cover both specification and implementation at the same time. The paper proposes a new graphical representation of classes, which can be used for integrated class-level black-and white-box testing. Its distinguishing feature from existing representations is that each method of a class is shown from two perspectives, namely the specification and implementation view. Both the specification of a method and its implementation are represented as control flow graphs, which allows black- and white-box testing by structural techniques. Moreover, a test suite reduction technique has been developed for adjusting white-box test cases to black-box testing.

Software vendors rarely acknowledge their debt to research, indeed often are unaware of it, and rarely even appreciate the importance of such acknowledgement. The long lead times, and tortuous adoption paths, for software engineering research contributions also cloud perception of the actual source of popularly adopted software engineering technologies.

We present an approach to the development of software systems supporting electronic commerce. The basic idea of this approach is to develop systems of this kind, called electronic commerce applications (ECAs), following a process-oriented approach. This means that first we model the processes to be supported by an ECA. Our emphasis is on the specification of the communication interfaces between process parts which take place at different sites. In a second step we use these specifications to simulate the behavior of distributed processes and to implement the software needed for the support of the specified ECA.

No abstract available.

A user-defined telecooperation service (UTS) provides service elements for application-specific communication and cooperation processes as well as integrated means for the service definition, adaptation, and management. It supports user groups with particular communication, cooperation, and coordination needs which may change over time and which may be that special, that the service maintenance can be carried out only by the users themselves in an economic and satisfactory way. The users may be organized in various open and closed groups. They dispose of personal computing equipment connected via wide-area telecommunication networks. The users participate only from time to time. Therefore, there is a partial and varying accessibility of users and user sites. Interactions are mainly based on asynchronous communication operations. The cooperation and coordination functions have to consider unreachable users. The paper introduces the notion of UTS. Fields of application are addressed. Moreover, we describe the principles of the service element definitions and outline the architecture of a supporting system.

Workflow management is an area of increasing interest. Nonetheless there are only a few workflow systems which are actually used for supporting business processes in an industrial context. Most of these systems only deal with processes which create and manipulate unstructured pieces of information, like documents and images. Our workflow management approach, called the FUNSOFT net approach, additionally supports the management of structured pieces of information, called objects. In doing so, we use a repository which is used to store information about process models and about individual processes. This repository is particularly useful for processes dealing with highly structured information, such as software processes. We describe the experience in using such a repository. We point out which of these experiences may be useful for developers of other workflow management systems as well.

The paper provides an overview of process research and the application of research results to practice and then describes process models using FUNSOFT nets and a workflow management system LEU. The example from which the experience is drawn is that of a problem tracking system and the components of the model are described and illustrated. The experience reported comes in three flavors: the appropriateness of FUNSOFT nets as a modeling mechanisms and the alternative use of state transition diagrams; the benefits of the model and its support of the business process; and finally some implications for process research.

No abstract available.

Workflow management systems/business process management systems (BPMS) provide for an integral support of computer-based information processing, personal activities, business procedures and their relationships to organizational structures. They support the modeling and analysis of so-called business processes and offer means for the application-near design and implementation of computer-based business process assistance. Mainly, the BPMSs concentrate on the support of enterprise-internal processes. Our approach extends the scope of business process management. Enterprise-internal processes are viewed as sub-processes of global inter-enterprise processes. Additional global process assistance is based on the definition of global activity models and global information models. Features of dynamic naming and binding can be provided by business process brokers, which extend the concepts of object trading to the trading of opportunities to participate in global processes.

The article describes how software process management could be improved by integration of development history recording. This idea is based on the observation that software process management focuses on activity patterns to be enforced, while the dependences between documents and document parts produced in these activities are not considered. As a complement to that perspective, development history recording pays emphasis to the dependencies between documents. These dependencies are managed to find out whether or not documents are complete, transitively dependent, or related in other ways. Our approach is to combine both perspectives to enforce that software processes follow prescribed patterns and to manage dependencies between documents in order to ensure high quality software.

Most of today’s approaches to business process engineering (also called business process management) start from an activity-centered perspective. They describe activities to be carried out within a business process and their relationships, but they usually pay little attention to the objects manipulated within processes. In this article, we discuss an approach to business process modeling, model analysis, and business process enaction (also called workflow management) which is based on data modeling, activity modeling, and organization modeling. In fact, the ℒeu approach to business process management considers data models (describing types of objects to be manipulated in a business process and their relationships), activity models (describing activities to be carried out in a business process), and organization models (describing organizational entities involved in a business process) as separate, but equally important, facets of business processes.

Software processes are usually described by guidelines and advices. These guidelines are claimed to be valid for many projects. This understanding leads to software processes which deviate from initial plans and which frequently yield insufficient results. System-atic management of software processes can help to overcome these shortcomings. In this paper, we introduce an incremental approach to software process management. This approach covers the complete life-cycle of software process models, i.e., it deals with software process modeling, software process model analysis, and software process model enaction. It is based on a net-based software process modeling language called FUNSOFT nets. FUNSOFT nets are high-level Petri nets adapted to the application domain of software process management. We model software processes by means of different views onto a software process model. Our approach is implemented in a software process management environment called MELMAC.