We describe ongoing work on a variability mechanism for Autonomic Software Product Lines (ASPL). The autonomic software product lines have self-management characteristics that make product line instances more resilient to context changes and some aspects of product line evolution. Instances sense the context, selects and bind the best component variants to variation-points at run-time. The variability mechanism we describe is composed of a profile guided dispatch based on off-line and on-line training processes. Together they form a simple, yet powerful variability mechanism that continuously learns, which variants to bind given the current context and system goals.

This report describes a work in progress to develop Autonomic Software Product Lines (ASPL). The ASPL is a dynamic software product line approach with a novel variability handling mechanism that enables traditional software product lines to adapt themselves at runtime in response to changes in their context, requirements and business goals. The ASPL variability mechanism is composed of three key activities: 1) context-profiling, 2) context-aware composition, and 3) online learning. Context-profiling is an offline activity that prepares a knowledge base for context-aware composition. The context-aware composition uses the knowledge base to derive a new product or adapts an existing product based on a product line's context attributes and goals. The online learning optimizes the knowledge base to remove errors and suboptimal information and to incorporate new knowledge. The three activities together form a simple yet powerful variability handling mechanism that learns and adapts a system at runtime in response to changes in system context and goals. We evaluated the ASPL variability mechanism on three small-scale software product lines and got promising results. The ASPL approach is, however, is yet at an initial stage and require improved development support with more rigorous evaluation. 

We have designed and implemented a Computer Aided Personal Interview (CAPI) system that learns from expert interviews and can support less experienced interviewers by for example suggesting questions to ask or skip. We were particularly interested to streamline the due diligence process when estimating the value for software startups. For our design we evaluated some machine learning algorithms and their trade-offs, and in a small case study we evaluates their implementation and performance. We find that while there is room for improvement, the system can learn and recommend questions. The CAPI system can in principle be applied to any domain in which long interview sessions should be shortened without sacrificing the quality of the assessment.

This paper discusses on-going work in adaptive architectures concerning automatic adaptation rule derivation. Adaptation is rule-action based but deriving rules that meet the adaptation goals are tedious and error prone. We present an approach that uses model-driven derivation and training for automatically deriving adaptation rules, and exemplify this in an environment for scientific computing.

In a service-oriented setting, where services are composed to provide end user functionality, it is a challenge to find the service components with best-fit functionality and quality. A decision based on information mainly provided by service providers is inadequate as it cannot be trusted in general. In this paper, we discuss service compositions in an open market scenario where an automated best-fit service selection and composition is based on Service Level Achievements instead. Continuous monitoring updates the actual Service Level Achievements which can lead to dynamically changing compositions. Measurements of real life services exemplify the approach.

Background: Mobility and balance is essential for older adults’ well-being an independence and the ability tomaintain physically active. Early identification of functionalimpairmentmay enable early risk-of-fall assessments and preventivemeasures.  There is a need to find new solutions to assess functional ability in easy, efficient, and accurateways, which can be clinically used frequently and repetitively. Therefore, we need to understand how functional tests and expert assessments (EAs) correlate with new techniques.

Objective: To explore whether the skeleton avatar technique (SAT) can predict the results of functional tests (FTs) of mobility and balance: Timed Up and Go (TUG), the 30-s chair stand test (30sCST), the 4-stage balance test (4SBT), and EA scoring of movement quality.

Methods: Fifty-four older adults (+65 years) were recruited through pensioners’ associations. The test procedure contained three standardized FTs: TUG, 30sCST, and 4SBT. The test performances were recorded using a three-dimensional SAT camera. EA scoring was performed based on the video recordings of the 30sCST. Functional ability scores were aggregated from balance and mobility scores. Probability theory-based statistical analyses were used on the data to aggregate sets of individual variables into scores, with correlation analysis used to assess the dependency between variables and between scores. Machine learning techniques were used to assess the appropriateness of easily observable variables/scores as predictors of the other variables included.

