Auflistung nach:
Auflistung P252 - Software Engineering 2016 nach Erscheinungsdatum
1 - 10 von 58
Treffer pro Seite
Sortieroptionen
- KonferenzbeitragKognitive Belastung als lokales Komplexitätsmaß in Geschäftsprozessmodellen(Software Engineering 2016, 2016) Figl, Kathrin; Laue, RalfIn unserem Beitrag [FL15] untersuchten wir die Verständlichkeit von Geschäftsprozessmodellen. Wir ließen Probanden Aufgaben zu Prozessmodellen lösen, in denen durch logisches Schlussfolgern Fragen zum Modell zu beantworten waren. Neben aus der Literatur bekannten Einflussfaktoren (z.B. Modellierungserfahrung) untersuchten wir, wie sich Metriken, die auf dem Be- griff der kognitiven Belastung (cognitive load) aufbauen, auf die korrekte Beantwortung von Fragen auswirken. Unsere Ergebnisse erlauben eine neue Sicht auf Komplexitätsmetriken für Geschäftsprozessmodelle: Eine bisher kaum beachtete Variable wurde als relevanter Einflussfaktor für die Modellverständlichkeit erkannt - die Interaktivität zwischen Modellelementen. Diese kann durch die Zahl der Mo- dellelemente, die zur Beantwortung einer Frage gemeinsam (in Verbindung zueinander) betrachtet werden müssen, operationalisiert werden.
- KonferenzbeitragIntelligent code completion with Bayesian networks(Software Engineering 2016, 2016) Proksch, Sebastian; Lerch, Johannes; Mezini, MiraCode completion is an integral part of modern Integrated Development Environments (IDEs). Intelligent code completion systems can reduce long lists of type-correct proposals to relevant items. In this work, we replace an existing code completion engine named Best-Matching Neighbor (BMN) by an approach using Bayesian Networks named Pattern-based Bayesian Network (PBN).We use additional context information for more precise recommendations and apply clustering techniques to improve model sizes and to increase speed. We compare the new approach with the existing algorithm and, in addition to prediction quality, we also evaluate model size and inference speed. Our results show that the additional context information we collect improves prediction quality, and that PBN can obtain comparable prediction quality to BMN, while model size and inference speed scale better with large input sizes.
- KonferenzbeitragOn facilitating reuse in multi-goal test-suite generation for software product lines(Software Engineering 2016, 2016) Lochau, Malte; Bürdek, Johannes; Bauregger, Stefan; Holzer, Andreas; Rhein, Alexander Von; Apel, Sven; Beyer, DirkSoftware testing is still the most established and scalable quality-assurance technique in practice today. However, generating effective test suites remains computationally expensive, consisting of repetitive reachability analyses for multiple test goals according to a coverage criterion. This situation is even worse when it comes to testing of entire software product lines (SPL). An SPL consists of a family of similar program variants, thus testing an SPL requires a sufficient coverage of all derivable program variants. Instead of considering every product variant one-by-one, family-based approaches are variability-aware analysis techniques in that they systematically explore similarities among the different variants. Based on this principle, we propose a novel approach for automated product-line test-suite generation incorporating extensive reuse of reachability information among test cases derived for different test goals and/or program variants. The developed tool implementation is built on top of CPA/TIGER which is based on CPACHECKER. We further present experimental evaluation results, revealing a considerable increase in efficiency compared to existing test-case generation techniques. Software product line (SPL) engineering aims at developing families of similar, yet welldistinguished software products built upon a common core platform. The commonality and variability among the family members (product variants) of an SPL are specified as features. In this regard, a feature corresponds to user-configurable product characteristics within the problem domain, as well as implementation artifacts being automatically composeable into implementation variants. The resulting extensive reuse of common feature artifacts among product variants facilitates development efficiency as well as product quality compared to one-by-one variant development. However, for SPLs to become fully accepted in practice, software-quality assurance techniques have to become variabilityaware, too, in order to benefit from SPL reuse principles. In practice, systematic software testing constitutes the most elaborated and wide-spread assurance technique, being directly applicable to software systems at any level of abstraction. In addition, testing enables a controllable trade-off between effectiveness and efficiency. In particular, white-box test generation consists of (automatically) deriving input vectors for a program under test with respect to predefined test goals. The derivation of sufficiently large test suites is, therefore, guided by test selection metrics, e.g., structural coverage criteria like basic block coverage and condition coverage [Be13]. These criteria impose multiple test goals, thus requiring sets of test input vectors for their complete coverage [Be13]. In case of mission-/safety- 1 This is a summary of a full article on this topic that appeared in Proc. FASE 2015 [Bü15]. 2 This work was partially supported by the DFG (German Research Foundation) under the Priority Programme SPP1593: Design For Future - Managed Software Evolution. 3 TU Darmstadt, Germany 4 TU Wien, Austria 5 University of Passau, Germany critical systems, it is imperative, or even enforced by industrial standards to guarantee a particular degree of code coverage for every delivered product. Technically, automated test input generation requires expensive reachability analyses of the program state space. Symbolic model checking is promising approach for fully automated white-box test generation using counterexamples as test inputs [Be04]. Nevertheless, concerning large sets of complex test goals, scalability issues still obstruct efficient test case generation when being performed for every test goal in separate. This problem becomes even worse while generating test inputs for covering entire product line implementations. To avoid a variantby-variant (re-)generation of test cases potentially leading to many redundant generation runs, an SPL test-suite generation approach must enhance existing techniques. In [Bü15], we presented a novel technique for efficient white-box test-suite generation for multi-goal test coverage of product-line implementations. The approach systematically exploits reuse potentials among reachability analysis results by means of similarity among test cases (1) derived for different test goals [Be13], and/or (2) derived for different product variants [Ci11]. The combination of both techniques allows for an incremental, coveragedriven exploration of the state space of entire product lines under test implemented in C enriched with feature parameters. We implemented an SPL test-suite generator for arbitrary coverage criteria on top of the symbolic software model checker CPACHECKER [Be13]. We evaluated our technique considering sample SPL implementations of varying size. Our experiments revealed the applicability of the tool to real-world SPL implementations, as well as a remarkable gain in efficiency obtained from the reuse of reachability analysis results. compared to test suite generation approaches without systematic reuse. As a future work, we plan to improve reuse capabilities by applying multi-property model-checking techniques of CPACHECKER which allows for reachability analyses of multiple test goals in a single run. Literaturverzeichnis [Be04] Beyer, Dirk; Chlipala, Adam J.; Henzinger, Thomas A.; Jhala, Ranjit; Majumdar, Rupak: Generating Tests from Counterexamples. In: ICSE. pp. 326-335, 2004. [Be13] Beyer, Dirk; Holzer, Andreas; Tautschnig, Michael; Veith, Helmut: Information Reuse for Multi-goal Reachability Analyses. In: ESOP, pp. 472-491. Springer, 2013. [Bü15] Bürdek, Johannes; Lochau, Malte; Bauregger, Stefan; Holzer, Andreas; von Rhein, Alexander; Apel, Sven; Beyer, Dirk: Facilitating Reuse in Multi-Goal Test-Suite Generation for Software Product Lines. In: FASE. Springer, 2015. [Ci11] Cichos, Harald; Oster, Sebastian; Lochau, Malte; Schürr, Andy: Model-based Coverage- Driven Test Suite Generation for Software Product Lines. In: MoDELS. Springer, pp. 425-439, 2011.
- KonferenzbeitragCounterexample guided abstraction refinement of product-line behavioural models(Software Engineering 2016, 2016) Cordy, Maxime; Heymans, Patrick; Legay, Axel; Schobbens, Pierre-Yves; Dawagne, Bruno; Leucker, MartinThe model-checking problem for Software Products Lines (SPLs) is harder than for single systems: variability constitutes a new source of complexity that exacerbates the state-explosion problem. Abstraction techniques have successfully alleviated state explosion in single-system models. However, they need to be adapted to SPLs, to take into account the set of variants that produce a counterexample. In this paper, we recall the main ideas of a paper published elsewhere that applies CEGAR (Counterexample-Guided Abstraction Refinement) and desings new forms of abstraction specifically for SPLs. Experiments are carried out to evaluate the efficiency of our new abstractions. The results show that our abstractions, combined with an appropriate refinement strategy, hold the potential to achieve large reductions in verification time, although they sometimes perform worse.
- KonferenzbeitragWorking with robots in smart homes and smart factories - robotic co-working(Software Engineering 2016, 2016) Aßmann, Uwe
- KonferenzbeitragAccurate profiling in the presence of dynamic compilation(Software Engineering 2016, 2016) Zheng, Yudi; Bulej, Lubomír; Binder, WalterMany programming languages are implemented on top of a managed runtime system, such as the Java Virtual Machine (JVM) or the .NET CLR, featuring an optimizing dynamic (just-intime) compiler. Programs written in those languages are first interpreted (or compiled by a baseline compiler), whereas frequently executed methods are later compiled by the optimizing dynamic compiler. Common feedback-directed optimizations [AHR02] performed by state-of-the-art dynamic compilers, such as the optimizing compiler in the Jikes RVM [Ar00] or Graal [Op], include method inlining and stack allocation of objects based on (partial) escape analysis [Ch99, SWM14], amongst others. Such optimizations result in compiled machine code that does not perform certain operations present at the bytecode level. In the case of inlining, method invocations are removed. In the case of stack allocation, heap allocations are removed and pressure on the garbage collector is reduced. Many profiling tools are implemented using bytecode instrumentation techniques, inserting profiling code into programs at the bytecode level. However, because dynamic compilation is transparent to the instrumented program, a profiler based on bytecode instrumentation techniques is not aware of the optimizations performed by the dynamic compiler. Prevailing profilers based on bytecode instrumentation suffer from two serious limitations: (1) over-profiling of code that is optimized (and in the extreme case completely removed) by the dynamic compiler, and (2) perturbation of the compiler optimizations due to the inserted instrumentation code. We present a novel technique to make profilers implemented with bytecode instrumentation techniques aware of the optimization decisions of the dynamic compiler, and to make the dynamic compiler aware of inserted profiling code. Our technique enables profilers which collect dynamic metrics that (1) correspond to an execution of the base profiling (w.r.t. the applied compiler optimizations), and (2) properly reflect the impact of dynamic compiler optimizations. We implement our approach in a state-of-the-art Java virtual machine and demonstrate its significance with concrete profilers. We quantify the impact of escape analysis on allocation profiling, object lifetime analysis, and the impact of method inlining on callsite profiling. We illustrate how our approach enables new kinds of profilers, such as a profiler for non-inlined callsites, and a testing framework for locating performance bugs in dynamic compiler implementations. This work was originally presented at OOPSLA'15 [ZBB15], where it received a Distinguished Paper Award as well as an endorsement from the Artifact Evaluation Committee for having submitted an easy-to-use, well-documented, consistent, and complete artifact4. In the meantime, the work has been integrated into the Graal project.
- KonferenzbeitragA simple and scalable static analysis for bound analysis and amortized complexity analysis(Software Engineering 2016, 2016) Sinn, Moritz; Zuleger, Florian; Veith, Helmut
- KonferenzbeitragModel-driven development of platform-independent mobile applications supporting role-based app variability(Software Engineering 2016, 2016) Vaupel, Steffen; Taentzer, Gabriele; Gerlach, Rene; Guckert, MichaelThe use of mobile applications has become an indispensable part of human interaction and especially of urban life. This will lead to rapidly increasing numbers of applications and users that make the development of mobile applications to one of the most promising fields in software engineering. Due to short time-to-market, differing platforms and fast emerging technologies, mobile application development faces typical challenges where model-driven development (MDD) can help. We present a modeling language and an infrastructure for the model-driven development of native apps in Android and iOS. Our approach allows flexible app development on different abstraction levels: compact modeling of standard app elements such as standard data management and increasingly detailed modeling of individual elements to cover specific behavior. Moreover, a kind of variability modeling is supported such that apps variants for a range of user roles can be developed. Several apps including a mobile learning app, a conference app, and a museum guide with augmented reality functionality demonstrate the usefulness of our approach.
- KonferenzbeitragNo PAIN, no gain? the utility of parallel fault injections(Software Engineering 2016, 2016) Winter, Stefan; Schwahn, Oliver; Natella, Roberto; Suri, Neeraj; Cotroneo, DomenicoThe article reports on interferences between concurrent fault injection test executions.
- KonferenzbeitragA DSL-based approach for event-based monitoring of systems of systems(Software Engineering 2016, 2016) Vierhauser, Michael; Rabiser, Rick; Grünbacher, Paul; Egyed, Alexander