Logo des Repositoriums

Auflistung nach Schlagwort "tool"

1 - 10 von 12
  • ConferencePaper
    3rd Workshop on Avionics Systems and Software Engineering (AvioSE’21)
    (Software Engineering 2021, 2021) Annighöfer, Björn; Schweiger, Andreas; Reich, Marina
    Software development in the aerospace domain is driven by new application potentials, increasing complexity, rising certification effort, and increasing cost pressure. In particular, future applications such as e.g., autonomous air transport, aircrew workload reduction, commercial UAVs, and further enhancement of existing functionality add to the system complexity. At the same time, there are challenges in communication and navigation in airspace, certification for multi-core processors, artificial intelligence as well as security for software, hardware, and connectivity. New software development methodologies and techniques are required for dealing with these challenges.
  • Konferenzbeitrag
    5th Workshop on Avionics Systems and Software Engineering (AvioSE'23)
    (Software Engineering 2023 Workshops, 2023) Annighoefer, Bjoern; Schweiger, Andreas; Poulaine, Stéphane
    Systems and software engineering in aerospace is subject to special challenges. For their resolution the AvioSE'23 workshop connects academia and industry with selected scientific presentations of high quality, motivating keynote talks, and an interactive panel discussion.
  • Konferenzbeitrag
    5th Workshop on Avionics Systems and Software Engineering (AvioSE’23)
    (Software Engineering 2023, 2023) Annighoefer, Bjoern; Schweiger, Andreas; Poulaine, Stéphane
    Systems and software engineering in aerospace is subject to special challenges. For their resolution the AvioSE’23 workshop connects academia and industry with selected scientific presentations of high quality, motivating keynote talks, and an interactive panel discussion.
  • Konferenzbeitrag
    Analyzing the Evolution of Data Structures in Trace-Based Memory Monitoring
    (Softwaretechnik-Trends Band 39, Heft 3, 2019) Weninger, Markus; Gander, Elias; Mössenböck, Hanspeter
    Modern software systems are becoming increasingly complex and are thus more prone to performance degradation due to memory leaks. Memory leaks occur if objects that are not needed anymore are still unintentionally kept alive. While there exists a variety of state-of-the-art memory monitoring tools, most of them only use memory snapshots, i.e., heap dumps, to analyze an application’s live objects at a single point in time. This does not allow developers to identify data structures that grow over time. Tracebased monitoring tools tackle this problem by recording memory events, e.g., allocations or object moves performed by the garbage collector (GC), throughout an application’s run time. In this paper, we present ongoing research on the use of memory traces for detecting the root causes of memory leaks introduced by growing data structures. This encompasses (1) a domain-specific language (DSL) to describe arbitrary data structures, (2) an algorithm to detect instances of previously defined data structures in reconstructed heaps, as well as (3) techniques to analyze the temporal evolution of these data structure instances to identify those possibly involved in memory leaks. All these concepts have been integrated into AntTracks, a trace-based memory monitoring tool, to prove their feasibility.
  • Zeitschriftenartikel
    Automatically Detecting and Mitigating Issues in Program Analyzers
    (Softwaretechnik-Trends Band 44, Heft 2, 2024) Mansur, Muhammad Numair
    This dissertation tackles two major challenges that impede the incorporation of static analysis tools into software development workflows, despite their potential to detect bugs and vulnerabilities in software before deployment. The first challenge addressed is unintentional unsoundness in program analyzers, such as SMT solvers and Datalog engines, which are susceptible to undetected soundness issues that can lead to severe consequences, particularly in safety-critical software. The dissertation presents novel, publicly available techniques that detected over 55 critical soundness bugs in these tools. The second challenge is balancing soundness, precision, and performance in static analyzers, which struggle with integration into diverse development scenarios due to their inability to scale and adapt to different program sizes and resource constraints. To combat this, the dissertation introduces an approach to automatically tailor abstract interpreters to specific code and resource conditions and presents a method for horizontally scaling analysis tools in cloud-based platforms.
  • Konferenzbeitrag
    Clang Preprocessor Tricks for Setting up Source Code Analysis Tools
    (Softwaretechnik-Trends Band 42, Heft 2, 2022) Quante, Jochen
    clang is in widespread use for development of C/C++ source code analysis tools. Many professional tools like Astrée use clang as a C++ frontend, specially because the continuously evolving C++ standard causes a lot of effort on the tool side, and clang provides an adequate infrastructure. At the same time, many hardware-specific compilers use gcc as a basis. Although gcc and clang are compatible to a certain degree, analyzing gcc-based code with clang always runs into problems. In this paper, we propose a lightweight approach to address recurring problems in clang-based software analysis tool usage.
  • Konferenzbeitrag
    Collaborative Sketching and Notation Creation with FlexiSketch Team
    (Software Engineering 2017, 2017) Wüest, Dustin; Seyff, Norbert; Glinz, Martin
    We used FlexiSketch Team, our flexible modeling tool, in an explorative study to better understand how novice and experienced engineers sketch and define ad-hoc notations collaboratively in early requirements elicitation and design sessions.
  • Konferenzbeitrag
    Collaborative software visualization with SEE
    (Softwaretechnik-Trends Band 43, Heft 2, 2023) Behnke, William; Kuß, Hannes Lennart
    SEE is a software engineering tool for visualizing software metrics based on the code-cities metaphor. It assists distributed teams in analyzing software collaboratively by offering multi-user functionality (including a voice chat), that allows team members to communicate naturally while investigating software. The tool utilizes graphs supplied in the Graph eXchange Language (GXL) format to represent software data, and allows users—among other things—to compare the current architecture with the original plan and to track changes of a software over time. One of our long-term goals is to enhance communication and collaboration among team members, to bridge spatial gaps, and to facilitate the understanding of software in (spatially separated) teams.
  • Zeitschriftenartikel
    Cooperative Approaches Across Test Generation and Formal Software Verification
    (Softwaretechnik-Trends Band 44, Heft 2, 2024) Lemberger, Thomas
    In the last decade, powerful techniques were developed that either automatically generate tests for software, or automatically verify software with formal methods. In both areas it is common to combine different techniques to leverage their strengths and mitigate their weaknesses. This happens through costly, proprietary reimplementations within a single tool. This thesis contrasts this and provide concepts that enable an inexpensive and fast off-the-shelf cooperation of standalone tools through standardized exchange formats.
  • Konferenzbeitrag
    Sharing and Exploiting Requirement Decisions
    (Softwaretechnik-Trends Band 40, Heft 1, 2020) Kleebaum, Anja; Johanssen, Jan Ole; Paech, Barbara; Bruegge, Bernd
    Continuous software engineering is an agile development process that puts particular emphasis on the incremental implementation of requirements and their rapid validation through user feedback. This involves frequent and incremental decision making, which needs to be shared within the team. Requirements engineers and developers have to share their decision knowledge since the decisions made are particularly important for future requirements. It has been a vision for long that important decision knowledge gets documented and shared. However, several reasons hinder requirements engineers and developers from doing this, for example, the intrusiveness and overhead of the documentation. With ConDec, we develop tool support for the continuous management of decision knowledge that uses techniques for natural language processing and integrates into tools that developers often use, for example, into the issue tracking system Jira. In this work, we focus on how ConDec enables requirements engineers and developers to share and exploit decision knowledge regarding requirements. We evaluate ConDec in student projects and develop techniques to teach decision knowledge management.