Results: The results indicate that SAT data of the fourth 4SBT stage could be used to predict the aggregated results of all stages of 4SBT (with 7.82% mean absolute error), the results of the 30sCST (11.0%), the TUG test (8.03%), and the EA of the sit-to-stand movement (8.79%). There is a moderate (significant) correlation between the 30sCST and the 4SBT (0.31, p = 0.03), but not between the EA and the 30sCST.

Conclusion: SAT can predict the results of the 4SBT, the 30sCST (moderate accuracy), and the TUG test and might add important qualitative information to the assessment of movement performance in active older adults. SAT might in the future provide the means for a simple, easy, and accessible assessment of functional ability among older adults.

The validation of software quality metrics lacks statistical significance. One reason for this is that the data collection requires quite some effort. To help solve this problem, we develop tools for metrics analysis of a large number of software projects (146 projects with ca. 70.000 classes and interfaces and over 11 million lines of code). Moreover, validation of software quality metrics should focus on relevant metrics, i.e., correlated metrics need not to be validated independently. Based on our statistical basis, we identify correlation between several metrics from well-known object-oriented metrics suites. Besides, we present early results of typical metrics values and possible thresholds.

The appearance of the log cross-section provides important information when assessing the quality of the log, where properties to consider include pith location and density of annual rings. This makes tasks like estimation of pith location and annual ring detection of great interest. However, creating labeled training data for these tasks can be time-consuming and subject to misjudgments. For this reason, we aim to create generated training data with controlled properties of pith location and amount of annual rings. We propose a two-step generator based on generative adversarial networks in which we can completely avoid manual labeling, not only when generating training data but also during training of the generator itself. This opens up the possibility to train the generator on other types of log end data without the need to manually label new training data. The same method is used to create two generated training datasets; one of entire log ends and one of patches of log ends. To evaluate how the generated data compares to real data, we train two deep learning models to perform estimation of pith location and ring counting, respectively. The models are trained separately on real and generated data and evaluated on real data only. The results show that the performance of both estimation of pith location and ring counting can be improved by replacing real training data with larger sets of generated training data.

To perform data mining projects for knowledge discovery based on health data produced in a daily health care stored in electronic health records (EHR) can be time consuming. This study exemplifies that the involvement of a data scientist improves classification performances. We have performed a case study that comprises two real world medical research projects, comparing feature engineering and knowledge discovery based on classification performance. Project (P1) comprised 82,742 patients with the research question “Can we predict patient falls by use of EHR data” and the second project (P2) included 23,396 patients with the focus on “Negative side effects of antiepileptic drug consumption on bone structure”.

The results concluded three salient results. (i) It is valuable for medical researchers to involve a data scientist when medical research based on real world medical data is performed. The findings were justified with an analysis of classification metrics when iteratively engineered features were used. The features were generated from domain experts and computer scientists in collaboration with medical researchers. We gave this process the name domain knowledge-driven feature engineering (KDFE).

To evaluate the classification performance the metric area under the receiver operating characteristic curve (AUROC) was used. (ii) Domain experts are benefited in quantitative terms by KDFE. When KDFE was compared to baseline, the average classification performance measured by AUROC for the engineered features rose for P1 from 0.62 to 0.82 and for P2 from 0.61 to 0.89 (p-values << 0.001). (iii) The engineered features were represented in a systematic structure, which is the foundation of a theoretical model for automated KDFE (aKDFE).

To our knowledge, this is the first study that proves that via quantitative measures KDFE adds value to real-world. However, the method is not limited to the medical domain. Other areas with similar data properties should also benefit from KDFE.

Context-Aware Composition allows to automatically select optimal variants of algorithms, data-structures, and schedules at runtime using generalized dynamic Dispatch Tables. These tables grow exponentially with the number of significant context attributes. To make Context-Aware Composition scale, we suggest four alternative implementations to Dispatch Tables, all well-known in the field of machine learning: Decision Trees, Decision Diagrams, Naive Bayes and Support Vector Machines classifiers. We assess their decision overhead and memory consumption theoretically and practically in a number of experiments on different hardware platforms. Decision Diagrams turn out to be more compact compared to Dispatch Tables, almost as accurate, and faster in decision making. Using Decision Diagrams in Context-Aware Composition leads to a better scalability, i.e., Context-Aware Composition can be applied at more program points and regard more context attributes than before.

