Search

Software engineers routinely use sketches (informal, ad-hoc drawings) to visualize and communicate complex ideas for colleagues or themselves. We hypothesize that sketching could also be used as a novel interaction modality in integrated software development environments (IDEs), allowing developers to express desired source code manipulations by sketching right on top of the IDE, rather than remembering keyboard shortcuts or using a mouse to navigate menus and dialogs. For an initial assessment of the viability of this idea, we conducted an elicitation study that prompted software developers to express a number of common IDE commands through sketches. For many of our task prompts, we observed considerable agreement in how developers would express the respective commands through sketches, suggesting that further research on a more formal sketch-based visual command language for IDEs would be worthwhile., Icelandic Research Fund (grant no. 196228), Post-print

A wide variety of Remote Sensing (RS) missions are continuously acquiring a large volume of data every day. The availability of large datasets has propelled Deep Learning (DL) methods also in the RS domain. Convolutional Neural Networks (CNNs) have become the state of the art when tackling the classification of images, however the process of training is time consuming. In this work we exploit the Layer-wise Adaptive Moments optimizer for Batch training (LAMB) optimizer to use large batch size training on High-Performance Computing (HPC) systems. With the use of LAMB combined with learning rate scheduling and warm-up strategies, the experimental results on RS data classification demonstrate that a ResNet50 can be trained faster with batch sizes up to 32K.

We observe a continuously increased use of Deep Learning (DL) as a specific type of Machine Learning (ML) for data-intensive problems (i.e., ’big data’) that requires powerful computing resources with equally increasing performance. Consequently, innovative heterogeneous High-Performance Computing (HPC) systems based on multi-core CPUs and many-core GPUs require an architectural design that addresses end user communities’ requirements that take advantage of ML and DL. Still the workloads of end user communities of the simulation sciences (e.g., using numerical methods based on known physical laws) needs to be equally supported in those architectures. This paper offers insights into the Modular Supercomputer Architecture (MSA) developed in the Dynamic Exascale Entry Platform (DEEP) series of projects to address the requirements of both simulation sciences and data-intensive sciences such as High Performance Data Analytics (HPDA). It shares insights into implementing the MSA in the Julich Supercomputing Centre (JSC) hosting Europe No. 1 Supercomputer Julich Wizard for European Leadership Science (JUWELS). We augment the technical findings with experience and lessons learned from two application communities case studies (i.e., remote sensing and health sciences) using the MSA with JUWELS and the DEEP systems in practice. Thus, the paper provides details into specific MSA design elements that enable significant performance improvements of ML and DL algorithms. While this paper focuses on MSA-based HPC systems and application experience, we are not losing sight of advances in Cloud Computing (CC) and Quantum Computing (QC) relevant for ML and DL.

Similarly to other scientific domains, Deep Learning (DL) holds great promises to fulfil the challenging needs of Remote Sensing (RS) applications. However, the increase in volume, variety and complexity of acquisitions that are carried out on a daily basis by Earth Observation (EO) missions generates new processing and storage challenges within operational processing pipelines. The aim of this work is to show that High-Performance Computing (HPC) systems can speed up the training time of Convolutional Neural Networks (CNNs). Particular attention is put on the monitoring of the classification accuracy that usually degrades when using large batch sizes. The experimental results of this work show that the training of the model scales up to a batch size of 8,000, obtaining classification performances in terms of accuracy in line with those using smaller batch sizes.

Powerful software tools, such as software development environments, often have complex graphical user interfaces (GUIs) that are not intuitive to handle, especially when performing complex, multi-step operations. We hypothesize that sketching could be a more intuitive way of expressing user intentions than navigating nested menus or memorizing keyboard shortcuts to accomplish complex operations. Enabling this vision requires software capable of both allowing the user to sketch anywhere on a GUI, and interpreting those sketches as specific commands to be performed within the integrated development environment (IDE). In this paper, we report on preliminary results of an elicitation study performed to gather insights into how developers would use a sketch-based interface., Icelandic Research Fund (grant no. 196228), Post-print

