Abstract Background Interruptions at inopportune moments can negatively affect the perceived productivity of software developers. Previous research has attempted to predict the interruptibility of software developers using biophysical data to minimize interruptions at such moments. Aims First, we sought to replicate the results of a well-known study that predicted the interruptibility of software developers with high accuracy in lab and field settings. Second, we provide a comprehensive and publicly available lab package to facilitate future replications. Method We conducted an external close replication of the original lab study. As such, we held ten one-on-one sessions in which participants were asked to perform three code change tasks during a 60-minute programming session while frequently interrupted by a tablet application and monitored by selected biometric sensors. The biophysical data were used to derive predictive (classification) models. Results We cannot replicate models that significantly improve over the baseline of a majority classifier. Furthermore, we identify three severe threats to validity: a small sample size, a highly imbalanced dataset, and an ad hoc transformation of a critical measurement scale. Conclusions The original results did not generalize to our more varied setting (e.g., participant profile). We recommend only conceptually replicating the original study.

The usage of domain-specific languages (DSLs) is an approach to reduce complexity in software development by expert developers for selected application domains. To support expert developers, a DSL is often combined with a tailored, domain-specific developer tool, offering similar functionality as general-purpose programming environments (IDEs like Eclipse for Java) while integrating with a domain-specific toolchain (e.g., code or documentation generators, simulators). General-purpose development environments have been successfully evaluated for the programmer experience (PX) and for anomalies using heuristic walkthroughs as a mixed review technique combining cognitive walkthroughs and a heuristic evaluation. In this paper, we report on the usefulness and acceptance of heuristic walkthroughs as an PX evaluation technique applied to domain-specific languages and IDEs in an industry context. Heuristic walkthroughs are used in four interventions (field simulations) to assess the programming experience and usability of domain-specific, Eclipse-based IDEs in a concrete industry setting. Data on the usefulness and acceptance (perceived satisfaction) of the walkthroughs themselves are collected and analysed. Our studies show that, in practice, the instrument of walkthroughs is useful for revealing practically relevant PX anomalies, while maintaining acceptance by practitioners participating in the walkthroughs. The documented variant of heuristic walkthroughs is eligible to become adopted for future field studies in academic research and for evaluation projects in industry, in support of developing domain-specific developer tooling in an evidence-driven manner.

Variability models are often enriched with attributes, such as performance, that encode the influence of features on the respective attribute. In spite of their importance, there are only few attributed variability models available that have attribute values obtained from empirical, real-world observations and that cover interactions between features. But, what does it mean for research and practice when staying in the comfort zone of developing algorithms and tools in a setting where artificial attribute values are used and where interactions are neglected? This is the central question that we want to answer here. To leave the comfort zone, we use a combination of kernel density estimation and a genetic algorithm to rescale a given (real-world) attribute-value profile to a given variability model. To demonstrate the influence and relevance of realistic attribute values and interactions, we present a replication of a widely recognized, third-party study, into which we introduce realistic attribute values and interactions. We found statistically significant differences between the original study and the replication. We infer lessons learned to conduct experiments that involve attributed variability models. We also provide the accompanying tool Thor for generating attribute values including interactions. Our solution is shown to be agnostic about the given input distribution and to scale to large variability models.

Much attention is paid nowadays to software architecture of a system as a set of design decisions providing the rationale for the system design. To document and share proven architectural design decisions, decisions made in concrete development projects are mined and distilled into reusable architectural decision models (a.k.a. guidance models). The available distillation approaches, however, remain ad hoc and biased towards the personal experience of few expert architects. Relationships between distilled decisions are not systematically explored. We propose an approach for distilling reusable architectural design decisions with emphasis on their relationships. Architectural knowledge artifacts (e.g., architecture documentation, interviews) are systematically coded for the occurrence of architectural design decisions and their details. Co-occurrences of coded design decisions are then processed for different relationship types using an established data-mining technique: frequent item-sets. The distilled relationships enter the construction of a reusable architectural decision model and contribute to organizing the design space based on empirical data (i.e., frequency patterns of co-occurrences). We report on distilling design-decision relationships from decision data collected during a three-year project on language architectures of 80 UML-based domain-specific modeling languages.

Abstract: The core language model is a central artifact of domain-specific modeling languages (DSMLs) as it captures all relevant domain abstractions and their relations. Natural-language scenarios are a means to capture require-ments in a way that can be understood by technical as well as non-technical stakeholders. In this paper, we use scenarios for the testing of structural properties of DSML core language models. In our approach, domain experts and DSML engineers specify requirements via structured natural-language scenarios. These scenario descriptions are then automatically transformed into executable test scenarios providing forward and backward traceability of domain requirements. To demonstrate the feasibility of our approach, we used Eclipse Xtext to implement a requirements language for the definition of semi-structured scenarios. Transformation specifica-tions generate executable test scenarios that run in our test platform which is built on the Eclipse Modeling Framework and the Epsilon language family. 1

Abstract: Domain-specific modeling languages (DSMLs) are commonly used in model-driven development projects. In this context, model-to-text (M2T) transformation templates generate source code from DSML models. When integrating two (or more) DSMLs, the reuse of such templates for the composed DSML would yield a number of benefits, such as, a reduced testing and maintenance effort. However, in order to reuse the original templates for an integrated DSML, potential syntactical mismatches between the templates and the integrated metamodel must be solved. This paper proposes a technology-independent approach to template rewriting based on higher-order model transformations to address such mismatches in an automated manner. By considering M2T generator templates as first-class models and by reusing transformation traces, our approach enables syntactical template rewriting. To demonstrate the feasibility of this rewriting technique, we built a prototype for Eclipse EMF and Epsilon. 1

This paper presents an approach for incorporating data integrity and data confidentiality into the model-driven development (MDD) of process-driven service-oriented architectures (SOAs) based on the OMG SoaML. Specifications for service interfaces are extended by UML activities to model invocation protocols. An invocation protocol makes the control and the object flows between service invocations explicit. Integrity and confidentiality attributes are used to annotate the object flows. The annotations serve for generating security-aware execution artefacts (e.g., interface description documents, deployment descriptors, and middleware configurations). We applied the approach prototypically in a Web Services platform environment (WS-BPEL, WSDL, WS-Security Policy).

Embedded, textual DSLs are often provided as an API wrapped around object-oriented application frameworks to ease framework integration. While literature presents claims that DSL-based application development is beneficial, empirical evidence for this is rare. We present the results of an experiment comparing the complexity of three different object-oriented framework APIs and an embedded, textual DSL. For this comparative experiment, we implemented the same, non-trivial application scenario using these four different APIs. Then, we performed an Object-Points (OP) analysis, yielding indicators for the API complexity specific to each API variant. The main observation for our experiment is that the embedded, textual DSL incurs the smallest API complexity. Although the results are exploratory, as well as limited to the given application scenario and a single embedded DSL, our findings can direct future empirical work. The experiment design is applicable for similar API design evaluations.

This case study summarizes the demonstration of a semantic network of interoperable educational systems referred to as Smart Space for Learningtrade. We started connecting several educational nodes in projects such as Elena, Prolearn, and Icamp. Integration was achieved by using the interaction standard SQI, common schemas for querying and results presentation, and query exchange language, e.g. QEL. The paper particularly focuses on how heterogeneous nodes can be made interoperable by reusing generalizations of mediating components - building blocks for a Smart Space for Learningtrade