This paper presents a generalized theory for capturing and manipulating classification information. We define decision algebra which models decision-based classifiers as higher order decision functions abstracting from implementations using decision trees (or similar), decision rules, and decision tables. As a proof of the decision algebra concept we compare decision trees with decision graphs, yet another instantiation of the proposed theoretical framework, which implement the decision algebra operations efficiently and capture classification information in a non-redundant way. Compared to classical decision tree implementations, decision graphs gain learning and classification speed up to 20% without accuracy loss and reduce memory consumption by 44%. This is confirmed by experiments.

Classification is a constitutive part in many different fields of Computer Science. There exist several approaches that capture and manipulate classification information in order to construct a specific classification model. These approaches are often tightly coupled to certain learning strategies, special data structures for capturing the models, and to how common problems, e.g. fragmentation, replication and model overfitting, are addressed. In order to unify these different classification approaches, we define a Decision Algebra which defines models for classification as higher order decision functions abstracting from their implementations using decision trees (or similar), decision rules, decision tables, etc. Decision Algebra defines operations for learning, applying, storing, merging, approximating, and manipulating models for classification, along with some general algebraic laws regardless of the implementation used. The Decision Algebra abstraction has several advantages. First, several useful Decision Algebra operations (e.g., learning and deciding) can be derived based on the implementation of a few core operations (including merging and approximating). Second, applications using classification can be defined regardless of the different approaches. Third, certain properties of Decision Algebra operations can be proved regardless of the actual implementation. For instance, we show that the merger of a series of probably accurate decision functions is even more accurate, which can be exploited for efficient and general online learning. As a proof of the Decision Algebra concept, we compare decision trees with decision graphs, an efficient implementation of the Decision Algebra core operations, which capture classification models in a non-redundant way. Compared to classical decision tree implementations, decision graphs are 20% faster in learning and classification without accuracy loss and reduce memory consumption by 44%. This is the result of experiments on a number of standard benchmark data sets comparing accuracy, access time, and size of decision graphs and trees as constructed by the standard C4.5 algorithm. Finally, in order to test our hypothesis about increased accuracy when merging decision functions, we merged a series of decision graphs constructed over the data sets. The result shows that on each step the accuracy of the merged decision graph increases with the final accuracy growth of up to 16%.

The context-aware composition approach (CAC) has shown to improve the performance of object-oriented applications on modern multi-core hardware by selecting between different (sequential and parallel) component variants in different (call and hardware) contexts. However, introducing CAC in legacy applications can be time-consuming and requires quite some effort for changing and adapting the existing code.We observe that CAC-concerns, like offline component variant profiling and runtime selection of the champion variant, can be separated from the legacy application code. We suggest separating and reusing these CAC concerns when introducing CAC to different legacy applications.

For automating this process, we propose an approach based on Aspect-Oriented Programming (AOP) and Reflective Programming. It shows that manual adaptation to CAC requires more programming than the AOP-based approach; almost three times in our experiments. Moreover, the AOP-based approach speeds up the execution time of the legacy code, in our experiments by factors of up to 2.3 and 3.4 on multi-core machines with two and eight cores, respectively. The AOP based approach only introduces a small runtime overhead compared to the manually optimized CAC approach. For different problems, this overhead is about 2-9% of the manual adaptation approach. These results suggest that AOP-based adaptation can effectively adapt legacy applications to CAC which makes them running efficiently even on multi-core machines.

For large software projects, system designers have to adhere to a significant number of functional and non-functional requirements, which makes software development a complex engineering task. If these requirements change during the development process, complexity even increases. In this paper, we suggest recommendation systems based on context-aware composition to enable a system designer to postpone and automate decisions regarding efficiency non-functional requirements, such as performance, and focus on the design of the core functionality of the system instead.