Polar stratospheric clouds (PSC) play a key role in polar ozone depletion in the stratosphere. Improved observations and continuous monitoring of PSCs can help to validate and enhance chemistry-climate models that are used to predict the evolution of the polar ozone hole. Here we present the results of our study in which we explored the potential of applying machine learning (ML) methods to classify PSC observations of infrared limb sounders. Two datasets have been considered. The first dataset is a collection of infrared spectra captured in Northern Hemisphere winter 2006/2007 and Southern Hemisphere winter 2009 by the Michelson Interferometer for Passive Atmospheric Sounding (MIPAS) instrument onboard ESA's Envisat satellite. The second dataset is the cloud scenario database (CSDB) of simulated MIPAS spectra. We first performed an initial analysis to assess the basic characteristics of these datasets and to decide which features to extract from them. More than 10,000 Brightness temperature differences (BTDs) features have been generated and fed as input to the ML methods instead of directly using the infrared spectra. Next, we assessed the use of ML methods for the reduction of the dimensionality of this large feature space using principal component analysis (PCA) and kernel principal component analysis (KPCA) as well as the classification with the random forest (RF) and support vector machine (SVM) techniques. All methods were found to be suitable to retrieve information on the composition of PSCs. Of these, RF seems to be the most promising method, being less prone to overfitting and producing results that agree well with established results based on conventional classification methods.

With the advent of large interactive displays and the increasing ubiquity of touch-enabled devices, digital sketching tools are becoming viable alternatives to classic whiteboards for the design and engineering of software systems. In this paper, we argue that current sketching tools still focus largely on creating sketches as artifacts (mostly, models), rather than recognizing sketches as byproducts of engineers' thought processes as they tackle a broad variety of complex engineering activities. We therefore advocate a more activity-than artifact-oriented view of sketching and propose research on a number of ways in which digital sketching can support cognitively demanding software engineering activities more directly.

This paper compares three multi-national research infrastructures, one that provides data services, one that provides compute services, and one that supports linguistics research. The aim is to jointly provide services to the user communities, and, perhaps eventually, seamlessly interoperate. To this end, we look at and compare how the infrastructures build their service federations (trust, service status, information systems), and how they manage users (identities, authentication, and authorisation).

Complex software projects typically involve stakeholders from a variety of backgrounds that bring a variety of goals and expectations, but also valuable knowledge to the project. To facilitate communication and cooperation in such heterogeneous, interdisciplinary teams, we previously introduced the Interaction Room, a consulting method that uses large whiteboards to help stakeholders identify the key risk, value and effort drivers of their projects early. In this paper, we describe drawbacks of the original Interaction Room approach and show how a digitally augmented version of the method, relying on large interactive displays, was designed to improve the quality of the discussion, the long-term impact of the insights, and the inclusion of remote stakeholders. The Augmented Interaction Room is an example of how digitization can not only improve existing consulting methods, but also produce new insights and ways of collaborating with clients.

The design, development and deployment of scientific computing applications can be quite complex as they require scientific, High-Performance Computing (HPC), and software engineering expertise. Often, HPC applications are however developed by end users who are experts in their scientific domain, but need support from a supercomputing centre for the engineering and optimization aspects. The cooperation and communication between experts from these quite different disciplines can be difficult though. We therefore propose to employ the Interaction Room, a technique that facilitates interdisciplinary collaboration in complex software projects., This project has received funding from the European Union’s Horizon 2020 research and innovation programme under the Grant Agreement No. 754304 DEEP-EST., Peer Reviewed Camera Ready

The development of high performance computing applications is considerably different from traditional software development. This distinction is due to the complex hardware systems, inherent parallelism, different software lifecycle and workflow, as well as (especially for scientific computing applications) partially unknown requirements at design time. This makes the use of software engineering practices challenging, so only a small subset of them are actually applied. In this paper, we discuss the potential for applying software engineering techniques to an emerging field in high performance computing, namely large-scale data analysis and machine learning. We argue for the employment of software engineering techniques in the development of such applications from the start, and the design of generic, reusable components. Using the example of the Juelich Machine Learning Library (JuML), we demonstrate how such a framework can not only simplify the design of new parallel algorithms, but also increase the productivity of the actual data analysis workflow. We place particular focus on the abstraction from heterogeneous hardware, the architectural design as well as aspects of parallel and distributed unit testing.

Large drawing boards have long been software engineers' tools of choice for collaborative software design. Recently, traditional design tools such as whiteboards and flip charts are being replaced by large interactive surfaces such as touch-sensitive wall-mounted displays or interactive tabletops. This workshop explores the novel opportunities that these interactive modeling tools offer for collaborative software engineering, as well as the technical and cognitive challenges that they introduce.

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.

