Keynote at the 5th Workshop on Validation, Analysis, and Evolution of Software Tests (VST 2022)
Website: https://rramler.github.io/vst2022/
Abstract: Nowadays, Artificial intelligence (AI) plays a critical role in automating different human-intensive tasks, including software engineering tasks. Since the late 70s, researchers have proposed automated techniques to automatically generate test data (fuzzing) or test suites (test suite generation). Proposed techniques span from simple heuristics to more advanced AI-based techniques and evolutionary intelligence in particular. While recent studies have shown that these techniques achieve high coverage and find bugs, generated tests can be hard to understand and maintain. This talk will provide an overview and reflection on state-of-the-art techniques, open challenges, and research opportunities towards more accessible tests that are easy to integrate within the DevOps cycle. To this aim, the talk will cover relevant application domains, including "traditional" software and emerging cyber-physical systems.
Reformulating Branch Coverage as a Many-Objective Optimization ProblemAnnibale Panichella
Test data generation has been extensively investigated as a search problem, where the search goal is to maximize the number of covered program elements (e.g., branches). Recently, the whole suite approach, which combines the fitness functions of single branches into an aggregate, test suite-level fitness, has been demonstrated to be superior to the traditional single-branch at a time approach. In this paper, we propose to consider branch coverage directly as a many-objective optimization problem, instead of aggregating multiple objectives into a single value, as in the whole suite approach. Since programs may have hundreds of branches (objectives), traditional many-objective algorithms that are designed for numerical optimization problems with less than 15 objectives are not applicable. Hence, we introduce a novel highly scalable many-objective genetic algorithm, called MOSA (Many-Objective Sorting Algorithm), suitably defined for the many-objective branch coverage problem. Results achieved on 64 Java classes indicate that the proposed many-objective algorithm is significantly more effective and more efficient than the whole suite approach. In particular, effectiveness (coverage) was significantly improved in 66% of the subjects and efficiency (search budget consumed) was improved in 62% of the subjects on which effectiveness remains the same.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2021/09/a-practical-guide-to-implementing-ml-on-embedded-devices-a-presentation-from-the-chamberlain-group/
Nathan Kopp, Principal Software Architect for Video Systems at the Chamberlain Group, presents the “Practical Guide to Implementing ML on Embedded Devices” tutorial at the May 2021 Embedded Vision Summit.
Deploying machine learning onto edge devices requires many choices and trade-offs. Fortunately, processor designers are adding inference-enhancing instructions and architectures to even the lowest cost MCUs, tools developers are constantly discovering optimizations that extract a little more performance out of existing hardware, and ML researchers are refactoring the math to achieve better accuracy using faster operations and fewer parameters.
In this presentation, Kopp takes a high-level look at what is involved in running a DNN model on existing edge devices, exploring some of the evolving tools and methods that are finally making this dream a reality. He also takes a quick look at a practical example of running a CNN object detector on low-compute hardware.
An Adaptive Evolutionary Algorithm based on Non-Euclidean Geometry for Many-O...Annibale Panichella
In the last decade, several evolutionary algorithms have been proposed in the literature for solving multi- and many-objective optimization problems. The performance of such algorithms depends on their capability to produce a well-diversified front (diversity) that is as closer to the Pareto optimal front as possible (proximity). Diversity and proximity strongly depend on the geometry of the Pareto front, i.e., whether it forms a Euclidean, spherical or hyperbolic hypersurface. However, existing multi- and many-objective evolutionary algorithms show poor versatility on different geometries. To address this issue, we propose a novel evolutionary algorithm that: (1) estimates the geometry of the generated front using a fast procedure with O(M × N) computational complexity (M is the number of objectives and N is the population size); (2) adapts the diversity and proximity metrics accordingly. Therefore, to form the population for the next generation, solutions are selected based on their contribution to the diversity and proximity of the non-dominated front with regards to the estimated geometry.
Computational experiments show that the proposed algorithm outperforms state-of-the-art multi and many-objective evolutionary algorithms on benchmark test problems with different geometries and number of objectives (M=3,5, and 10).
This document discusses kernel methods and radial basis function (RBF) networks. It begins with an introduction and overview of Cover's theory of separability of patterns. It then revisits the XOR problem and shows how it can be solved using Gaussian hidden functions. The interpolation problem is explained and how RBF networks can perform strict interpolation through a set of training data points. Radial basis functions that satisfy Micchelli's theorem allowing for a nonsingular interpolation matrix are presented. Finally, the structure and training of RBF networks using k-means clustering and recursive least squares estimation is covered.
This document presents information on digital image processing operations including image arithmetic. It discusses several MATLAB commands for performing arithmetic on images, such as imabsdiff for calculating the absolute difference between images, imadd for adding images, imcomplement for inverting pixels, imdivide for dividing images, imlincomb for linear combinations, immultiply for multiplying images, and imsubtract for subtracting images. Examples are provided for each command to demonstrate how it can be used to perform operations like adding a constant to an image, inverting black and white pixels, estimating and removing a background, and scaling an image intensity. The objectives are to use these commands to perform tasks like comparing filtered and original images.
Reformulating Branch Coverage as a Many-Objective Optimization ProblemAnnibale Panichella
Test data generation has been extensively investigated as a search problem, where the search goal is to maximize the number of covered program elements (e.g., branches). Recently, the whole suite approach, which combines the fitness functions of single branches into an aggregate, test suite-level fitness, has been demonstrated to be superior to the traditional single-branch at a time approach. In this paper, we propose to consider branch coverage directly as a many-objective optimization problem, instead of aggregating multiple objectives into a single value, as in the whole suite approach. Since programs may have hundreds of branches (objectives), traditional many-objective algorithms that are designed for numerical optimization problems with less than 15 objectives are not applicable. Hence, we introduce a novel highly scalable many-objective genetic algorithm, called MOSA (Many-Objective Sorting Algorithm), suitably defined for the many-objective branch coverage problem. Results achieved on 64 Java classes indicate that the proposed many-objective algorithm is significantly more effective and more efficient than the whole suite approach. In particular, effectiveness (coverage) was significantly improved in 66% of the subjects and efficiency (search budget consumed) was improved in 62% of the subjects on which effectiveness remains the same.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2021/09/a-practical-guide-to-implementing-ml-on-embedded-devices-a-presentation-from-the-chamberlain-group/
Nathan Kopp, Principal Software Architect for Video Systems at the Chamberlain Group, presents the “Practical Guide to Implementing ML on Embedded Devices” tutorial at the May 2021 Embedded Vision Summit.
Deploying machine learning onto edge devices requires many choices and trade-offs. Fortunately, processor designers are adding inference-enhancing instructions and architectures to even the lowest cost MCUs, tools developers are constantly discovering optimizations that extract a little more performance out of existing hardware, and ML researchers are refactoring the math to achieve better accuracy using faster operations and fewer parameters.
In this presentation, Kopp takes a high-level look at what is involved in running a DNN model on existing edge devices, exploring some of the evolving tools and methods that are finally making this dream a reality. He also takes a quick look at a practical example of running a CNN object detector on low-compute hardware.
An Adaptive Evolutionary Algorithm based on Non-Euclidean Geometry for Many-O...Annibale Panichella
In the last decade, several evolutionary algorithms have been proposed in the literature for solving multi- and many-objective optimization problems. The performance of such algorithms depends on their capability to produce a well-diversified front (diversity) that is as closer to the Pareto optimal front as possible (proximity). Diversity and proximity strongly depend on the geometry of the Pareto front, i.e., whether it forms a Euclidean, spherical or hyperbolic hypersurface. However, existing multi- and many-objective evolutionary algorithms show poor versatility on different geometries. To address this issue, we propose a novel evolutionary algorithm that: (1) estimates the geometry of the generated front using a fast procedure with O(M × N) computational complexity (M is the number of objectives and N is the population size); (2) adapts the diversity and proximity metrics accordingly. Therefore, to form the population for the next generation, solutions are selected based on their contribution to the diversity and proximity of the non-dominated front with regards to the estimated geometry.
Computational experiments show that the proposed algorithm outperforms state-of-the-art multi and many-objective evolutionary algorithms on benchmark test problems with different geometries and number of objectives (M=3,5, and 10).
This document discusses kernel methods and radial basis function (RBF) networks. It begins with an introduction and overview of Cover's theory of separability of patterns. It then revisits the XOR problem and shows how it can be solved using Gaussian hidden functions. The interpolation problem is explained and how RBF networks can perform strict interpolation through a set of training data points. Radial basis functions that satisfy Micchelli's theorem allowing for a nonsingular interpolation matrix are presented. Finally, the structure and training of RBF networks using k-means clustering and recursive least squares estimation is covered.
This document presents information on digital image processing operations including image arithmetic. It discusses several MATLAB commands for performing arithmetic on images, such as imabsdiff for calculating the absolute difference between images, imadd for adding images, imcomplement for inverting pixels, imdivide for dividing images, imlincomb for linear combinations, immultiply for multiplying images, and imsubtract for subtracting images. Examples are provided for each command to demonstrate how it can be used to perform operations like adding a constant to an image, inverting black and white pixels, estimating and removing a background, and scaling an image intensity. The objectives are to use these commands to perform tasks like comparing filtered and original images.
The document describes Weddle's rule, a numerical integration method. It provides background on Thomas Weddle, who introduced the rule. Weddle's rule approximates integrals using a 6th degree Newton-Cotes formula. The document explains the formula for Weddle's rule, provides an example calculation, and discusses applications for numerical integration such as calculating power and energy over time.
The document defines and provides equations for various special functions including the beta and gamma functions, Bessel function, error function, complementary error function, Heaviside's unit step function, pulse function, sinusoidal pulse, rectangle function, gate function, Dirac delta function, signum function, saw tooth wave function, triangular wave function, half-wave and full-wave rectified sinusoidal functions, and square wave function. The author is N. B. Vyas from the Department of Mathematics at Atmiya Institute of Tech. and Science in Rajkot, India.
The document discusses initial value problems for first order differential equations and Euler's method for solving such problems numerically. It provides an example problem where Euler's method is used to find successive y-values for the differential equation dy/dx = x with the initial condition y(0) = 1. The y-values found using Euler's method are then compared to the actual solution, showing small errors that decrease as the step size h is reduced.
This document discusses various polynomial functions in MATLAB. It covers defining and manipulating polynomials, including evaluation, finding roots, addition/subtraction, multiplication/division, derivatives, and curve fitting using polynomial regression. Polynomials in MATLAB are defined as row vectors of coefficients. Key functions include polyval for evaluation, roots for finding roots, conv for multiplication, deconv for division, and polyfit for curve fitting.
The document discusses various linear algebra concepts related to vectors and projections. It defines orthogonal vectors as vectors that are perpendicular to each other, forming a right angle. It also defines orthonormal vectors as orthogonal vectors that have a unit length. The document discusses the orthogonal projection of one vector onto another vector. It explains how to find the orthogonal projection using an inner product formula. It also discusses applications of projections, including Gram-Schmidt orthogonalization and least squares curve fitting.
The document discusses three examples of connecting devices to a VGA display: 1) Drawing a diagonal line, 2) Connecting a camera to output video, 3) Connecting a keyboard to display text. It provides details on VGA signal generation, dual-port RAM for buffering between asynchronous clock domains, and example code for interfacing a PS/2 keyboard to generate on-screen text.
The document discusses attention models and their applications. Attention models allow a model to focus on specific parts of the input that are important for predicting the output. This is unlike traditional models that use the entire input equally. Three key applications are discussed: (1) Image captioning models that attend to relevant regions of an image when generating each word of the caption, (2) Speech recognition models that attend to different audio fragments when predicting text, and (3) Visual attention models for tasks like saliency detection and fixation prediction that learn to focus on important regions of an image. The document also covers techniques like soft attention, hard attention, and spatial transformer networks.
Introduction to Graph Neural Networks: Basics and Applications - Katsuhiko Is...Preferred Networks
This presentation explains basic ideas of graph neural networks (GNNs) and their common applications. Primary target audiences are students, engineers and researchers who are new to GNNs but interested in using GNNs for their projects. This is a modified version of the course material for a special lecture on Data Science at Nara Institute of Science and Technology (NAIST), given by Preferred Networks researcher Katsuhiko Ishiguro, PhD.
Artificial Intelligence, Machine Learning, Deep Learning
The 5 myths of AI
Deep Learning in action
Basics of Deep Learning
NVIDIA Volta V100 and AWS P3
The document discusses different types of convolution operations on signals. Convolution involves taking one signal, flipping and shifting it, then multiplying it sample-by-sample with another signal and summing the results. Linear convolution produces a output signal that is the sum of the two input signal lengths minus one. Circular convolution treats the signals as if they repeat periodically, producing a periodic output signal of the same period. It can approximate linear convolution if the period is long enough. The discrete Fourier transform (DFT) and its fast version, the FFT, can also be used to efficiently compute circular convolution by multiplying the signals' Fourier transforms.
Survey of Attention mechanism & Use in Computer VisionSwatiNarkhede1
This presentation contains the overview of Attention models. It also has information of the stand alone self attention model used for Computer Vision tasks.
Introduction to Spiking Neural Networks: From a Computational Neuroscience pe...Jason Tsai
The document provides an introduction to spiking neural networks (SNNs) and neuromorphic computing. It discusses the characteristics and advantages of SNNs, including their spatio-temporal nature, asynchronous processing, sparsity, and energy efficiency. It also covers basic neuroscience concepts like neurons, action potentials, synaptic plasticity, and learning rules like STDP. Common SNN models and neural encoding schemes are described. Examples of SNN applications in visual processing and pattern generation are presented. Finally, neuromorphic hardware platforms like Intel's Loihi chip are introduced.
Introduction to Spiking Neural Networks: From a Computational Neuroscience pe...Jason Tsai
Abstract:
Being the third generation of neural network models, the study of spiking neural networks is an interdisciplinary field among brain science, theoretical neuroscience, and artificial neural networks research. Recently it is gaining attention and momentum, especially in neuromorphic device design for real-time machine learning. Some of you might have heard of it, but its underneath principles probably remain unknown for most of you. In this talk, I will briefly illustrate the basic building blocks of this emerging architecture and technology.
An introduction to Realistic Ocean Rendering through FFT - Fabio Suriano - Co...Codemotion
This document provides an overview of ocean rendering techniques using Fast Fourier Transforms (FFT). It discusses how games and movies like Assassin's Creed, Crysis, and Titanic simulate ocean water through an FFT-based spectrum representation. The FFT is used to compute the discrete Fourier transform and its inverse to transform between frequency and time domains. Grid sizes of 128-512 are common. Ocean shading considers reflection and refraction using Fresnel equations. Level of detail is achieved through a top-down projected grid for consistent near-far resolution without artifacts.
MatLab is a matrix-based program used for numeric computation and visualization. It contains functions for creating matrices and performing operations on them like addition, subtraction, multiplication, etc. It also allows plotting of functions and special matrices like magic squares, identity matrices, and Toeplitz matrices. Polynomial operations can also be performed such as addition, multiplication, differentiation and evaluation.
Spiking neural network: an introduction IDalin Zhang
1) The document discusses Spiking Neural Networks (SNNs), which are a type of neural network that more closely mimic biological neural behavior.
2) It describes the Leaky Integrate-and-Fire (LIF) neuron model, which is commonly used in SNNs. The LIF model integrates inputs over time and generates spikes when the voltage exceeds a threshold.
3) Different encoding approaches are discussed for representing input data as spike trains, including rate coding, temporal coding, population coding, and the Hough Spiker Algorithm. These approaches transform real-valued inputs into spike timings.
We trained a large, deep convolutional neural network to classify the 1.2 million
high-resolution images in the ImageNet LSVRC-2010 contest into the 1000 dif-
ferent classes. On the test data, we achieved top-1 and top-5 error rates of 37.5%
and 17.0% which is considerably better than the previous state-of-the-art. The
neural network, which has 60 million parameters and 650,000 neurons, consists
of five convolutional layers, some of which are followed by max-pooling layers,
and three fully-connected layers with a final 1000-way softmax. To make train-
ing faster, we used non-saturating neurons and a very efficient GPU implemen-
tation of the convolution operation. To reduce overfitting in the fully-connected
layers we employed a recently-developed regularization method called “dropout”
that proved to be very effective. We also entered a variant of this model in the
ILSVRC-2012 competition and achieved a winning top-5 test error rate of 15.3%,
compared to 26.2% achieved by the second-best entry.
1. Autoencoders are unsupervised neural networks that are useful for dimensionality reduction and clustering. They compress the input into a latent-space representation then reconstruct the output from this representation.
2. Deep autoencoders stack multiple autoencoder layers to learn hierarchical representations of the data. Each layer is trained sequentially.
3. Variational autoencoders use probabilistic encoders and decoders to learn a Gaussian latent space. They can generate new samples from the learned data distribution.
This document discusses independent component analysis (ICA) for blind source separation. ICA is a method to estimate original signals from observed signals consisting of mixed original signals and noise. It introduces the ICA model and approach, including whitening, maximizing non-Gaussianity using kurtosis and negentropy, and fast ICA algorithms. The document provides examples applying ICA to separate images and discusses approaches to improve ICA, including using differential filtering. ICA is an important technique for blind source separation and independent component estimation from observed signals.
This document provides an overview of software testing concepts. It discusses different types of testing like unit testing, functional testing, error path testing, boundary value testing, and equivalence partitioning. It also covers test strategies like golden path testing, black box testing, and white box testing. The purpose of a tester is explained as quantifying risk to make decisions that improve confidence and quality.
Software Testing: A Research Travelogue (2000–2014)Alex Orso
The document discusses the major developments and contributions in the field of software testing research over the past 14 years from 2000 to 2014. It identifies the most significant research contributions as automated test input generation techniques like symbolic execution, search-based testing, and random testing. It also discusses important testing strategies, empirical studies and infrastructure developments, and practical contributions to software testing. Open challenges and opportunities discussed include testing real-world systems, handling oracles, testing non-functional properties, and leveraging cloud and crowd-based approaches.
The document describes Weddle's rule, a numerical integration method. It provides background on Thomas Weddle, who introduced the rule. Weddle's rule approximates integrals using a 6th degree Newton-Cotes formula. The document explains the formula for Weddle's rule, provides an example calculation, and discusses applications for numerical integration such as calculating power and energy over time.
The document defines and provides equations for various special functions including the beta and gamma functions, Bessel function, error function, complementary error function, Heaviside's unit step function, pulse function, sinusoidal pulse, rectangle function, gate function, Dirac delta function, signum function, saw tooth wave function, triangular wave function, half-wave and full-wave rectified sinusoidal functions, and square wave function. The author is N. B. Vyas from the Department of Mathematics at Atmiya Institute of Tech. and Science in Rajkot, India.
The document discusses initial value problems for first order differential equations and Euler's method for solving such problems numerically. It provides an example problem where Euler's method is used to find successive y-values for the differential equation dy/dx = x with the initial condition y(0) = 1. The y-values found using Euler's method are then compared to the actual solution, showing small errors that decrease as the step size h is reduced.
This document discusses various polynomial functions in MATLAB. It covers defining and manipulating polynomials, including evaluation, finding roots, addition/subtraction, multiplication/division, derivatives, and curve fitting using polynomial regression. Polynomials in MATLAB are defined as row vectors of coefficients. Key functions include polyval for evaluation, roots for finding roots, conv for multiplication, deconv for division, and polyfit for curve fitting.
The document discusses various linear algebra concepts related to vectors and projections. It defines orthogonal vectors as vectors that are perpendicular to each other, forming a right angle. It also defines orthonormal vectors as orthogonal vectors that have a unit length. The document discusses the orthogonal projection of one vector onto another vector. It explains how to find the orthogonal projection using an inner product formula. It also discusses applications of projections, including Gram-Schmidt orthogonalization and least squares curve fitting.
The document discusses three examples of connecting devices to a VGA display: 1) Drawing a diagonal line, 2) Connecting a camera to output video, 3) Connecting a keyboard to display text. It provides details on VGA signal generation, dual-port RAM for buffering between asynchronous clock domains, and example code for interfacing a PS/2 keyboard to generate on-screen text.
The document discusses attention models and their applications. Attention models allow a model to focus on specific parts of the input that are important for predicting the output. This is unlike traditional models that use the entire input equally. Three key applications are discussed: (1) Image captioning models that attend to relevant regions of an image when generating each word of the caption, (2) Speech recognition models that attend to different audio fragments when predicting text, and (3) Visual attention models for tasks like saliency detection and fixation prediction that learn to focus on important regions of an image. The document also covers techniques like soft attention, hard attention, and spatial transformer networks.
Introduction to Graph Neural Networks: Basics and Applications - Katsuhiko Is...Preferred Networks
This presentation explains basic ideas of graph neural networks (GNNs) and their common applications. Primary target audiences are students, engineers and researchers who are new to GNNs but interested in using GNNs for their projects. This is a modified version of the course material for a special lecture on Data Science at Nara Institute of Science and Technology (NAIST), given by Preferred Networks researcher Katsuhiko Ishiguro, PhD.
Artificial Intelligence, Machine Learning, Deep Learning
The 5 myths of AI
Deep Learning in action
Basics of Deep Learning
NVIDIA Volta V100 and AWS P3
The document discusses different types of convolution operations on signals. Convolution involves taking one signal, flipping and shifting it, then multiplying it sample-by-sample with another signal and summing the results. Linear convolution produces a output signal that is the sum of the two input signal lengths minus one. Circular convolution treats the signals as if they repeat periodically, producing a periodic output signal of the same period. It can approximate linear convolution if the period is long enough. The discrete Fourier transform (DFT) and its fast version, the FFT, can also be used to efficiently compute circular convolution by multiplying the signals' Fourier transforms.
Survey of Attention mechanism & Use in Computer VisionSwatiNarkhede1
This presentation contains the overview of Attention models. It also has information of the stand alone self attention model used for Computer Vision tasks.
Introduction to Spiking Neural Networks: From a Computational Neuroscience pe...Jason Tsai
The document provides an introduction to spiking neural networks (SNNs) and neuromorphic computing. It discusses the characteristics and advantages of SNNs, including their spatio-temporal nature, asynchronous processing, sparsity, and energy efficiency. It also covers basic neuroscience concepts like neurons, action potentials, synaptic plasticity, and learning rules like STDP. Common SNN models and neural encoding schemes are described. Examples of SNN applications in visual processing and pattern generation are presented. Finally, neuromorphic hardware platforms like Intel's Loihi chip are introduced.
Introduction to Spiking Neural Networks: From a Computational Neuroscience pe...Jason Tsai
Abstract:
Being the third generation of neural network models, the study of spiking neural networks is an interdisciplinary field among brain science, theoretical neuroscience, and artificial neural networks research. Recently it is gaining attention and momentum, especially in neuromorphic device design for real-time machine learning. Some of you might have heard of it, but its underneath principles probably remain unknown for most of you. In this talk, I will briefly illustrate the basic building blocks of this emerging architecture and technology.
An introduction to Realistic Ocean Rendering through FFT - Fabio Suriano - Co...Codemotion
This document provides an overview of ocean rendering techniques using Fast Fourier Transforms (FFT). It discusses how games and movies like Assassin's Creed, Crysis, and Titanic simulate ocean water through an FFT-based spectrum representation. The FFT is used to compute the discrete Fourier transform and its inverse to transform between frequency and time domains. Grid sizes of 128-512 are common. Ocean shading considers reflection and refraction using Fresnel equations. Level of detail is achieved through a top-down projected grid for consistent near-far resolution without artifacts.
MatLab is a matrix-based program used for numeric computation and visualization. It contains functions for creating matrices and performing operations on them like addition, subtraction, multiplication, etc. It also allows plotting of functions and special matrices like magic squares, identity matrices, and Toeplitz matrices. Polynomial operations can also be performed such as addition, multiplication, differentiation and evaluation.
Spiking neural network: an introduction IDalin Zhang
1) The document discusses Spiking Neural Networks (SNNs), which are a type of neural network that more closely mimic biological neural behavior.
2) It describes the Leaky Integrate-and-Fire (LIF) neuron model, which is commonly used in SNNs. The LIF model integrates inputs over time and generates spikes when the voltage exceeds a threshold.
3) Different encoding approaches are discussed for representing input data as spike trains, including rate coding, temporal coding, population coding, and the Hough Spiker Algorithm. These approaches transform real-valued inputs into spike timings.
We trained a large, deep convolutional neural network to classify the 1.2 million
high-resolution images in the ImageNet LSVRC-2010 contest into the 1000 dif-
ferent classes. On the test data, we achieved top-1 and top-5 error rates of 37.5%
and 17.0% which is considerably better than the previous state-of-the-art. The
neural network, which has 60 million parameters and 650,000 neurons, consists
of five convolutional layers, some of which are followed by max-pooling layers,
and three fully-connected layers with a final 1000-way softmax. To make train-
ing faster, we used non-saturating neurons and a very efficient GPU implemen-
tation of the convolution operation. To reduce overfitting in the fully-connected
layers we employed a recently-developed regularization method called “dropout”
that proved to be very effective. We also entered a variant of this model in the
ILSVRC-2012 competition and achieved a winning top-5 test error rate of 15.3%,
compared to 26.2% achieved by the second-best entry.
1. Autoencoders are unsupervised neural networks that are useful for dimensionality reduction and clustering. They compress the input into a latent-space representation then reconstruct the output from this representation.
2. Deep autoencoders stack multiple autoencoder layers to learn hierarchical representations of the data. Each layer is trained sequentially.
3. Variational autoencoders use probabilistic encoders and decoders to learn a Gaussian latent space. They can generate new samples from the learned data distribution.
This document discusses independent component analysis (ICA) for blind source separation. ICA is a method to estimate original signals from observed signals consisting of mixed original signals and noise. It introduces the ICA model and approach, including whitening, maximizing non-Gaussianity using kurtosis and negentropy, and fast ICA algorithms. The document provides examples applying ICA to separate images and discusses approaches to improve ICA, including using differential filtering. ICA is an important technique for blind source separation and independent component estimation from observed signals.
This document provides an overview of software testing concepts. It discusses different types of testing like unit testing, functional testing, error path testing, boundary value testing, and equivalence partitioning. It also covers test strategies like golden path testing, black box testing, and white box testing. The purpose of a tester is explained as quantifying risk to make decisions that improve confidence and quality.
Software Testing: A Research Travelogue (2000–2014)Alex Orso
The document discusses the major developments and contributions in the field of software testing research over the past 14 years from 2000 to 2014. It identifies the most significant research contributions as automated test input generation techniques like symbolic execution, search-based testing, and random testing. It also discusses important testing strategies, empirical studies and infrastructure developments, and practical contributions to software testing. Open challenges and opportunities discussed include testing real-world systems, handling oracles, testing non-functional properties, and leveraging cloud and crowd-based approaches.
Speeding-up Software Testing With Computational IntelligenceAnnibale Panichella
Software testing is a crucial activity to assess the correct behavior of a program. However, it is also costly since it consumes a large ratio of software development time. For this reason, researchers have investigated techniques to automate the process of creating test cases. The key idea is to use meta-heuristics (e.g., Genetic Algorithms) to automatically generate test cases that reveal software failures. In this talk, I will present a case study in the automotive and showing the larger effectiveness and efficiency of meta-heuristics compared to manual testing.
Genetic programming is a model of programming that uses biological evolution concepts to solve complex problems. It represents computer programs as parse trees and evolves populations of programs through genetic operations like mutation and crossover. A genetic programming system randomly generates an initial population of programs and uses a fitness function to evaluate them. The fittest programs survive and reproduce new programs to create subsequent generations until a satisfactory solution is found. Genetic programming has been successfully applied to problems like maze navigation, symbolic regression, and neural network optimization.
In the modern world, we are permanently using, leveraging, interacting with, and relying upon systems of ever higher sophistication, ranging from our cars, recommender systems in eCommerce, and networks when we go online, to integrated circuits when using our PCs and smartphones, security-critical software when accessing our bank accounts, and spreadsheets for financial planning and decision making. The complexity of these systems coupled with our high dependency on them implies both a non-negligible likelihood of system failures, and a high potential that such failures have significant negative effects on our everyday life. For that reason, it is a vital requirement to keep the harm of emerging failures to a minimum, which means minimizing the system downtime as well as the cost of system repair. This is where model-based diagnosis comes into play.
Model-based diagnosis is a principled, domain-independent approach that can be generally applied to troubleshoot systems of a wide variety of types, including all the ones mentioned above. It exploits and orchestrates techniques for knowledge representation, automated reasoning, heuristic problem solving, intelligent search, learning, stochastics, statistics, decision making under uncertainty, as well as combinatorics and set theory to detect, localize, and fix faults in abnormally behaving systems.
In this talk, we will give an introduction to the topic of model-based diagnosis, point out the major challenges in the field, and discuss a selection of approaches from our research addressing these challenges. For instance, we will present methods for the optimization of the time and memory performance of diagnosis systems, show efficient techniques for a semi-automatic debugging by interacting with a user or expert, and demonstrate how our algorithms can be effectively leveraged in important application domains such as scheduling or the Semantic Web.
The document summarizes recent research on using machine learning to improve the accuracy of static code analysis tools in identifying actionable warnings. It discusses challenges with high false positive rates in static analysis tools and describes several studies that aimed to address this. The key points are:
1) Multiple studies have worked to reduce false positives by extracting features from code and using machine learning to classify warnings as actionable or not.
2) However, issues with data leakage across features and instances limited the effectiveness of early models.
3) More recent collaboration between research groups applied techniques like boundary, label, learner, and instance engineering to refine the data and achieved preliminary improved results.
4) Open science and collaboration helped integrate findings
The job of software tester - How do I see software testingAli LABBENE
The document provides an overview of the job of a software tester and discusses software testing techniques. It begins with an example of testing a program that checks if three integer inputs form a valid triangle. Various black-box testing techniques like equivalence partitioning and boundary value analysis are demonstrated on this example. Common software bugs and failures from safety-critical systems are also discussed. The document emphasizes the importance of testing in assuring software safety and quality. It provides information on standards for testing critical software. Key trends in software testing from an industry report are highlighted. The role of the International Software Testing Qualifications Board in standardizing testing practices is briefly described. Popular books on software testing by Glenford Myers and Boris Beizer are also mentioned.
This document discusses how Code Hunt crowdsources code and processes through an educational gaming platform. It began as dynamic symbolic execution tool Pex that was adapted into a game called Coding Duel. This evolved into Code Hunt, an online platform where users write code in the browser to solve puzzles. Code Hunt provides test cases to give feedback until the user's code matches the secret implementation. It has been used by hundreds of thousands of students to learn programming in a game-like environment. The document argues that Code Hunt can scale crowdsourcing of code and processes while identifying top coders through competitive coding contests hosted on the platform. Code Hunt data from these contests has been publicly released to further research.
The document discusses artificial intelligence and provides an overview of key topics including:
1. Natural language processing techniques like text vectorization, seq2seq modeling, attention mechanisms, and transformers.
2. The use of AI in physics and responsible AI approaches like explainable, safe, and fair AI.
3. An introduction to foundational AI concepts like the four paradigms of science, types of machine learning, deep learning models, and applications of AI in areas such as computer vision and robotics.
The document discusses mutating and testing tests. It introduces the concept of mutation analysis, where tests are evaluated by seeding real bugs into the code and checking if the tests detect these bugs. The document provides an example of applying mutation analysis to a factorial function code and test cases. It finds bugs in the test cases like weak oracles and missing test inputs. The document also compares the Pit mutation testing tool with the Descartes tool, finding Descartes generates fewer but coarser-grained mutants, making it more scalable for large projects.
The document provides an overview of software testing fundamentals including:
1. It discusses key testing concepts like error, fault, failure and how testing helps build confidence and reduce costs. Testing aims to find faults and prove software meets requirements.
2. Testing challenges are discussed like the impossibility of exhaustive testing due to huge number of combinations. Prioritization is important given limited time.
3. Principles of testing are covered such as defects clustering, absence of errors fallacy, and how early testing avoids fault multiplication. Testing must be context dependent.
To define methods, invoke methods, and pass arguments to a method (§5.2-5.5).
To develop reusable code that is modular, easy-to-read, easy-to-debug, and easy-to-maintain. (§5.6).
To use method overloading and understand ambiguous overloading (§5.7).
To design and implement overloaded methods (§5.8).
To determine the scope of variables (§5.9).
To know how to use the methods in the Math class (§§5.10-5.11).
To learn the concept of method abstraction (§5.12).
To design and implement methods using stepwise refinement (§5.12).
- The document discusses the speaker's 25 years of experience applying AI techniques to software engineering projects. It covers early work in the 1990s on fault prediction and the challenges of applying machine learning at that time. It then discusses subsequent work in areas like search-based software engineering, natural language processing for requirements engineering, and using simulation and search techniques for testing autonomous vehicle systems. The speaker reflects on both the benefits and challenges of these different AI applications in software engineering.
On the Diffusion of Test Smells in Automatically Generated Test Code: An Empi...Fabio Palomba
The role of software testing in the software development process is widely recognized as a key activity for successful projects. This is the reason why in the last decade several automatic unit test generation tools have been proposed, focusing particularly on high code coverage. Despite the effort spent by the research community, there is still a lack of empirical investigation aimed at analyzing the characteristics of the produced test code. Indeed, while some studies inspected the effectiveness and the usability of these tools in practice, it is still unknown whether test code is maintainable. In this paper, we conducted a large scale empirical study in order to analyze the diffusion of bad design solutions, namely test smells, in automatically generated unit test classes. Results of the study show the high diffusion of test smells as well as the frequent co-occurrence of different types of design problems. Finally we found that all test smells have strong positive correlation with structural characteristics of the systems such as size or number of classes.
This document discusses how machines can make decisions using machine learning approaches. It provides an overview of machine learning vocabulary and techniques including supervised learning methods like regression and classification. It also discusses unsupervised learning and examples of clustering emails. The document then demonstrates simple linear and logistic regression models to predict outputs for given inputs. It discusses evaluating models through error measurement and mentions some other machine learning techniques. Finally, it provides an overview of neural networks including feedforward networks and different types like convolutional and recurrent neural networks.
This document discusses how machines can make decisions using machine learning approaches. It provides an overview of machine learning vocabulary and techniques including supervised learning methods like regression and classification. It also discusses unsupervised learning and examples of clustering emails. The document then demonstrates simple linear and logistic regression models to predict outputs given inputs. It discusses evaluating models through error measurement and mentions several other machine learning techniques. Finally, it provides an overview of neural networks including feedforward networks and different types like convolutional and recurrent neural networks.
Advances in Unit Testing: Theory and PracticeTao Xie
Here are the key steps to specify and test the IntSet class using Pex:
1. Define the IntSet class with the required methods like insert, member, remove.
2. Add the [PexClass] attribute to the class to enable Pex testing.
3. Add [PexMethod] attributes to the methods you want Pex to generate tests for, like insert and member.
4. Within the test methods, use PexAssume to specify preconditions and PexAssert to specify postconditions.
5. Run Pex by building the project. Pex will generate test inputs to cover different paths in the code and validate assumptions/assertions.
6. Ex
Applications of Machine Learning and Metaheuristic Search to Security TestingLionel Briand
This document discusses testing web application firewalls (WAFs) for SQL injection (SQLi) vulnerabilities. It states that the testing goal is to generate test cases that result in executable malicious SQL statements that can bypass the WAF. It also notes that WAF filter rules often need customization to avoid false positives and protect against new attacks, but that customization is error-prone due to complex rules, time/resource constraints, and a lack of automated tools.
The Use of Static Code Analysis When Teaching or Developing Open-Source SoftwareAndrey Karpov
The document discusses using static code analysis when teaching or developing open-source software. It outlines how static analysis can help instructors check student homework and projects more efficiently, and help students learn about error patterns. When using static analysis for open-source projects, it recommends integrating it into developers' workflows locally and via continuous integration systems. Regular use is key to maximizing its benefits for finding and fixing bugs.
This document summarizes the history and activities of SIG-FPAI, a special interest group on artificial intelligence and natural language processing in Japan. It discusses past annual meetings and key topics discussed. It also provides an overview of the development of AI and the internet in Japan from the 1980s to present day. Key events and technologies discussed include the emergence of ISPs in the early 1990s, the rise of search engines and e-commerce in the late 1990s/early 2000s, and the growth of social media and mobile internet in the mid-2000s.
MIP Award presentation at the IEEE International Conference on Software Analy...Annibale Panichella
Presentation for the Most Influential Paper (MIP) award at the IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER) 2024
Abstract:
Existing defect prediction models use product or process metrics and machine learning methods to identify defect- prone source code entities. Different classifiers (e.g., linear regression, logistic regression, or classification trees) have been investigated in the last decade. The results achieved so far are sometimes contrasting and do not show a clear winner. In this paper we present an empirical study aiming at statistically analyzing the equivalence of different defect predictors. We also propose a combined approach, coined as CODEP (COmbined DEfect Predictor), that employs the classification provided by different machine learning techniques to improve the detection of defect-prone entities. The study was conducted on 10 open source software systems and in the context of cross-project defect prediction, that represents one of the main challenges in the defect prediction field. The statistical analysis of the results indicates that the investigated classifiers are not equivalent and they can complement each other. This is also confirmed by the superior prediction accuracy achieved by CODEP when compared to stand-alone defect predictors.
Breaking the Silence: the Threats of Using LLMs in Software EngineeringAnnibale Panichella
Presentation of our work presented at ICSE 2024 (NIER track) in Lisbon
Abstract:
Large Language Models (LLMs) have gained considerable traction within the Software Engineering (SE) community, impacting various SE tasks from code completion to test generation, from program repair to code summarization. Despite their promise, researchers must still be careful as numerous intricate factors can influence the outcomes of experiments involving LLMs.
This paper initiates an open discussion on potential threats to the validity of LLM-based research including issues such as closed-source models, possible data leakage between LLM training data and research evaluation, and the reproducibility of LLM-based findings.
In response, this paper proposes a set of guidelines tailored for SE researchers and Language Model (LM) providers to mitigate these concerns.
The implications of the guidelines are illustrated using existing good practices followed by LLM providers and a practical example for SE researchers in the context of test case generation.
Searching for Quality: Genetic Algorithms and Metamorphic Testing for Softwar...Annibale Panichella
More machine learning (ML) models are introduced to the field of Software Engineering (SE) and reached a stage of maturity to be considered for real-world use; But the real world is complex, and testing these models lacks often in explainability, feasibility and computational capacities. Existing research introduced meta-morphic testing to gain additional insights and certainty about the model, by applying semantic-preserving changes to input-data while observing model-output. As this is currently done at random places, it can lead to potentially unrealistic datapoints and high computational costs. With this work, we introduce genetic search as an aid for metamorphic testing in SE ML. Exploiting the delta in output as a fitness function, the evolutionary intelligence optimizes the transformations to produce higher deltas with less changes. We perform a case study minimizing F1 and MRR for Code2Vec on a representative sample from java-small with both genetic and random search. Our results show that within the same amount of time, genetic search was able to achieve a decrease of 10% in F1 while random search produced 3% drop.
A Fast Multi-objective Evolutionary Approach for Designing Large-Scale Optica...Annibale Panichella
Spatial mode division de-multiplexing of optical signals has many real-world applications, such as quantum computing and both classical and quantum optical communication. In this context, it is crucial to develop devices able to efficiently sort optical signals according to the optical mode they belong to and route them on different paths. Depending on the mode selected, this problem can be very hard to tackle. Recently, researchers have proposed using multi-objective evolutionary algorithms (MOEAs) ---and NSGA-II in particular--- combined with Linkage Learning (LL) to automate the process of design mode sorter. However, given the very large-search scale of the problem, the existing evolutionary-based solutions have a very slow convergence rate. In this paper, we proposed a novel approach for mode sorter design that combines (1) stochastic linkage learning, (2) the adaptive geometry estimation-based MOEA (AGE-MOEA-II), and (3) an adaptive mutation operator. Our experiments with two- and three-objectives (beams) show that our approach is faster (better convergence rate) and produces better mode sorters (closer to the ideal solutions) than the state-of-the-art approach. A direct comparison with the vanilla NSGA-II and AGE-MOEA-II also further confirms the importance of adopting LL in this domain.
An Improved Pareto Front Modeling Algorithm for Large-scale Many-Objective Op...Annibale Panichella
A key idea in many-objective optimization is to approximate the optimal Pareto front using a set of representative non-dominated solutions. The produced solution set should be close to the optimal front (convergence) and well-diversified (diversity). Recent studies have shown that measuring both convergence and diversity depends on the shape (or curvature) of the Pareto front. In recent years, researchers have proposed evolutionary algorithms that model the shape of the non-dominated front to define environmental selection strategies that adapt to the underlying geometry. This paper proposes a novel method for non-dominated front modeling using the Newton-Raphson iterative method for roots finding. Second, we compute the distance (diversity) between each pair of non-dominated solutions using geodesics, which are generalizations of the distance on Riemann manifolds (curved topological spaces). We have introduced an evolutionary algorithm within the Adaptive Geometry Estimation based MOEA (AGE-MOEA) framework, which we called AGE-MOEA-II. Computational experiments with 17 problems from the WFG and SMOP benchmarks show that AGE-MOEA-II outperforms its predecessor AGE-MOEA as well as other state-of-the-art many-objective algorithms, ie, NSGA-III, MOEA/D, VaEA, and LMEA.
This presentation describes the results published in the following paper published in the Journal INFORMATION AND SOFTWARE TECHNOLOGY
TITLE: A Large Scale Empirical Comparison of State-of-the-art Search-based Test Case Generators
AUTHORS: Annibale Panichella, Fitsum Kifetew, Paolo Tonella
ABSTRACT: Context: Replication studies and experiments form an important foundation in advancing scientific research. While their prevalence in Software Engineering is increasing, there is still more to be done. Objective: This article aims to extend our previous replication study on search-based test generation techniques by performing a large-scale empirical comparison with further techniques from state of the art. Method: We designed a comprehensive experimental study involving six techniques, a benchmark composed of 180 non-trivial Java classes, and a total of 21,600 independent executions. Metrics regarding the effectiveness and efficiency of the techniques were collected and analyzed by means of statistical methods. Results: Our empirical study shows that single-target approaches are generally outperformed by multi-target approaches, while within the multi-target approaches, DynaMOSA/MOSA, which are based on many-objective optimization, outperform the others, in particular for complex classes. Conclusion: The results obtained from our large-scale empirical investigation con rm what has been reported in previous studies, while also highlighting striking differences and novel observations. Future studies, on different benchmarks and considering additional techniques, could further reinforce and extend our findings.
Incremental Control Dependency Frontier Exploration for Many-Criteria Test C...Annibale Panichella
The presentation was given at the 10th International Symposium on Seach-Based Software Engineering (SSBSE 2018)
Abstract:
Several criteria have been proposed over the years for measuring test suite adequacy. Each criterion can be converted into a specific objective function to optimize with search-based techniques in an attempt to generate test suites achieving the highest possible coverage for that criterion. Recent work has tried to optimize for multiple-criteria at once by constructing a single objective function obtained as a weighted sum of the objective functions of the respective criteria. However, this solution suffers the problem of sum scalarization, i.e., differences along the various dimensions being optimized get lost when such dimensions are projected into a single value. Recent advances in SBST formulated coverage as a many-objective optimization problem rather than applying sum scalarization. Starting from this formulation, in this work, we apply many-objective test generation that handles multiple adequacy criteria simultaneously. To scale the approach to the big number of objectives to be optimized at the same time, we adopt an incremental strategy, where only coverage targets in the control dependency frontier are considered until the frontier is expanded by covering a previously uncovered target.
We report on the advances in this sixth edition of the JUnit tool
competitions. This year the contest introduces new benchmarks to
assess the performance of JUnit testing tools on different types of
real-world software projects. Following on the statistical analyses
from the past contest work, we have extended it with the performance of the combined tool aiming to beat the human-made tests. Overall,
the 6th competition evaluates four automated JUnit testing tools
taking as baseline human written test cases for the selected benchmark
projects. The paper details the modications performed to
the methodology and provides full results of the competition.
The document summarizes the 5th round of a Java unit testing tool competition. It describes the infrastructure used, including modifications to work with libraries not in DEFECT4J and a new tool to detect flaky tests. 69 classes across 8 projects were used as benchmarks. The results showed EvoSuite performed best overall based on generated test coverage, effectiveness on real and mutated code, and test quality metrics. Statistical analysis confirmed EvoSuite was better than the other 3 participating tools. Lessons included benefits of statistical analysis and selecting non-trivial test classes.
To reduce the effort developers have to make for crash debugging, researchers have proposed several solutions for automatic failure reproduction.
Recent advances proposed the usage of symbolic execution, mutation analysis and directed model checking as underling techniques for post-failure analysis of crash stack traces.
However, existing approaches still cannot reproduce many real-world crashes due to various limitations, such as environment dependencies, path explosion, and time complexity.
In this paper, we present EvoCrash, a post-failure approach which uses a novel Guided Genetic Algorithm (GGA) to cope with the large search space characterizing real-world software programs, and thereby address major challenges in automated crash replication.
Results of an empirical study on three open-source systems show that EvoCrash can successfully replicate 33 (66%) of real-world crashes, thereby outperforming the three cutting-edge crash replication techniques.
Manual crash reproduction is a labor-intensive and timeconsuming task. Therefore, several solutions have been proposed in literature for automatic crash reproduction, including generating unit tests via symbolic execution and mutation analysis. However, various limitations adversely a ect the capabilities of the existing solutions in covering a wider range of crashes because generating helpful tests that trigger speci c execution paths is particularly challenging. In this paper, we propose a new solution for automatic crash reproduction based on evolutionary unit test generation techniques. The proposed solution exploits crash data from collected stack traces to guide search-based algorithms toward the generation of unit test cases that can reproduce the original crashes. Results from our preliminary study on real crashes from Apache Commons libraries show that our solution can successfully reproduce crashes which are not reproducible by two other state-of-art techniques.
Parameterizing and Assembling IR-based Solutions for SE Tasks using Genetic A...Annibale Panichella
This document proposes using genetic algorithms to parameterize and assemble information retrieval (IR)-based solutions for software engineering tasks. The goal is to find an optimal configuration of IR parameters like term extraction, stopword removal, weighting, and distance functions. The approach evaluates different IR configurations based on how well they cluster related documents, as measured by silhouette coefficient. Empirical tests on traceability recovery and duplicate bug detection tasks show this "GA-IR" approach finds configurations comparable to ideal ones and outperforming baselines. The clustering hypothesis - that better document clusters correlate with better IR performance - is also supported.
Business applications are more and more collaborative (cross-domains, cross-devices, service composition). Security shall focus on the overall application scenario including the interplay between its entities/devices/services, not only on the isolated systems within it. In this paper we propose the Security Threat Identification And TEsting (STIATE) toolkit to support development teams toward security assessment of their under-development applications focusing on subtle security logic flaws that may go undetected by using current industrial technology. At design-time, STIATE supports the development teams toward threat modeling and analysis by identifying automatically potential threats (via model checking and mutation techniques) on top of sequence diagrams enriched with security annotations (including {whatif} conditions). At run-time, STIATE supports the development teams toward testing by exploiting the identified threats to automatically generate and execute test-cases on the up and running application. We demonstrate the usage of the STIATE toolkit on an application scenario employing the SAML Single Sign-On multi-party protocol, a well-known industrial security standard largely studied in previous literature.
Results for EvoSuite-MOSA at the Third Unit Testing Tool CompetitionAnnibale Panichella
The document describes MOSA, a new many-objective sorting algorithm for test case prioritization and generation. MOSA reformulates branch coverage as a multi-objective optimization problem by defining an objective function for each branch. It then uses a genetic algorithm and preference criterion to iteratively generate test cases that optimize coverage of multiple branches at once. MOSA was implemented in the Evosuite-MOSA tool and achieved competitive results in the Third Unit Testing Tool Competition, requiring less time than other high-scoring tools to achieve similar coverage levels. However, Evosuite-MOSA also encountered some crashes and limitations when handling certain classes in the competition benchmark.
Adaptive User Feedback for IR-based Traceability RecoveryAnnibale Panichella
Traceability recovery allows software engineers to understand the interconnections among software artefacts and, thus, it provides an important support to software maintenance activities. In the last decade, Information Retrieval (IR) has been widely adopted as core technology of semi-automatic tools to extract traceability links between artefacts according to their textual information. However, a widely known problem of IR-based methods is that some artefacts may share more words with non-related artefacts than with related ones. To overcome this problem, enhancing strategies have been proposed in literature. One of these strategies is relevance feedback, which allows to modify the textual similarity according to information about links classified by the users. Even though this technique is widely used for natural language documents, previous work has demonstrated that relevance feedback is not always useful for software artefacts. In this paper, we propose an adaptive version of relevance feedback that, unlike the standard version, considers the characteristics of both (i) the software artefacts and (ii) the previously classified links for deciding whether and how to apply the feedback. An empirical evaluation conducted on three systems suggests that the adaptive relevance feedback outperforms both a pure IR-based method and the standard feedback.
Diversity mechanisms for evolutionary populations in Search-Based Software En...Annibale Panichella
This document discusses mechanisms for maintaining diversity in evolutionary algorithms. It begins by explaining the importance of balancing exploration and exploitation. Several techniques for preserving diversity are then presented, including modifying genetic operators, changing the objective function, and applying statistical methods. Empirical evaluations demonstrate how diversity mechanisms can improve performance in search-based software engineering problems like test data generation and test suite optimization, which often suffer from premature convergence and getting stuck in local optima due to loss of diversity. Parameter tuning techniques like adjusting the mutation rate and niching methods like fitness sharing are also described as ways to explicitly promote diversity.
Estimating the Evolution Direction of Populations to Improve Genetic AlgorithmsAnnibale Panichella
Meta-heuristics have been successfully used to solve a wide variety of problems. However, one issue many techniques have is their risk of being trapped into local optima, or to create a limited variety of solutions (problem known as ``population drift''). During recent and past years, different kinds of techniques have been proposed to deal with population drift, for example hybridizing genetic algorithms with local search techniques or using niche techniques.
This paper proposes a technique, based on Singular Value Decomposition (SVD), to enhance Genetic Algorithms (GAs) population diversity. SVD helps to estimate the evolution direction and drive next generations towards orthogonal dimensions.
The proposed SVD-based GA has been evaluated on 11 benchmark problems and compared with a simple GA and a GA with a distance-crowding schema. Results indicate that SVD-based GA achieves significantly better solutions and exhibits a quicker convergence than the alternative techniques.
When and How Using Structural Information to Improve IR-Based Traceability Re...Annibale Panichella
Traceability recovery is a key software maintenance activity in which software engineers extract the relationships among software artifacts. Information Retrieval (IR) has been widely accepted as a method for automated traceability recovery based on the textual similarity among the software artifacts. However, a notorious difficulty for IR-based methods is that artifacts may be related even if they are not textually similar. A growing body of work addresses this challenge by combining IR-based methods with structural information from source code. Unfortunately, the accuracy of such methods is highly dependent on the IR methods. If IR methods perform poorly, the combined approaches may perform even worse.
In this paper, we propose to use the feedback provided by software engineers when classifying candidate links to regulate the effect of using structural information. Specifically, our approach only considers structural information when the traceability links from the IR methods are verified by developers and classified as correct links. An empirical evaluation conducted on three systems suggests that our approach outperforms both a pure IR-based method and a simple approach for combining textual and structural information.
Cross-project defect prediction is very appealing because (i) it allows predicting defects in projects for which the availability of data is limited, and (ii) it allows producing generalizable prediction models. However, existing research suggests that cross-project prediction is particularly challenging and, due to heterogeneity of projects, prediction accuracy is not always very good.
This paper proposes a novel, multi-objective approach for cross-project defect prediction, based on a multi-objective logistic regression model built using a genetic algorithm. Instead of providing the software engineer with a single predictive model, the multi-objective approach allows software engineers to choose predictors achieving a compromise between number of likely defect-prone artifacts (effectiveness) and LOC to be analyzed/tested (which can be considered as a proxy of the cost of code inspection).
Results of an empirical evaluation on 10 datasets from the Promise repository indicate the superiority and the usefulness of the multi-objective approach with respect to single-objective predictors. Also, the proposed approach outperforms an alternative approach for cross-project prediction, based on local prediction upon clusters of similar classes.
“An Outlook of the Ongoing and Future Relationship between Blockchain Technologies and Process-aware Information Systems.” Invited talk at the joint workshop on Blockchain for Information Systems (BC4IS) and Blockchain for Trusted Data Sharing (B4TDS), co-located with with the 36th International Conference on Advanced Information Systems Engineering (CAiSE), 3 June 2024, Limassol, Cyprus.
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024Neo4j
Neha Bajwa, Vice President of Product Marketing, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
Communications Mining Series - Zero to Hero - Session 1DianaGray10
This session provides introduction to UiPath Communication Mining, importance and platform overview. You will acquire a good understand of the phases in Communication Mining as we go over the platform with you. Topics covered:
• Communication Mining Overview
• Why is it important?
• How can it help today’s business and the benefits
• Phases in Communication Mining
• Demo on Platform overview
• Q/A
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
UiPath Test Automation using UiPath Test Suite series, part 6DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 6. In this session, we will cover Test Automation with generative AI and Open AI.
UiPath Test Automation with generative AI and Open AI webinar offers an in-depth exploration of leveraging cutting-edge technologies for test automation within the UiPath platform. Attendees will delve into the integration of generative AI, a test automation solution, with Open AI advanced natural language processing capabilities.
Throughout the session, participants will discover how this synergy empowers testers to automate repetitive tasks, enhance testing accuracy, and expedite the software testing life cycle. Topics covered include the seamless integration process, practical use cases, and the benefits of harnessing AI-driven automation for UiPath testing initiatives. By attending this webinar, testers, and automation professionals can gain valuable insights into harnessing the power of AI to optimize their test automation workflows within the UiPath ecosystem, ultimately driving efficiency and quality in software development processes.
What will you get from this session?
1. Insights into integrating generative AI.
2. Understanding how this integration enhances test automation within the UiPath platform
3. Practical demonstrations
4. Exploration of real-world use cases illustrating the benefits of AI-driven test automation for UiPath
Topics covered:
What is generative AI
Test Automation with generative AI and Open AI.
UiPath integration with generative AI
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Removing Uninteresting Bytes in Software FuzzingAftab Hussain
Imagine a world where software fuzzing, the process of mutating bytes in test seeds to uncover hidden and erroneous program behaviors, becomes faster and more effective. A lot depends on the initial seeds, which can significantly dictate the trajectory of a fuzzing campaign, particularly in terms of how long it takes to uncover interesting behaviour in your code. We introduce DIAR, a technique designed to speedup fuzzing campaigns by pinpointing and eliminating those uninteresting bytes in the seeds. Picture this: instead of wasting valuable resources on meaningless mutations in large, bloated seeds, DIAR removes the unnecessary bytes, streamlining the entire process.
In this work, we equipped AFL, a popular fuzzer, with DIAR and examined two critical Linux libraries -- Libxml's xmllint, a tool for parsing xml documents, and Binutil's readelf, an essential debugging and security analysis command-line tool used to display detailed information about ELF (Executable and Linkable Format). Our preliminary results show that AFL+DIAR does not only discover new paths more quickly but also achieves higher coverage overall. This work thus showcases how starting with lean and optimized seeds can lead to faster, more comprehensive fuzzing campaigns -- and DIAR helps you find such seeds.
- These are slides of the talk given at IEEE International Conference on Software Testing Verification and Validation Workshop, ICSTW 2022.
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
How to Get CNIC Information System with Paksim Ga.pptxdanishmna97
Pakdata Cf is a groundbreaking system designed to streamline and facilitate access to CNIC information. This innovative platform leverages advanced technology to provide users with efficient and secure access to their CNIC details.
A tale of scale & speed: How the US Navy is enabling software delivery from l...sonjaschweigert1
Rapid and secure feature delivery is a goal across every application team and every branch of the DoD. The Navy’s DevSecOps platform, Party Barge, has achieved:
- Reduction in onboarding time from 5 weeks to 1 day
- Improved developer experience and productivity through actionable findings and reduction of false positives
- Maintenance of superior security standards and inherent policy enforcement with Authorization to Operate (ATO)
Development teams can ship efficiently and ensure applications are cyber ready for Navy Authorizing Officials (AOs). In this webinar, Sigma Defense and Anchore will give attendees a look behind the scenes and demo secure pipeline automation and security artifacts that speed up application ATO and time to production.
We will cover:
- How to remove silos in DevSecOps
- How to build efficient development pipeline roles and component templates
- How to deliver security artifacts that matter for ATO’s (SBOMs, vulnerability reports, and policy evidence)
- How to streamline operations with automated policy checks on container images
GridMate - End to end testing is a critical piece to ensure quality and avoid...ThomasParaiso2
End to end testing is a critical piece to ensure quality and avoid regressions. In this session, we share our journey building an E2E testing pipeline for GridMate components (LWC and Aura) using Cypress, JSForce, FakerJS…
Unlocking Productivity: Leveraging the Potential of Copilot in Microsoft 365, a presentation by Christoforos Vlachos, Senior Solutions Manager – Modern Workplace, Uni Systems
Full-RAG: A modern architecture for hyper-personalizationZilliz
Mike Del Balso, CEO & Co-Founder at Tecton, presents "Full RAG," a novel approach to AI recommendation systems, aiming to push beyond the limitations of traditional models through a deep integration of contextual insights and real-time data, leveraging the Retrieval-Augmented Generation architecture. This talk will outline Full RAG's potential to significantly enhance personalization, address engineering challenges such as data management and model training, and introduce data enrichment with reranking as a key solution. Attendees will gain crucial insights into the importance of hyperpersonalization in AI, the capabilities of Full RAG for advanced personalization, and strategies for managing complex data integrations for deploying cutting-edge AI solutions.
zkStudyClub - Reef: Fast Succinct Non-Interactive Zero-Knowledge Regex ProofsAlex Pruden
This paper presents Reef, a system for generating publicly verifiable succinct non-interactive zero-knowledge proofs that a committed document matches or does not match a regular expression. We describe applications such as proving the strength of passwords, the provenance of email despite redactions, the validity of oblivious DNS queries, and the existence of mutations in DNA. Reef supports the Perl Compatible Regular Expression syntax, including wildcards, alternation, ranges, capture groups, Kleene star, negations, and lookarounds. Reef introduces a new type of automata, Skipping Alternating Finite Automata (SAFA), that skips irrelevant parts of a document when producing proofs without undermining soundness, and instantiates SAFA with a lookup argument. Our experimental evaluation confirms that Reef can generate proofs for documents with 32M characters; the proofs are small and cheap to verify (under a second).
Paper: https://eprint.iacr.org/2023/1886
Maruthi Prithivirajan, Head of ASEAN & IN Solution Architecture, Neo4j
Get an inside look at the latest Neo4j innovations that enable relationship-driven intelligence at scale. Learn more about the newest cloud integrations and product enhancements that make Neo4j an essential choice for developers building apps with interconnected data and generative AI.
Encryption in Microsoft 365 - ExpertsLive Netherlands 2024Albert Hoitingh
In this session I delve into the encryption technology used in Microsoft 365 and Microsoft Purview. Including the concepts of Customer Key and Double Key Encryption.
FIDO Alliance Osaka Seminar: The WebAuthn API and Discoverable Credentials.pdf
VST2022.pdf
1. Do Tests Generated by AI Help Developers?
Open Challenges, Applications and
Opportunities
Annibale Panichella, Ph.D.
a.panichella@tudelft.nl
@AnniPanic
1
3. The CISE Lab
3
https://www.ciselab.nl
Dr. Annibale Panichella
(Lab leader)
Dr. Pouria Derakhshanfar
(Post-doc)
Imara van Dinten
(Ph.D. Student)
Mitchell Olsthoorn
(Ph.D. Student)
Leonhard Applis
(Ph.D. Student)
Team of 10 M.Sc.
students
4. My Research Interests
4
Word-cloud from my research papers Research Topics:
• Automated Test Generation
• Crash Replication
• Security Attacks Generations
• SE for Cyber-Physical Systems
• Empirical Software Engineering
• Testing for AI-based systems
• …
7. Spot the Bug
7
int balance = 1000;
void decrease(int amount) {
if (balance <= amount) {
balance = balance – amount;
} else {
printf(“Insufficient fundsn”);
}
}
void increase(int amount) {
balance = balance + amount;
}
It should be balance >= amount
8. Spot the Bug
8
int balance = 1000;
void decrease(int amount) {
if (balance <= amount) {
balance = balance – amount;
} else {
printf(“Insufficient fundsn”);
}
}
void increase(int amount) {
balance = balance + amount;
}
It should be balance >= amount
What if the amount is negative?
9. Spot the Bug
9
int balance = 1000;
void decrease(int amount) {
if (balance <= amount) {
balance = balance – amount;
} else {
printf(“Insufficient fundsn”);
}
}
void increase(int amount) {
balance = balance + amount;
}
It should be balance >= amount
What if the amount is negative?
What if sum is too large for int ?
17. Symbolic Execution
17
int foo (int v) {
return 2*v;
}
void method (int x, int y){
int z = foo(y);
if (z == x)
if (x > y+10)
printf(“Error”);
}
Concrete
State
x = 2
y = 1
z = 2
Symbolic
State
x = x0
y = y0
z = 2*y0
Path
Condition
2*y0 = x0
x0 <= y0+10
Code Under Test
Find y0 and x0 that solve
these equations/paths
18. Symbolic AI
[J. Haugeland, 1985] • Symbolic AI is often called GOFAI (Good Old-fashioned
Arti
fi
cial Intelligence)
• The overall idea is that many aspects of intelligence can be
achieved by manipulation of “symbols” and symbolic solvers
• Pros: powerful and each
• Cons:
• Not all problems can be modelled as symbolic equations
• Not all formulas can be solved with exact methods
• Path explosion problem in testing
19. Historical Overview
19
Automatic generation of random
self-checking test cases
D. L. Bird; C. U. Munoz
IBM Systems Journal
1976 Test Data Generation
(Symbolic execution)
1982 Random Testing
(Data generation)
1968-69 First SE Conference
20. Random Testing
20
class Triangle {
int a, b, c; //sides
String type = "NOT_TRIANGLE";
void computeTriangleType(int a, int b, int c) {
1. if (a == b) {
2. if (b == c)
3. type = "EQUILATERAL";
else
4. type = "ISOSCELES";
} else {
5. if (a == c) {
6. type = "ISOSCELES";
} else {
7. if (b == c)
8. type = “ISOSCELES”;
else
9. type = “SCALENE”;
}
}
}
Program Under Test The simplest fuzzer
public class TestDataGenerator {
static int lowerBound = -100;
static int upperBound = 100;
static int[] generate(int nData){
int[] data = new int[nData];
for (int i=0; i<nData; i++){
double value = lowerBound + Math.random()
* (upperBound - lowerBound);
data[i] = (int) Math.round(value);
}
return data;
}
}
[-66, 59, -8] [91, 43, 36]
[51, -76, -62]
[74, 66, -40] …
Output
Number of inputs
Upper and Lower
Bounds
It is fast and useful, but it does not
generate complete test cases (only
the test input)
!
21. Historical Overview
21
1976 Test Data Generation
(Symbolic execution)
1982 Random Testing
(Data generation)
IEEE TSE
1990 Numerical Optimization
(Data generation)
1968-69 First SE Conference
22. Historical Overview
22
1976 Test Data Generation
(Symbolic execution)
1982 Random Testing
(Data generation)
Pargas et al. IEEE TSE1999
1990 Numerical Optimization
(Data generation)
1968-69 First SE Conference
1999 Genetic Algorithms
(Data Generation)
23. The Test Case Generation Era
23
2007 Randoop - Random Testing
(Test Case Generation)
2011 EvoSuite - Genetic Algorithm
(Test Case Generation)
2004 Genetic Algorithms
(Test Case Generation)
P. Tonella, ISSTA 2004
24. Test Case Generation
24
class Triangle {
int a, b, c; //sides
String type = "NOT_TRIANGLE";
void computeTriangleType(int a, int b, int c) {
1. if (a == b) {
2. if (b == c)
3. type = "EQUILATERAL";
else
4. type = "ISOSCELES";
} else {
5. if (a == c) {
6. type = "ISOSCELES";
} else {
7. if (b == c)
8. type = “ISOSCELES”;
else
9. type = “SCALENE”;
}
}
}
Program Under Test @Test
public void testTriangle_invalid1() {
assertEquals(Triangle2.Type.INVALID,
Triangle2.triangle(0,0,0));
}
@Test
public void testTriangle_invalid2() {
assertEquals(Triangle2.Type.INVALID,
Triangle2.triangle(1,1,3));
}
@Test
public void testTriangle_equilateral() {
assertEquals(Triangle2.Type.EQUILATERAL,
Triangle2.triangle(2,2,2));
}
@Test
public void testTriangle_isoscele() {
assertEquals(Triangle2.Type.ISOSCELES,
Triangle2.triangle(3,4,3));
}
@Test
public void testTriangle_scalene() {
assertEquals(Triangle2.Type.SCALENE,
Triangle2.triangle(3,4,5));
}
Generated Test Suite
AI
25. The Test Case Generation Era
25
2007 Randoop - Random Testing
(Test Case Generation)
2011 EvoSuite - Genetic Algorithm
(Test Case Generation)
2004 Genetic Algorithms
(Test Case Generation)
2013 SBST tool competition
2015 Many-objective GAs
(Test Case Generation)
A. Panichella et al., ICST 2015 A. Panichella et al., TSE 2018
Many-objective evolutionary algorithms outperform
state-of-the-art test case generation algorithms
Nowadays, many-objective algorithms are the core engine of many
existing state-of-the-art tools (see next slide)
32. Are Generated Tests Readable?
32
G. Fraser et al., Does Automated Unit Test
Generation Really Help Software Testers? A
Controlled Empirical Study, TOSEM 2015.
0%
Testing
Comprehension
Testing time
75% 100%
Generated tests achieve higher structural
coverage than manually created test suites.
Do not lead to
fi
nd faults more quickly if
developers have to manually-validate the tests
33. Are Generated Tests Readable?
33
G. Fraser et al., Does Automated Unit Test
Generation Really Help Software Testers? A
Controlled Empirical Study, TOSEM 2015.
There is no difference in the
ef
fi
ciency of debugging when it is
supported either by manual or
EvoSuite test cases
36. My Personal View
36
Test cases generated by AI-methods do
fi
nd
many crashes and runtime exceptions
Generating effective (bug detecting) tests is not
the end of the story
Focus on application domains that are too hard
and complex to test by hand
Easy to validate oracle
Generate documentation
Successful results
38. Generating Test Documentation
38
TestDescriber
Generated test
+ Documentation
S. Panichella, A. Panichella, M. Beller, A. Zaidman, H.C. Gall. “The impact of test case
Summaries on Bug Fixing Performance: And Empirical Investigation”. ICSE 2016
39. Generating Test Documentation
39
Main Steps in TestDescriber:
public class Option {
public Option(String opt, String longOpt,
boolean hasArg, String descr)
throws IllegalArgumentException {
OptionValidator.validateOption(opt);
this.opt = opt;
this.longOpt = longOpt;
if (hasArg) {
this.numberOfArgs = 1;
}
this.description = descr;
}
...
}
Production Code
40. public class Option {
public Option(String opt, String longOpt,
boolean hasArg, String descr)
throws IllegalArgumentException {
OptionValidator.validateOption(opt);
this.opt = opt;
this.longOpt = longOpt;
if (hasArg) {
this.numberOfArgs = 1;
}
this.description = descr;
}
...
}
Generating Test Documentation
40
Main Steps in TestDescriber:
1. Select the covered statements
Covered Code
41. public class Option {
public Option(String opt, String longOpt,
boolean hasArg, String descr)
throws IllegalArgumentException {
OptionValidator.validateOption(opt);
this opt = opt;
this longOpt = longOpt;
if (hasArg) {false
}
this description = descr;
}
...
}
Generating Test Documentation
41
Main Steps in TestDescriber:
1. Select the covered statements
2. Filter out Java keywords, etc.
Covered Code
42. public class Option {
public Option(String opt, String long Opt,
boolean has Arg, String descr)
throws IllegalArgumentException {
Option Validator.validate Option(opt);
this opt = opt;
this long Opt = long Opt;
if (has Arg) {false
;
}
this description = descr;
}
...
}
Generating Test Documentation
42
Covered Code
Main Steps in TestDescriber:
1. Select the covered statements
2. Filter out Java keywords, etc.
3. Identi
fi
er Splitting (Camel case)
43. public class Option {
public Option(String option, String long Option,
boolean has Argument String description)
throws IllegalArgumentException {
Option Validator.validate Option(option);
this option = option;
this long Option = long Option;
if (has Argument) {false
}
this description = description;
}
...
}
Generating Test Documentation
43
Covered Code
Main Steps in TestDescriber:
1. Select the covered statements
2. Filter out Java keywords, etc.
3. Identi
fi
er Splitting (Camel case)
4. Abbreviation Expansion (using external
vocabularies)
44. public class Option {
Option(String option, String long Option
,
boolean has Argument String description)
throws IllegalArgumentException
Option Validator.validate Option(option);
this option = option
;
this long Option = long Option;
if (has Argument false
}
this description = description;
}
NOUN NOUN NOUN
ADJ
NOUN
NOUN
VERB
NOUN NOUN NOUN
NOUN
VERB NOUN
NOUN
ADJ
ADJ ADJ ADJ
NOUN
NOUN NOUN
VERB
ADJ
NOUN
CON
NOUN
ADJ
Generating Test Documentation
44
Main Steps in TestDescriber:
1. Select the covered statements
2. Filter out Java keywords, etc.
3. Identi
fi
er Splitting (Camel case)
4. Abbreviation Expansion (using external
vocabularies)
5. Part-of-Speech tagger
Covered Code
45. public class Option {
Option(String option, String long Option
,
boolean has Argument String description)
throws IllegalArgumentException
Option Validator.validate Option(option);
this option = option
;
this long Option = long Option;
if (has Argument false
}
this description = description;
}
NOUN NOUN NOUN
ADJ
NOUN
NOUN
VERB
NOUN NOUN NOUN
NOUN
VERB NOUN
NOUN
ADJ
ADJ ADJ ADJ
NOUN
NOUN NOUN
VERB
ADJ
NOUN
CON
NOUN
ADJ
Generating Test Documentation
45
Covered Code
The test case instantiates an "Option"
with:
- option equal to “...”
- long option equal to “...”
- it has no argument
- description equal to “…”
An option-validator validates the
instantiated object
The test asserts the following
condition:
- "Option" has no argument
Natural Language Sentences
46. How Do Test Case Summaries Impact the Number of
Bugs Fixed by Developers?
46
Participants WITHOUT TestDescriber
summaries
fi
xed 40% of bugs
Both the two groups had 45 minutes
to
fi
x each class
Participants WITH TestDescriber summaries,
fi
xed 60%-80% of bugs
47. Test Documentation and Comprehension
47
Without
With 4%
6%
14%
33%
14%
6%
32%
9%
36%
45%
Perceived test comprehensibility WITH and
WITHOUT TestDescriber summaries
Without Summaries:
• Only 15% of participants consider the test
cases as “easy to understand”.
• 40% of participants considered the test
cases as incomprehensible.
With Summaries:
• 46% of participants consider the test
cases as “easy to understand”.
• Only 18% of participants considered
the test cases as incomprehensible.
48. Test Documentation and Comprehension
48
Roy et al., ASE 2020
Follow-up work that uses Deep Learning for
post-process generated tests
DeepTC-Enhancer generate:
• Test Documentation
• Test Method Names
• Variable Names
52. The Botsing Project
52
Target Crash:
Bug Name: ACC-70
Library: Apache Commons Collection
Exception in thread "main" java.lang.NullPointerException at
org.apache.commons.collections.list.TreeList$TreeListIterator.previous (TreeList.java:841)
at java.util.Collections.get(Unknown Source)
at java.util.Collections.iteratorBinarySearch(Unknown Source)
at java.util.Collections.binarySearch(Unknown Source)
at utils.queue.QueueSorted.put(QueueSorted.java:51)
at framework.search.GraphSearch.solve(GraphSearch.java:53)
at search.informed.BestFirstSearch.solve(BestFirstSearch.java:20)
at Hlavni.main(Hlavni.java:66)
public Object previous() {
...
if (next == null) {
next = parent.root.get(nextIndex - 1);
} else {
next = next.previous();
}
Object value = next.getValue();
...
}
}
Buggy Code
if “parent” is null,
this code triggers
an exception
BOTSING
public void test0() throws Throwable {
TreeList treeList0 = new TreeList();
treeList0.add((Object) null);
TreeList.TreeListIterator treeList_TreeListIterator0 = new
TreeList.TreeListIterator(treeList0, 732);
// Undeclared exception!
treeList_TreeListIterator0.previous();
}
Test generated by BOTSING
53. 53
Test Case
Selection
Evolutionary
Algorithm
Test Execution
Initial
Tests
Variants
Generation
The Botsing Project
java.lang.IllegalArgumentException:
org.apache.commons.collections.map.AbstractHashedMap.<init> (AbstractHashedMap.java:142)
org.apache.commons.collections.map.AbstractHashedMap.<init> (AbstractHashedMap.java:127)
org.apache.commons.collections.map.AbstractLinkedMap.<init> (AbstractLinkedMap.java:95)
org.apache.commons.collections.map.LinkedMap.<init> (LinkedMap.java:78)
org.apache.commons.collections.map.TransformedMap.transformMap (TransformedMap.java:153)
org.apache.commons.collections.map.TransformedMap.putAll (TransformedMap.java:190)
java.lang.IllegalArgumentException:
org.apache.commons.collections.map.AbstractHashedMap.<init> (AbstractHashedMap.java:141)
org.apache.commons.collections.map.AbstractHashedMap.<init> (AbstractHashedMap.java:48)
org.apache.commons.collections.map.AbstractLinkedMap.<init> (AbstractLinkedMap.java:31)
org.apache.commons.collections.map.LinkedMap.<init> (LinkedMap.java:72)
org.apache.commons.collections.map.TransformedMap.transformMap (TransformedMap.java:148)
org.apache.commons.collections.map.TransformedMap.putAll (TransformedMap.java:190)
Test quality is measured using the “distance”
between the target and the generated stack traces
Target Stack Trace
Produced Stack Trace
54. 54
Do Generated Tests Help Developers?
Time
to
fi
x
a
bug
(in
s)
With Botsing Without Botsing
https://github.com/STAMP-project/botsing
Generated tests help developers
fi
xing
bugs signi
fi
cantly faster
Generated tests help developers locating
bugs signi
fi
cantly faster
“Search-based crash reproduction and its
impact on debugging”, TSE 2018
60. Integration Components
60
ystems ICSE ’20, May 23-29, 2020, Seoul, South Korea
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
ve con�icts be-
th and �cth are
is a risk of colli-
(�c(t) < �cth ^
Detected(t)), then
mmand issued by
nd requires sub-
Figure 4: A decision tree diagram representing integration
rules 1, 2 and 4 in Figure 3.
Table 1: Safety requirements for AutoDrive.
Features Requirements
PP The PP system shall avoid collision with pedestrians by initiating emergency
braking in case of impending collision with pedestrians.
TSR The TSR system shall stop the vehicle at the stop sign by initiating a full
braking when a stop sign is detected
AEB The AEB system shall avoid collision with vehicles by initiating emergency
braking in case of impending collision with vehicles.
ACC The ACC system shall respect the safety distance by keeping the vehicle
Simpli
fi
ed Example
Condition Template
⟨if op1 operator threshold⟩
speed(t) < speedLeadingCar(t) (t is the time stamp)
62. Test Inputs
Environment
Position
and speed
Road Shape
Traf
fi
c lights
position and
status
62
Weather
Ego Car:
- Initial Position
- Initial Speed
Car Under Test:
- Initial Position
- Initial Speed
66. AI-Based Testing
66
Test 1
Test 2
Test Case
Selection
Initial Tests
Evolutionary
Algorithm
Test Execution
Variants
Generation
67. AI-Based Testing
67
Minimum distance within the
simulation time window
Results of Test 1
2m
Results of Test 2
1m
Results of Test 3
1.5m
Test Case
Selection
Initial Tests
Evolutionary
Algorithm
Test Execution
Variants
Generation
68. AI-Based Testing
68
The best test case it the one closer to
violate the safe distance (
fi
tness)
Test Case
Selection
Initial Tests
Evolutionary
Algorithm
Test Execution
Variants
Generation
Results of Test 1
2m
Results of Test 2
1m
69. AI-Based Testing
69
Test 2
Mutation and/or
Crossover
Test Case
Selection
Initial Tests
Evolutionary
Algorithm
Test Execution
Variants
Generation
70. Search Objectives
70
stem.
s
a
TABLE I
SAFETY REQUIREMENTS AND FAILURE DISTANCE FUNCTIONS FOR
SafeDrive.
Feature Requirement Failure distance functions (FD1, . . . , FD5)
PP No collision with
pedestrians
FD1(i) is the distance between the ego car and the
pedestrian at step i.
AEB No collision with
cars
FD2(i) is the distance between the ego car and the
leading car at step i.
TSR Stop at a stop sign Let u(i) be the speed of the ego car at time step i
if a stop sign is detected, and let u(i) = 0 if there
is no stop sign. We define FD3(i) = 0 if u(i)
5km/h; FD3(i) = 1
u(i)
if u(i) 6= 0; and otherwise,
FD3(i) = 1.
TSR Respect the speed
limit
Let u0(i) be the difference between the speed of the
ego car and the speed limit at step i if a speed-
limit sign is detected, and let u0(i) = 0 if there
is no speed-limit sign. We define FD4(i) = 0 if
u0(i) 10km/h; FD4(i) = 1
u0(i)
if u0(i) 6= 0;
and otherwise, FD4(i) = 1.
ACC Respect the safety
distance
FD5(i) is the absolute difference between the safety
distance sd and FD2(i).
C. Hybrid Test Objectives
Our test objectives aim to guide the test generation process
towards test inputs that reveal undesired feature interactions.
We first present our formal notation and assumptions and then
we introduce our test objectives. Note that since in this paper,
• For each safety requirement, we
measure the distance to fail that
requirement during the simulation
• The problem is inherently many-
objectives
71. Case Study
• Two case study systems from IEE (industrial partner)
• Designed by experts
• Manually tested for more than six months
• Different rules to integrated feature actuator commands
• Both systems consist of four self-driving features
• Adaptive Cruise Control (ACC)
• Automated Emergency Braking (AEB)
• Traf
fi
c Sign Recognition (TSR)
• Pedestrian Protection (PP)
71
72. Many-Objective Search in Action
72
0 min
0
1
2
3
4
F1 F2 F3 F4 F5 F6 F7 F8 F9 F10
Distance
to
a
failure
Different types of
(potential) failures with
feature interactions
A zero distance means we
found a test that exposes
the failure
75. Feedback From Domain Experts
• The failure we found were due to undesired
feature interactions
• The failures were not previously known to the
experts (new tests for regression testing)
• We identi
fi
ed ways to improve the feature
interaction logic to avoid such failures
75
77. Do Tests Generated by AI Help Developers?
Open Challenges, Applications and
Opportunities
Annibale Panichella, Ph.D.
a.panichella@tudelft.nl
@AnniPanic
77