Context-aware composition suggests the optimal component variants of a system for different static contexts (e.g., software and hardware environment) or even different dynamic contexts (e.g., actual parameters and resource utilization). Thus, an efficiency non-functional requirement can be automatically optimized statically or dynamically by providing possible component variants. Such a recommender system reduces time and effort spent on manually developing optimal applications that adapts to different (static or dynamic) contexts and even changes thereof.

Classification approaches, e.g. Decision trees or Naive Bayesian classifiers, are often tightly coupled to learning strategies, special data structures, the type of information captured, and to how common problems, e.g. Over fitting, are addressed. This prevents a simple combination of classifiers of differentclassification approaches learned over different data sets. Many different methods of combiningclassification models have been proposed. However, most of them are based on a combination of the actual result of classification rather then producing a new, possibly more accurate, classifier capturing the combined classification information. In this paper we propose a new general approach to combiningdifferent classification models based on a concept of Decision Algebra which provides a unified formalization of classification approaches as higher order decision functions. It defines a general combining operation, referred to as merge operation, abstracting from implementation details of differentclassifiers. We show that the combination of a series of probably accurate decision functions (regardless of the actual implementation) is even more accurate. This can be exploited, e.g., For distributed learning and for efficient general online learning. We support our results by combining a series of decision graphs and Naive Bayesian classifiers learned from random samples of the data sets. The result shows that on each step the accuracy of the combined classifier increases, with a total accuracy growth of up to 17%.

Stream processing applications map continuous sequences of input data blocks to continuous sequences of output data blocks. They have demands on throughput of blocks or response time for each data block. We present theoretical bounds on the degree of parallelism of such applications, their throughput and response time. Based on these bounds, we develop scheduling heuristics for different optimization and constraint problems of stream processing applications involving throughput and response time. These results direct the manual implementation of efficient stream processing applications and will, on the long run, help generating them automatically.

Today there exist many programming models and platforms for implementing real-time stream processing systems. A decision in favor of the wrong technology might lead to increased development time and costs. It is, therefore, necessary to decide which alternatives further efforts should concentrate on and which may be forgotten. Such decisions cannot be based sole on analytical comparisons; the present experiment seeks to complement analytical with empirical results.

More specifically, the paper discusses the results of comparing programmability and performance of one and the same real-world real-time stream processing system implemented using three different alternative implementation platforms: C++ as a general-purpose programming language, IBM InfoSphere Streams as a dedicated stream processing platform, and MatLab as the technical computing system preferred in the application domain. As a result: system implementation based on MatLab was easiest, the C++ based implementation outperformed the others in response time, while InfoSphereStreams led to the highest data throughput. Altogether, the results give a picture of advantages and disadvantages of each technology for our real-time stream processing system. More empirical studies ought to provide similar empirical knowledge to help decide which technology to use for solving particular stream processing problems.

Quality assessment of human movements has many of applications in diagnosis and therapy of musculoskeletal insufficiencies and high performance sport. We suggest five purely data driven assessment methods for arbitrary human movements using inexpensive 3D sensor technology. We evaluate their accuracy by comparing them against a validated digitalization of a standardized human-expert-based assessment method for deep squats. We suggest the data driven method that shows high agreement with this baseline method, requires little expertise in the human movement and no expertise in the assessment method itself. It allows for an effective and efficient, automatic and quantitative assessment of  arbitrary human movements.

The paper suggests a quantitative assessment of human movements using inexpensive 3D sensor technology and evaluates its accuracy by comparing it with human expert assessments. The two assessment methods show a high agreement. To achieve this, a novel sequence alignment algorithm was developed that works for arbitrary time series.

Static program analysis supporting software development is often part of edit-compile-cycles, and precise program analysis is time consuming. Points-to analysis is a data-flow-based static program analysis used to find object references in programs. Its applications include test case generation, compiler optimizations and program understanding, etc. Recent increases in processing power of desktop computers comes mainly from multiple cores. Parallel algorithms are vital for simultaneous use of multiple cores. An efficient parallel points-to analysis requires sufficient work for each processing unit.