This chapter concludes the book by formulating twelve hypotheses that give an outlook on how enterprise IT is changing. This change is not triggered by one single megatrend, buzzword, or idea. Rather, numerous developments are intertwining, jointly causing fundamental change in how business and IT work together and define each other.

This chapter defines the aim of the Interaction Room—fostering understanding between stakeholders and focusing their communication on those aspects that are critical to the success of a project—and describes key principles that shape the Interaction Room method. These principles include for example involving domain experts, favoring relevance over completeness, favoring clarity over precision, defining value and effort drivers, managing late as well as early requirements, revealing uncertainties early, making cost changes transparent, and building trust between stakeholders.

This chapter describes how an Interaction Room is used in the initial phase of a software development project in order to help business and technical stakeholders to understand both the application domain and the technical constraints of the system under development. The chapter shows how the feature canvas is used to gain an overview of the projects’ requirements, how the process canvas is used to sketch relevant business processes, how the object canvas is used to map out relevant business objects, and how the integration canvas is used to identify interfaces to surrounding systems. The chapter concludes with an outlook on how the insights gained in the IR:scope can drive a follow-up software development project.

This chapter describes how an Interaction Room is used to keep track of the progress, the risks, and the cost of an ongoing software project. It describes how the insights gained in an Interaction Room support estimation and prioritization of features in sprint planning workshops, how the requirements exchange can help to deal with late requirements without exceeding the project’s budget and schedule, how the risk map helps stakeholders to stay aware of aspects that may jeopardize the project, and how cost forward progressing is used to continually forecast the project’s effort based on the team’s performance.

This chapter describes how an Interaction Room is used to evaluate the disruptive and constructive potential of novel technologies (such as big data analysis) for an organization’s business and its IT. The chapter shows how the feature canvas is used to identify relevant features of a system or business that are affected by novel technologies, and how the process, object, and integration canvases are used to examine opportunities for restructuring and optimization brought about by novel technologies. The chapter concludes with an outlook on how the insights gained in the IR:tech can spark follow-up projects in which the organizations’ business and IT is refactored based on identified technology innovations.

This chapter highlights the mismatch between agile practices and traditional software delivery contracts. A higher degree of trust and communication between client and supplier is required by contracts that reflect agile principles, since both parties share a responsibility for eliminating risks and uncertainties, and working efficiently toward successful project completion. The chapter sets up a framework for characterizing contract models by project character and model of cooperation that will be used to discuss different approaches to traditional and agile contracting in the following chapters.

This chapter describes how an Interaction Room is used in the early phases of digitalization initiatives in order to identify an organization’s digitalization potential and to identify candidates for concrete digitalization projects that should be pursued. The chapter shows how the partner canvas is used to gain an overview of the involved stakeholders, how the physical object canvas is used to identify key objects of interest, and how the touchpoint canvas is used to analyze customer journeys that would benefit from digitalization. The chapter concludes with an outlook on how the insights gained in the IR:digital can spark follow-up IT project scoping activities.

This chapter introduces the context for the case study that will be described in the following chapters to illustrate the use of the Interaction Room in a large-scale software development project, namely the development of the Cura health insurance benefit system. The chapter briefly describes the application domain in which this system operates, as well as the background against which the project took place.

This chapter describes how the insights gained in the Cura project’s inception using the IR:scope were carried into the project’s execution. It also shows how the techniques of the IR:agile and the adVANTAGE contract model were used to plan sprints, monitor risks, bill features, and forecast efforts as the project progressed.

This chapter motivates the need for a more “tamed” agile contract model that reflects agile project practices while balancing risks fairly. It describes the principles underlying the adVANTAGE contract model—a commitment to agility, mutual trust between the contract parties, both parties’ willingness to assume risk, and incentive to work efficiently toward lean software.

This chapter gives a brief overview of traditional contract principles (starting from a discussion of why contracts are important and necessary in the first place) and focuses on the challenges that arise when trying to apply these to agile projects. In this light, the chapter discusses fixed price contracts, time and materials contracts as well as pay-per-use contracts. The discussion shows the need for contract models that are more reflective of agile practices, and reconcile the customers’ and suppliers’ risk-containment needs.

