13 research outputs found
JavAdaptor : unrestricted dynamic software updates for Java
No full textDynamic software updates (DSU) are one of the top-most features requested by developers and users. As a result, DSU is already standard in many dynamic programming languages. But, it is not standard in statically typed languages such as Java. Even if at place number three of Oracle's current request for enhancement (RFE) list, DSU support in Java is very limited. Therefore, over the years many different DSU approaches for Java have been proposed. Nevertheless, DSU for Java is still an active field of research, because most of the existing approaches are too restrictive. Some of the approaches have shortcomings either in terms of flexibility or performance, whereas others are platform dependent or dictate the program's architecture. With JavAdaptor, we present the first DSU approach which comes without those restrictions. We will demonstrate JavAdaptor based on the well-known arcade game Snake which we will update stepwise at runtime
JavAdaptor : flexible runtime updates of Java applications
No full textSoftware is changed frequently during its life cycle. New requirements come, and bugs must be fixed. To update an application, it usually must be stopped, patched, and restarted. This causes time periods of unavailability, which is always a problem for highly available applications. Even for the development of complex applications, restarts to test new program parts can be time consuming and annoying. Thus, we aim at dynamic software updates to update programs at runtime. There is a large body of research on dynamic software updates, but so far, existing approaches have shortcomings either in terms of flexibility or performance. In addition, some of them depend on specific runtime environments and dictate the program’s architecture. We present JAVA DAPTOR, the first runtime update approach based on Java that (a) offers flexible dynamic software updates, (b) is platform independent, (c) introduces only minimal performance overhead, and (d) does not dictate the program architecture. JAVA DAPTOR combines schema changing class replacements by class renaming and caller updates with Java HotSwap using containers and proxies. It runs on top of all major standard Java virtual machines. We evaluate our approach’s applicability and performance in non-trivial case studies and compare it with existing dynamic software update approaches
Secure Deletion: Towards Tailor-Made Privacy in Database Systems
No full textIn order to ensure a secure data life cycle, it is necessary to delete sensitive data in a forensic secure way. Current state of the art in common database systems is not to provide secure deletion at all. There exist academic demonstrators that address some aspects of secure deletion. However, they are limited to their deletion approach. We argue, due to different data sensitivity levels (probably even on attribute level) and differences in policies (e.g., time when and how a data item has to be deleted), it is necessary to have a standardized, user defined opportunity to enforce secure data deletion in a forensic secure manner. Our literature analysis reveals that most approaches are based on overwriting the data. Thus, in this paper, we examine how it is possible to integrate user-defined overwriting procedures to allow a customizable deletion process based on existing default interfaces to minimize the integration overhead. In general, we propose an extension of SQL and a page propagation strategy allowing the integration of a user defined deletion procedure
Extending an index-benchmarking framework with non-invasive visualization capability
No full textFinding a suitable multi-dimensional index structure for a data-intensive system is not a trivial task. The QuEval framework supports users in finding the best index structure from a list of candidates. Nevertheless, if an index structure shows itself superior to other index structures most oft the times, but fails for one data set, we want to know the reason for this phenomenon. To support an understanding of deficits, a visualization of the partitioning scheme is helpful. Consequently, we propose a visualization component which interacts with QuEval without affecting the performance evaluation. Thus, we use a modern software-engineering approach based on AspectJ to support Digital Engineering of complex solutions
Lightweight, semi-automatic variability extraction: a case study on scientific computing
No full textIn scientific computing, researchers often use feature-rich software frameworks to simulate physical, chemical, and biological processes. Commonly, researchers follow a clone-and-own approach: Copying the code of an existing, similar simulation and adapting it to the new simulation scenario. In this process, a user has to select suitable artifacts (e.g., classes) from the given framework and replaces the existing artifacts from the cloned simulation. This manual process incurs substantial effort and cost as scientific frameworks are complex and provide large numbers of artifacts. To support researchers in this area, we propose a lightweight API-based analysis approach, called VORM, that recommends appropriate artifacts as possible alternatives for replacing given artifacts. Such alternative artifacts can speed up performance of the simulation or make it amenable to other use cases, without modifying the overall structure of the simulation. We evaluate the practicality of VORM—especially, as it is very lightweight but possibly imprecise—by means of a case study on the DUNE numerics framework and two simulations from the realm of physical simulations. Specifically, we compare the recommendations by VORM with recommendations by a domain expert (a developer of DUNE). VORM recommended 34 out of the 37 artifacts proposed by the expert. In addition, it recommended 2 artifacts that are applicable but have been missed by the expert and 32 artifacts not recommended by the expert, which however are still applicable in the simulation scenario with slight modifications. Diving deeper into the results, we identified an undiscovered bug and an inconsistency in DUNE, which corroborates the usefulness of VORM
Energy Transformation under Investigation: A comic strip by District Future Urban Lab, Energy Transformation in Dialogue and Karlsruhe Transformation Centre for Sustainability and Cultural Change
No full textPerformance evolution of configurable software systems: an empirical study
No full textAs a software system evolves, its performance can improve or degrade over time. Performance evolution is especially delicate in configurable software systems, where performance
degradation may manifest only for specific configurations, making it especially hard to spot
and fix. Problem. Prior work concentrated mainly on performance-bug detection and rootcause analysis of a single version of a system. The big picture of how performance co-evolves
with a system and what role configurability plays is largely unclear. Approach. In an empirical study, we investigate the relation between configurability and performance evolution.
Specifically, we analyze a total of 190 releases of 12 configurable real-world systems and
examine the extent to which performance changes are specific to particular configurations
and whether few or many configuration options cause performance changes. We triangulate
our findings by analyzing change logs and commit messages of the respective projects to pin
down causes of performance changes. Results. We found that almost every release of every
subject system exhibits performance changes in some of their configurations. Notably, the
majority of performance changes affects only a subset of the configuration space, and most
performance changes are triggered by multiple options (up to 6). In a deeper analysis, we
found that a considerable number of releases mention performance changes in the change
log and commits: performance changes are reported in 45% and 69% of the releases in the
change log and the commit messages, respectively, but only a fraction report the involved
configuration options
Distance-Based Sampling of Software Configuration Spaces
No full textConfigurable software systems provide configuration options to adjust and optimize
their functional and non-functional properties. However, to obtain accurate performance predictions,
a representative sample set of configurations is required. Different sampling strategies have been
proposed, which come with different advantages and disadvantages. In our experiments, we found
that most sampling strategies do not achieve a good coverage of the configuration space with respect
to covering relevant performance values. That is, they miss important configurations with distinct
performance behavior. Based on this observation, we devise a new sampling strategy that is based on
a distance metric and a probability distribution to spread the configurations of the sample set across
the configuration space. To demonstrate the merits of distance-based sampling, we compare it to
state-of-the-art sampling strategies on 10 real-world configurable software systems. Our results show
that distance-based sampling leads to more accurate performance models for medium to large sample
sets
Energietransformation im Dialog. Vom Reallabor zum Karlsruher Transformationszentrum. Faltblatt zum Projekt
No full text