The present paper presents a parallel points-to analysis of object-oriented programs. It exploits that (1) different target methods of polymorphic calls and (2) independent control-flow branches can be analyzed in parallel. Carefully selected thresholds guarantee that each parallel thread has sufficient work to do and that only little work is redundant with other threads. Our experiments show that this approach achieves a maximum speed-up of 4.5.

Static program analysis usually consists of a number of steps, each producing partial results. For example, the points-to analysis step, calculating object references in a program, usually just provides the input for larger client analyses like reachability and escape analyses. All these analyses are computationally intense and it is therefore vital to create parallel approaches that make use of the processing power that comes from multiple cores in modern desktop computers.

The present paper presents two parallel approachesto increase the efficiency of reachability analysis and escape analysis, based on a parallel points-to analysis. The experiments show that the two parallel approaches achieve a speed-up of 1.5 for reachability analysis and 3.8 for escape analysis on 8 cores for a benchmark suite of Java programs.

Program analysis supporting software development is often part of edit-compile-cycles, and precise program analysis is time consuming. With the availability of parallel processing power on desktop computers, parallelization is a way to speed up program analysis. This requires a parallel data-flow analysis with sufficient work for each processing unit. The present paper suggests such an approach for object-oriented programs analyzing the target methods of polymorphic calls in parallel. With carefully selected thresholds guaranteeing sufficient work for the parallel threads and only little redundancy between them, this approach achieves a maximum speed-up of 5 (average 1.78) on 8 cores for the benchmark programs.

Program analysis supporting software development is often part of edit-compile-cycles and precise program analysis is time consuming. With the availability parallel processing power on desktop computers, parallelization is a way to speed up program analysis. This paper introduces a parallelization schema for program analysis that can be translated to parallel machines using standard scheduling techniques. First benchmarks analyzing a number of Java programs indicate that the schema scales well for up to 8 processors, but not very well for 128 processors. These results are a first step towards more precise program analysis in Integrated Development Environments utilizing the computational power of today’s custom computers.

Indirect metrics in quality models define weighted integrations of direct metrics to provide higher-level quality indicators. This paper presents a case study that investigates to what degree quality models depend on statistical assumptions about the distribution of direct metrics values when these are integrated and aggregated. We vary the normalization used by the quality assessment efforts of three companies, while keeping quality models, metrics, metrics implementation and, hence, metrics values constant. We find that normalization has a considerable impact on the ranking of an artifact (such as a class). We also investigate how normalization affects the quality trend and find that normalizations have a considerable effect on quality trends. Based on these findings, we find it questionable to continue to aggregate different metrics in a quality model as we do today.

We need to aggregate metric values to make quality assessment actionable. However, due to properties of metric values, i.e., unknown distributions and different measurement scales, they are difficult to aggregate. We present and evaluate a method to aggregate metric values based on observed numerical distributions that are converted into cumulative density functions. We use these to determine the probability of each metric and file, and aggregate these. Our limited study suggests that the method improves correctness, communication, and the ability to take action. However, more evaluation is required.

Information quality assessment of technical documentation is nowadays an integral part of quality management of products and services. These are usually assessed using questionnaires, checklists, and reviews and consequently work that is cumbersome, costly and prone to errors. Acknowledging the fact that only humans can assess certain quality aspects, we suggest complementing these with automatic quality assessment using a software infrastructure that (i) reads information from documentations, (ii) performs analyses on this information, and (iii) visualizes the results to help stakeholders understand quality issues. We introduce the software infrastructure’s architecture and implementation, its adaptation to different formats of documentations and types of analyses, along with a number of real world cases exemplifying feasibility and benefit of our approach. Altogether, our approach contributes to more efficient and automatic information quality assessments. 