In the rehabilitation management domain, we find many situations where actors have to manage complex cases. To facilitate patients’ quick recovery from their individual conditions, case managers need a high degree of flexibility in organizing their tasks. Unfortunately, giving them complete flexibility is challenging for two reasons: Firstly, process owners may want to tame the flexibility to conform with compliance policies. Secondly, without complete information about the possible processes in the problem domain, software engineers are struggling to design information systems that can support these case management processes effectively. In this paper, we will therefore show how semantic web technologies can complement adaptive case management techniques in order to cope with the cases’ flexibility. Following the ideas of linked data and the open-world assumption, these techniques facilitate (1) a data structure that is easily extendable, (2) data quality improvements, and (3) the definition and checking of business rules using domain concepts. As a proof of concept, we integrated the method into a case management tool and conducted a small case study using real-life examples from the rehabilitation domain.

This chapter illustrates how to implement the adVANTAGE model in practice using the example of an actual project that was negotiated and executed following the principles and procedures described in the previous chapters. The chapter also discusses how the parameters of the contract model should be fine-tuned to accommodate different project situations.

This chapter gives an overview of more flexible contract models that have been proposed in various domains, and examines their applicability to agile software development. The chapter discusses fixed price per iteration and fixed price per point models, the “money for nothing, change for free” model and the “shared pain/shared gain” model, as well as multi-stage contract models. In discussing these models, the chapter specifically takes into account the constraints and motivations that customers may be bound by, and the mechanisms that the different contract models provide to assign risk to the contract parties.

This chapter describes how an Interaction Room is used in the development of mobile applications, helping business and technical stakeholders leverage the unique features of mobile devices in order to generate a user experience (UX) that is tailored as closely as possible to the users’ needs. The chapter shows how the persona canvas is used to understand the different groups of users that will work with the application, how the portfolio canvas is used to analyze the market in which the mobile application will compete, how the touchpoint canvas is used to identify points in the customer journey that are particularly suitable for mobile support, and how the interaction canvas can be used to sketch the UX of the mobile application. The chapter concludes with an outlook on how the insights gained in the IR:mobile can drive a follow-up mobile software development project.

This chapter discusses the skill set that today’s IT projects require beyond pure technical competence: the pragmatic consideration of established practices, the ability to communicate and collaborate openly and effectively across disciplines, an awareness of one’s own uncertainty and limits of understanding, and the ability to focus on those system aspects that provide the most value to the customer. Besides general software technology and methodology skills, the chapter in particular focuses on skills related to dealing with the challenges introduced by mobility, agility, and flexibility of applications, as well as the increasing need for in-depth domain knowledge.

Software processes have to be flexible in order to handle a wide range of software project types and complexities. Large companies that depend on custom-built software may therefore define different software processes in order to adapt to different recurring project contexts (e.g., hot-fix versus migration projects). However, the stakeholders do not always follow the intended “happy path”—not the least because any software project typically has to deal with a considerable amount of uncertainty. Following an agile process may not be possible due to a company’s culture or policy restrictions (e.g., in the healthcare or financial domain) though. In this chapter, we present an approach to introduce more flexibility into software process models by adapting case management techniques to the domain of flexible software process management, in order to cope with key issues that come with software process evolution. Key functionalities of the approach have been implemented in a prototype and showcased to developers and architects via a live experiment. The feedback is promising as it shows that the approach helps to quickly identify context-specific actions and artifacts. This in turn reduces effort in structuring the daily work of software process stakeholders in an environment of evolving process elements specific to different kinds of projects, roles, and technologies.

In recent years, investigating opportunities to support knowledge-intensive business processes has gained increasing momentum in the research community. Novel contributions that introduce paradigms addressing the need for process execution flexibility form an alternative to traditional workflow management approaches and are mostly subsumed under the concept of adaptive case management (ACM). However, many of these approaches omit mining any kind of knowledge about such processes. This is because there is a gap between process mining, which works well for structured processes, and ACM, which mainly focuses on information system support for task management and collaboration using heterogeneous data sources. In this paper, we strive to bridge this gap by introducing a method for mining knowledge-intensive processes. It is part of agenda-driven case management, an ACM approach that follows the idea of mining common execution patterns while a case manager handles a flexible agenda.

