Auflistung nach:
Auflistung P252 - Software Engineering 2016 nach Erscheinungsdatum
1 - 10 von 58
Treffer pro Seite
Sortieroptionen
- KonferenzbeitragContinuous Software Engineering(Software Engineering 2016, 2016) Hasselbring, Wilhelm
- KonferenzbeitragExtracting frame conditions from operation contracts(Software Engineering 2016, 2016)
- KonferenzbeitragScaling size and parameter spaces in variability-aware software performance models(Software Engineering 2016, 2016) Kowal, Matthias; Tschaikowski, Max; Tribastone, Mirco; Schaefer, InaModel-based software performance engineering often requires the analysis of many instances of a model to find optimizations or to do capacity planning. These performance predictions get increasingly more difficult with larger models due to state space explosion as well as large parameter spaces since each configuration has its own performance model and must be analyzed in isolation (product-based (PB) analysis). We propose an efficient family-based (FB) analysis using UML activity diagrams with performance annotations. The FB analysis enables us to analyze all configurations at once using symbolic computation. Previous work has already shown that a FB analysis is significant faster than its PB counterpart. This work is an extension of our previous research lifting several limitations.
- KonferenzbeitragTransparent object proxies for javascript(Software Engineering 2016, 2016) Keil, Matthias; Guria, Sankha Narayan; Schlegel, Andreas; Geffken, Manuel; Thiemann, PeterThis work appeared in the conference proceedings of the European Conference on Object-Oriented Programming, ECOOP 2015. One important question in the design of a proxy API is whether a proxy object should inherit the identity of its target. Apparently proxies should have their own identity for security-related applications whereas other applications, in particular contract systems, require transparent proxies that compare equal to their target objects. In this work we examine the issue with transparency in various use cases for proxies, discuss different approaches to obtain transparency, and propose two designs that require modest modifications in the JavaScript engine and cannot be bypassed by the programmer. The JavaScript Proxy API embodies a design decision that reveals the presence of proxies in some important use cases. This decision concerns object equality. Proxies are opaque, which means that each proxy has its own identity, different from all other (proxy or nonproxy) objects. Given opaque proxies, an equality test can be used to distinguish a proxy from its target as demonstrated in the following example:
- KonferenzbeitragDevelopment of flexible software process lines with variability operations: A longitudinal case study(Software Engineering 2016, 2016) Schramm, Joachim; Dohrmann, Patrick; Kuhrmann, MarcoContext: A software process line helps to systematically develop and manage families of processes and, as part of this, variability operations provide means to modify and reuse predefined process assets. Objective: Our goal is to evaluate the feasibility of variability operations to support the development of flexible software process lines. Method: We conducted a longitudinal study in which we studied 5 variants of the V-Modell XT process line for 2 years. Results: Our results show the variability operation instrument feasible in practice. We analyzed 616 operation exemplars addressing various customization scenarios, and we found 87 different operation types. Conclusions: Although variability operations are only one instrument among others, our results suggest this instrument useful to implement variability in real-life software process lines. This summary refers to the paper Development of Flexible Software Process Lines with Variability Operations: A Longitudinal Case Study [Do15]. This paper was published as full research paper in the EASE'2015 proceedings.
- KonferenzbeitragJust test what you cannot verify!(Software Engineering 2016, 2016) Czech, Mike; Jakobs, Marie-Christine; Wehrheim, HeikeSoftware verification is an established method to ensure software safety. Nevertheless, verification still often fails, either because it consumes too much resources, e.g., time or memory, or the technique is not mature enough to verify the property. Often then discarding the partial verification, the validation process proceeds with techniques like testing. To enable standard testing to profit from previous, partial verification, we use a summary of the verification effort to simplify the program for subsequent testing. Our techniques use this summary to construct a residual program which only contains program paths with unproven assertions. Afterwards, the residual program can be used with standard testing tools. Our first experiments show that testing profits from the partial verification. The test effort is reduced and combined verification and testing is faster than a complete verification.
- KonferenzbeitragUmlchange - specifying model changes to support security verification of potential evolution(Software Engineering 2016, 2016) Wenzel, Sven; Poggenpohl, Daniel; Jürjens, Jan; Ochoa, MartínSecurity certification of complex systems requires a high amount of effort. As a particular challenge, today's systems are increasingly long-living and subject to continuous change. After each change of some part of the system, the whole system needs to be re-certified from scratch (since security properties are not in general modular), which is usually far too much effort. We present a tool-supported approach for security certification that minimizes the amount of effort necessary in the case of re-certification after change. It is based on an approach for model-based development of secure software which makes use of the security extension UMLsec of the Unified Modeling Language (UML). It allows the user to integrate security requirements such as secure information flow and audit security into a system design model, it supported by a security verification tool chain, and has been applied to a number of industrial applications.
- KonferenzbeitragDesign and evaluation of a customizable multi-domain reference architecture on top of product lines of self-driving heavy vehicles - an industrial case study(Software Engineering 2016, 2016) Schroeder, Jan; Holzner, Daniela; Berger, Christian; Hoel, Carl-Johan; Laine, Leo; Magnusson, AndersSelf-driving vehicles are of high interest for academia and industry at the moment. Particularly, in the transportation domain they exhibit a huge potential to increase companies' competitiveness by automating delivery tasks or construction work. This industrial case study reports on the process of developing and evaluating a multi-domain reference architecture concerned with commercial transport mission planning, execution, and tracking for self-driving vehicles. Therefore, internal and external stakeholders as well as development documents were consulted. The resulting reference architecture is evaluated based on its underlying non-functional requirements ensuring early confirmation of compliance with stakeholder needs. A concrete variant of the architecture was also deployed on a Volvo FMX truck and practically evaluated in an exemplary construction site setting. This paper summarizes our work Schroeder et al. [Sc15] published at 2015 ICSE.
- KonferenzbeitragAn empirical study on program comprehension with reactive programming(Software Engineering 2016, 2016) Salvaneschi, Guido; Amann, Sven; Proksch, Sebastian; Mezini, MiraStarting from the first investigations with strictly functional languages, reactive programming has been proposed as the programming paradigm for reactive applications. The advantages of designs based on this style over designs based on the Observer design pattern have been studied for a long time. Over the years, researchers have enriched reactive languages with more powerful abstractions, embedded these abstractions into mainstream languages - including object-oriented languages - and applied reactive programming to several domains, like GUIs, animations, Web applications, robotics, and sensor networks. However, an important assumption behind this line of research - that, beside other advantages, reactive programming makes a wide class of otherwise cumbersome applications more comprehensible - has never been evaluated. In this paper, we present the design and the results of the first empirical study that evaluates the effect of reactive programming on comprehensibility compared to the traditional object-oriented style with the Observer design pattern. Results confirm the conjecture that comprehensibility is enhanced by reactive programming. In the experiment, the reactive programming group significantly outperforms the other group.
- KonferenzbeitragGuiding random test generation with program analysis(Software Engineering 2016, 2016) Ma, Lei; Artho, Cyrille Valentin; Zhang, Cheng; Sato, Hiroyuki; Gmeiner, Johannes; Ramler, RudolfRandom test generation is effective in creating method sequences for exercising the software under test. However, black-box approaches for random testing are known to suffer from low code coverage and limited defect detection ability. Analyzing the software under test and using the extracted knowledge to guide test generation can help to overcome these limitations. We developed a random test case generator augmented by a combination of six static and dynamic program analysis techniques. Our tool GRT (Guided Random Testing) has been evaluated on realworld software systems as well as Defects4J benchmarks. It outperformed related approaches in terms of code coverage, mutation score and detected faults. The results show a considerable improvement potential of random test generation when combined with advanced analysis techniques.