Information quality assessment of technical documentation is an integral part of quality management of products and services. Technical documentation is usually assessed using questionnaires, checklists, and reviews. This is cumbersome, costly and prone to errors. Acknowledging the fact that only people can assess certain quality aspects, we suggest complementing these with software-supported automatic quality assessment. The many different encodings and representations of documentation, e.g., various XML dialects and XML Schemas/DTDs, is one problem. We present a system, a software infrastructure, where abstraction and meta modelling are used to define reusable analyses and visualisations that are independent of specific encodings and representations. We show how this system is implemented and how it: 1) reads information from documentations; 2) performs analyses on this information; 3) visualises the results to help stakeholders understand quality issues. We introduce the system, the architecture and implementation, its adaptation to different formats of documentations and types of analyses, along with a number of real world cases exemplifying the feasibility and benefits of our approach. Altogether, our approach contributes to more efficient information quality assessments.

An initial study of how text clones can be detected and visualized in technical documentation, i.e., semi-structured text that describe a product, software, or service. The goal of the visualizations is to support human experts to assess and prioritize the clones, since certain clones can be either intentional or harmless. We study some existing visualizations designed for source code, and provide initial and limited adaption of these. A major difficulty in this adaptation is to manage the semi-structured technical documentation compared to structured source code. 

Movements of a person can be recorded with a mobile camera and visualized as sequences of stick figures for assessments in health and elderly care, physio-therapy, and sports. However, since the visualizations flicker due to noisy input data, the visualizations themselves and even whole assessment applications are not trusted in general. The present paper evaluates different filters for smoothing the movement visualizations but keeping their validity for a visual physio-therapeutic assessment. It evaluates variants of moving average, high-pass, and Kalman filters with different parameters. Moreover, it presents a framework for the quantitative evaluation of smoothness and validity. As these two criteria are contradicting, the framework also allows to weight them differently and to automatically find the correspondingly best-fitting filter and its parameters. Different filters can be recommended for different weightings of smoothness and validity. The evaluation framework is applicable in more general contexts and with more filters than the three filters assessed. However, as a practical result of this work, a suitable filter for stick figure visualizations in a mobile application for assessing movement quality could be selected and used in a mobile app. The application is now more trustworthy and used by medical and sports experts, and end customers alike.

The present research develops a framework to refine the classification of an individual's activities and recognize wellness associated with their routine. The framework improves the accuracy of the classification of routine activities of a person, the activation time data of sensors fixed on objects linked with the routine activities of the person, and the aptness of an incessant activity pattern with the routine activities. The existing techniques need continuous monitoring and are non-adaptive to a person's persistent habitual variations or individualities. The research involves applying Internet of Medical Things (IoMT)-based sensor information fusion to the novel multimodel data analytics to develop Activities of Daily Living (ADL) pattern, behavioral pattern generation and anomaly recognition. The novel multimodel data analytics approach is named AiCareLiving. AicareLiving is an IoMT and artificial intelligence (AI) enabled approach. The research work describes activity data using an individual's activities within a specified area before evaluating the activity data to detect the existence of an anomaly by identifying the deviation of the activity data from the activity profile, which indicates the anticipated behavior and activity of the person. This wellness information would be shared to the caregivers, related healthcare professionals, care providers and municipalities through the secured healthcare information exchange protocol and IoMT. AiCareLiving framework aims to least false positive in terms of anomaly detection and forecasting; the high precision is close to the confidence level of 95%.

This paper introduces an AI-based approach to detect human-made objects and changes in these on land parcels. To this end, we used binary image classification performed by a convolutional neural network. Binary classification requires the selection of a decision boundary, and we provided a deterministic method for this selection. Furthermore, we varied different parameters to improve the performance of our approach, leading to a true positive rate of 91.3% and a true negative rate of 63.0%. A specific application of our work supports the administration of agricultural land parcels eligible for subsidiaries. As a result of our findings, authorities could reduce the effort involved in the detection of human made changes by approximately 50%.