ContextThe planning, estimation and controlling mechanisms of agile process models rely significantly on a fixed set of tasks being established for each sprint. These tasks are created as refinements of product backlog items at the beginning of each sprint. However, a project team's understanding of the backlog items' business implications and dependencies may often not be deep enough to identify all necessary tasks this early, so in addition to the tasks defined in the beginning of the sprint, more necessary tasks might be discovered as the sprint progresses, making any attempt at progress estimation or risk management difficult. ObjectiveWe strive to enable software teams to achieve a deeper understanding of product backlog items, which should help them to identify a sprint's tasks more reliably and comprehensively, and avoid discovering the need for extra tasks during sprint execution. MethodWe introduced a project team in a medium-sized software development company to the Interaction Room method, which encourages interdisciplinary communication about key system design aspects among all stakeholders. We observed the team's conduct in the sprint planning meetings, and tracked early- vs. late-identified tasks across several sprints. ResultsBefore the introduction of our method, the team used to discover on average 26% of a sprint's tasks not at the beginning of the sprint, but later during the course of the sprint. Using the Interaction Room in two separate projects, this ratio dropped to an average of 5% late-discovered tasks. ConclusionOur observations from these projects suggest that increased communication among all stakeholders of a project leads to a more reliable identification of the tasks to be performed in a sprint, and that an Interaction Room can provide appropriate guidance to conduct this team communication in a focused and pragmatic way.

One of the main goals of process mining is to automatically discover meaningful process models from event logs. Since these logs are the essential source of information for discovery algorithms, their quality is of high importance. In recent years, many studies on the quality of resulting process models have been conducted. However, the analysis of event log quality prior to the generation of models has been neglected. For example, yet there are no metrics which can measure the degree of event log quality that is needed so that discovery algorithms can be applied. Especially in the context of case management (CM) where processes are less structured, complex event logs reduce the effectiveness of the process discovery. In order to avoid mining impractical "spaghetti processes", it would be convenient to measure the event log complexity prior to discovery steps. In this paper, we provide our research results concerning the design and applicability of such metrics. First of all, they shall help to indicate whether the event log quality is sufficient for traditional process discovery. In case of very poor quality, they indicate the demand for more agile techniques (e.g. adaptive CM or agenda-driven CM).

In a large industry project that followed an agile approach based on the Scrum method, we found that the team often struggled with breaking coarse product backlog items down into the detailed tasks that had to be completed in a sprint. The team's understanding of the backlog items' business and technical implications and dependencies seemed not deep enough to identify all necessary tasks, so in addition to the tasks defined in the sprint planning meeting prescribed by Scrum, an average of 26% of additional tasks was identified later over the course of each sprint, making any attempt at progress estimation or risk management very difficult. To counter this effect and support the team's understanding of backlog items right from the beginning of each sprint, we introduced a pragmatic method to analyze backlog items more comprehensively and thus support a more complete and reliable task breakdown. We consequently found that the effectiveness and precision of task breakdowns has improved significantly in the project.

Contributing to a Free, Libre and Open Source Software (FLOSS) project is not a trivial task even for experienced developers: Beyond the effort required for understanding and editing a project's source code for one's own purposes, submitting the changes back to the community requires additional motivation, time, and social and technical effort. Although several surveys have examined the dynamics driving FLOSS contributors, most focus either on the motivations of core developers or indicators of potential long-term commitment, i.e. the small but quite involved and visible minority at the core of a project. Our survey in contrast examines the experiences of the much larger, but nearly invisible group of developers who are just making and submitting their first patch, and identifies barriers that hinder or even prevent them from making a valuable contribution.

It is often difficult for a team of stakeholders with heterogeneous backgrounds to maintain a common understanding of a system’s structure and the challenges in its implementation. Thus, especially in complex software projects, risks and inconsistencies are easily overlooked. In this paper, we present the concept of an Augmented Interaction Room (AugIR), i.e. a physical team room whose walls are outfitted with wall-sized touchscreens that visualize different aspects of a software system in the form of various model sketches. These sketches can be annotated by the stakeholders in order to explicitly mark important elements or indicate aspects that are critical for project success. The AugIR strives to support the collaborative work of heterogeneous teams and especially targets the inclusion of non-technical stakeholders into the communication process. Therefore, the AugIR continuously monitors the stakeholders’ design and modeling activities and analyzes the relationships between annotated contents to automatically uncover inconsistencies, contradictions and hidden potential project risks.

In recent years, mature workflow management technology has become available to support enterprises in engineering and executing well-known business processes. But in the domain of case management, no strict process can be prescribed for tasks due to their high variability. Rather, these tasks require the expertise of case managers who work with information from many different sources. We believe that such processes will benefit from an agenda-driven case management approach. However, implementing an information system supporting such an approach is challenging since it impacts and relies on many aspects of an enterprise's way of handling heterogeneous data. In this paper, we discuss requirements and design decisions arising from the adCM concept and present the results in implementing a corresponding support system.