Points-to information is the basis for many analyses and transformations, e.g., for program understanding and optimization. To justify new analysis techniques, they need to be compared to the state of the art regarding their accuracy and efficiency. Usually, benchmark suites are used to experimentally compare the different techniques. In this paper, we show that the accuracy of two analyses can only be compared in restricted cases, as there is no benchmark suite with exact Points-to information, no Gold Standard, and it is hard to construct one for realistic programs. We discuss the challenges and possible traps that may arise when comparing different Points-to analyses directly with each other, and with over- and under-approximations of a Gold Standard. Moreover, we discuss how different Points-to analyses can be combined to a more precise one. We complement the paper with experiments comparing and combining different static and dynamic Points-to analyses.

Points-to information is the basis for many analysesand transformations, e.g., for program understanding andoptimization. Collections frameworks are part of most modern programming languages’ infrastructures and used by many applications. The richness of features and the inherent structure of collection classes affect both performance and precision of points-to analysis negatively.

In this paper, we discuss how to replace original collections frameworks with versions specialized for points-to analysis. We implement such a replacement for the Java Collections Framework and support its benefits for points-to analysis by applying it to three different points-to analysis implementations. In experiments, context-sensitive points-to analyses require, on average, 16-24% less time while at the same time being more precise. Context-insensitive analysis in conjunction with inlining also benefits in both precision and analysis cost.

Points-to analysis is a static program analysis that extracts reference information from agiven input program. Its accuracy is limited due to abstractions that any such analysisneeds to make. Further, the exact analysis results are unknown, i.e., no so-called GoldStandard exists for points-to analysis. This hinders the assessment of new ideas to pointstoanalysis, as results can be compared only relative to results obtained by other inaccurateanalyses.

In this paper, we present feedback-driven points-to analysis. We suggest performing(any classical) points-to analysis with the points-to results at certain programpoints guarded by a-priori upper bounds. Such upper bounds can come from other pointstoanalyses – this is of interest when different approaches are not strictly ordered in termsof accuracy – and from human insight, i.e., manual proofs that certain points-to relationsare infeasible for every program run. This gives us a tool at hand to compute very accuratepoints-to analysis and, ultimately, to manually create a Gold Standard.

In this paper, we present feedback-driven points-to analysis where any classical points-to analysis has its points-to results at certain program points guarded by a-priori upper bounds. Such upper bounds can come from other points-to analyses – this is of interest when different approaches are not strictlyordered in terms of accuracy – and from human insight, i.e., manual proofs that certain points-to relations are infeasible for every program run.

Points-to analysis is a static program analysis aiming at analyzing the reference structure of dynamically allocated objects at compile-time. It constitutes the basis for many analyses and optimizations in software engineering and compiler construction. Sparse program representations, such as Whole Program Points-to Graph (WPP2G) and Points-to SSA (P2SSA), represent only dataflow that is directly relevant for points-to analysis. They have proved to be practical in terms of analysis precision and efficiency. However, intra-procedural control flow information is removed from these representations, which sacrifices analysis precision to improve analysis performance.

We show an approach for keeping control flow related information even in sparse program representations by representing control flow effects as operations on the data transferred, i.e., as dataflow information. These operations affect distinct paths of the program differently, thus yielding a certain degree of pathsensitivity. Our approach works with both WPP2G and P2SSA representations.

We apply the approach to P2SSA-based and flow-sensitive points-to analysis and evaluate a context-insensitive and a context-sensitive variant. We assess our approach using abstract precision metrics. Moreover, we investigate the precision improvements and performance penalties when used as an input to three source-code-level analyses: dead code, cast safety, and null pointer analysis.

Many dynamic analysis tools capture the occurrences of events at runtime. The longer programs are being monitored, the more accurate the data they provide to the user. Then, the runtime overhead must be kept as low as possible, because it decreases the user's productivity. Runtime performance overhead occurs due to identifying events, and storing them in a result data-structure. We address the latter issue by generating custom-made instrumentation code for each program. By using static analysis to get a~priori knowledge about which events of interest can occur and where they can occur, tailored code for storing those events can be generated for each program. We evaluate our idea by comparing the runtime overhead of a general purpose dynamic analysis tool that captures points-to information for Java programs with approaches based on custom-made instrumentation code. Experiments suggest highly reduced performance overhead for the latter.

The usefulness of dynamic analysis tools for programcomprehension increases with the amount oftime a given analyzed program is monitored. Thus, monitoring the analyzed program in a production environment should give the best picture of how the program actually works. However, high performance overhead is especially undesirable in such a setting, because it decreases the user’s productivity. Performance overhead occurs due to recognizing events that are of interest to the agent monitoring the program run and storing those events in data-structures. We propose to address this issue by creating a custom-made agent for each program. By using static analysis to get a priori knowledge about which events of interest can occur and where they can occur, tailored code for recognizing and storing those events can be generated for each program. We evaluate our idea by comparing a "general purpose" dynamic agent that captures fine-grained points-to information with custom-made agents that do the same job for specific programs. The latter show highly reduced performance overhead in practice. We also investigate how the precision of the static analysis affects the performance of the custom-made agents.

The advent of commodity 3D sensor technology enabled, amongst other things, the efficient and effective assessment of human movements. Statistical and machine learning approaches map recorded movement instances to expert scores to train models for the automated assessment of new movements. However, there are many variations in selecting the approaches and setting the parameters for achieving high performance, i.e., high accuracy and low response time. The present paper researches the design space and the impact of approaches of statistical and machine learning on accuracy and response time in human movement assessment. Results show that a random forest regression approach outperforms linear regression, support vector regression and neuronal network approaches. Since the results do not rely on the movement specifics, they can help improving the performance of automated human movement assessment, in general.

The advent of commodity 3D sensor technology enabled, amongst other things, the efficient and effective assessment of human movements. Statistical and machine learning approaches map recorded movement instances to expert scores to train models for the automated assessment of new movements. However, there are many variations in selecting the approaches and setting the parameters for achieving good performance, i.e., high scoring accuracy and low response time. The present paper researches the design space and the impact of sequence alignment on accuracy and response time. More specifically, we introduce variants of Dynamic Time Warping (DTW) for aligning the phases of slow and fast movement instances and assess their effect on the scoring accuracy and response time. Results show that an automated stripping of leading and trailing frames not belonging to the movement (using one DTW variant) followed by an alignment of selected frames in the movements (based on another DTW variant) outperforms the original DTW and other suggested variants thereof. Since these results are independent of the selected learning approach and do not rely on the movement specifics, the results can help improving the performance of automated human movement assessment, in general.

The advent of commodity 3D sensor technol- ogy has, amongst other things, enabled the efficient and effective assessment of human movements. Machine learning approaches do not rely manual definitions of gold standards for each new movement. However, to train models for the automated assessments of a new movement they still need a lot of data that map recorded movements to expert judg- ments. As camera technology changes, this training needs to be repeated if a new camera does not agree with the old one. The present paper presents an inexpensive method to check the agreement of cameras, which, in turn, would allow for a safe reuse of trained models regardless of the cameras. We apply the method to the Kinect, Astra Mini, and Real Sense cameras. The results show that these cameras do not agree and that the models cannot be reused without an unacceptable decay in accuracy. However, the suggested method works independent of movements and cameras and could potentially save effort when integrating new cameras in an existing assessment environment.

Nowadays, many companies are running digitalization initiatives or are planning to do so. There exist various models to evaluate the digitalization potential of a company and to define the maturity level of a company in exploiting digitalization technologies summarized under buzzwords such as Big Data, Artificial Intelligence (AI), Deep Learning, and the Industrial Internet of Things (IIoT). While platforms, protocols, patterns, technical implementations, and standards are in place to adopt these technologies, small-to mediumsized enterprises (SME) still struggle with digitalization. This is because it is hard to identify the most beneficial projects with manageable cost, limited resources and restricted know-how. In the present paper, we describe a real-life project where digitalization use cases have been identified, evaluated, and prioritized with respect to benefits and costs. This effort led to a portfolio of projects, some with quick and easy wins and some others with mid-to long-term benefits. From our experiences, we extracted a general approach that could be useful for other SMEs to identify concrete digitalization activities and to define projects implementing their digital transformation. The results are summarized in a Digitalization Canvas.