The maintenance and evolution of legacy applications and legacy data structures poses a significant challenge for many organizations that rely on large-scale information systems, e.g. in the financial services domain: Not only is the budget for modernizations that add more technical stability and flexibility than business functionality often slim, but it is also difficult to understand and design the best migration strategies for a large and organically grown system landscape. We report on the experiences from a migration project at a large bank that pursued a value-based approach, in which migration efforts were first focused on a small set of business processes that were identified as most crucial for the enterprise. The migration strategies developed and validated in this pilot phase could later be successfully applied to the larger system landscape.

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 maintenance and evolution of legacy applications and legacy data structures poses a significant challenge for many organizations that rely on large-scale information systems, e.g. in the financial services domain: Not only is the budget for modernizations that add more technical stability and flexibility than business functionality often slim, but it is also difficult to understand and design the best migration strategies for a large and grown system landscape. We report on the experiences from a migration project at a large bank that pursued a value-based approach, in which migration efforts were first focused on a small set of business processes that were identified as most crucial for the enterprise. The migration strategies developed and validated in this pilot phase could later be successfully applied to the larger system landscape.

Large-scale information system evolution projects often place high demands on both business and technical stakeholders' cognitive and communication skills. Especially if the need for evolution is not confined to a particular feature, but affects the whole value chain, finding dependencies and interrelationships between processes and components is challenging as it requires cross-departmental understanding. These issues can be even more challenging for management stakeholders who need to make high-level and far-reaching decisions on implementation strategies despite not being deeply involved in the technical details. One of the main problems in such projects is that the stakeholders who have expert knowledge typically have only little methodical experience, while the method experts lack the business experience. In this paper, we report on experiences and lessons from a large systems evolution project in a German insurance company, where we applied a new approach -- the so-called "Interaction Room" -- to improve stakeholders' understanding of the project's risks and dependencies in a pragmatic way, without overwhelming them with a heavyweight analysis method.

Mobile systems are determined by requirements which tend to change over time. Agile approaches seem to address this, but fail to provide reliable project plans, budget estimations and capacity forecasts. Thus, mobile enterprise applications demand for tamed agility, reconciling advantages of agile development and plan-driven approaches. In this paper, this tradeoff is addressed. The Interaction Room method is introduced as a low-tech method to support value-oriented development of mobile applications.

In many domains, there are tasks for which no strict process can be prescribed, but which require the expertise of case managers who work with information from a broad set of sources. To support case managers’ highly individual work, we present an approach that enables them to structure their work along a flexible agenda and a diverse collection of artifacts. We propose a cloud-based architecture for annotating artifacts with document- and content-level metadata to support case managers’ cognitive effort of organizing, relating and evaluating the multitude of artifacts involved in each case, and describe a tool that provides a consolidated environment for working with artifacts from heterogeneous sources.

Web applications are subject to an interaction challenge not found in other user interfaces: In addition to the widgets that web pages are built of, browsers provide further navigation features such as the Back and Forward buttons that are beyond the developer's control. Continuations have been suggested as a means to cope with the arbitrary navigation patterns that users may perform using these features. While an elegant solution in theory, continuations can incur a significant memory load in practice, and may offer more navigation options than business requirements mandate. We therefore propose a dialog control logic that augments the continuation approach with strategies for automatic elimination of continuations that will likely not be needed anymore, or whose invocation shall be prevented due to business requirements. This way, we aim to realize the benefits that continuations can provide to web applications, while ameliorating the drawbacks that they exhibit in practice. Continuations are used to cope with unforeseen user navigation in web applications.However, their management can incur significant memory overhead under heavy load.We present mechanisms for pruning continuation trees based on the dialog structure.This also prevents users from backtracking into completed transactions through the GUI.Depending on the structure of the dialogs, this enables significant memory savings.

In many domains, we find tasks for which no strict process can be prescribed, but which require the expertise of case managers who work with information from a broad set of sources. To support case managers' highly individual work in such so-called "process clouds", we present an approach that enables them to structure their work along any suitable mix of keywords, activities and artifacts.

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.

Agile software development methods are harder to adopt by third-party software developers than by in-house software development teams, since traditional contractual frameworks can easily lead to unfair risk distributions between client and supplier when applied to agile projects. We therefore present a pricing model for agile software projects that distributes risks evenly between the partners, and encourages efficient, high-quality contributions on both sides.

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.

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.