Software bugs prediction is one of the most active research areas in the software engineering community. The process of testing and debugging code proves to be costly during the software development life cycle. Software metrics measure the quality of source code to identify software bugs and vulnerabilities. Traceable code patterns are able to de- scribe code at a finer granularity level to measure quality. Micro patterns will be used in this research to mechanically describe java code at the class level. Machine learning has also been introduced for bug prediction to localize source code for testing and debugging. Deep Learning is a branch of Machine Learning that is relatively new. This research looks to improve the prediction of software bugs by utilizing micro patterns with deep learning techniques. Software bug prediction at a finer granularity level will enable developers to localize code to test and debug during the development process.

Excessive coupling between object-oriented classes in systems is generally acknowledged as harmful and is recognised as a maintenance problem that can result in a higher propensity for faults in systems and a „stored up‟ future problem. Characterisation and understanding coupling at different levels of abstraction is therefore important for both the project manager and developer both of whom have a vested interest in software quality. In this Thesis, coupling trends are empirically investigated over multiple versions of seven Java open-source systems (OSS). The first investigation explores the trends in longitudinal changes to open-source systems given by six coupling metrics. Coupling trends are then explored from the perspective of: the relationship between removed classes and their coupling with other classes in the same package; the relationships between coupling and 'warnings’ in packages and the time interval between versions in Java OSS; the relationship between some of these coupling metrics are also explored. Finally, the existence of an 80/20 rule for the coupling metrics is inspected. Results suggest that developer activity comprises a set of high and low periods (peak and trough‟ effect) evident as a system evolves. Findings also demonstrate that addition of coupling may have beneficial effects on a system, particularly if they are added as new functionality through the package Java feature. The fan-in and fan-out coupling metrics reveal particular features and exhibited a wide range of traits in the classes depending on their high or low values; finally, we revealed that one metric (fan-in) is the only metric that appears consistently to exhibit an 80/20 (Pareto) relationship.

Object-oriented systems that undergo repeated modifications commonly endure a loss of quality and design decay. This problem is often remedied by applying refactorings. Refactoring is one of the most important and commonly used techniques to improve the quality of the code by eliminating redundancy and reducing complexity; frequently refactored code is believed to be easier to understand, maintain and test. Object-oriented metrics provide an easy means to extract useful and measurable information about the structure of a software system. Metrics have been used to identify refactoring opportunities, detect refactorings that have previously been applied and gauge quality improvements after the application of refactorings. This thesis provides an in-depth analytical study of the relationship between metrics and refactorings. For this purpose we analyzed 136 versions of 4 different open source projects. We used RefactoringCrawler, an automatic refactoring detection tool to identify refactorings and then analyzed various metrics to study whether metrics can be used to (1) reliably identify refactoring opportunities, (2) detect refactorings that were previously applied, and (3) estimate the impact of refactoring on software quality. In conclusion, our study showed that metrics cannot be reliably used to either identify refactoring opportunities or detect refactorings. It is very difficult to use metrics to estimate the impact of refactoring, however studying the evolution of metrics at a system level indicates that refactoring does improve software quality and reduce complexity. / text

This paper analyses and develops models for programmer participation and effort estimation in open source software projects. This has not yet been a centre of research, although any results would be of high importance for assessing the efficiency of this model and for various decision-makers. In this paper, a case study is used for hypotheses generation regarding manpower function and effort modeling, then a large data set retrieved from a project repository is used to test these hypotheses. The main results are that Norden-Rayleigh-based approaches need to be complemented to account for the addition of new features during the lifecycle to be usable in this context, and that programmer-participation based effort models show significantly less effort than those based on output metrics like lines-of-code. (author's abstract) / Series: Working Papers on Information Systems, Information Business and Operations

<p>Capturing the quality of software and detecting sections for further scrutiny within are of high interest for industry as well as for education. Project managers request quality reports in order to evaluate the current status and to initiate appropriate improvement actions and teachers feel the need of detecting students which need extra attention and help in certain programming aspects. By means of software measurement software characteristics can be quantified and the produced measures analyzed to gain an understanding about the underlying software quality.</p><p>In this study, the technique of code profiling (being the activity of creating a summary of distinctive characteristics of software code) was inspected, formulized and conducted by means of a sample group of 19 industry and 37 student programs. When software projects are analyzed by means of software measurements, a considerable amount of data is produced. The task is to organize the data and draw meaningful information from the measures produced, quickly and without high expenses.</p><p>The results of this study indicated that code profiling can be a useful technique for quick program comparisons and continuous quality observations with several application scenarios in both industry and education.</p>

Software testing has been integrated within software development life cycle due to its importance in assuring software quality, software safety, and customers' satisfaction. However, problems in software testing are prominent among software developers as system grows in size and complexity. Dependency injection becomes an appealing solution for developers with its practicality to improve software design, improve testability, and enable mock testing technique. The study aims to discover the extent to which the dependency injection facilitates software design and software testing. In addition, the effect of mock practice on testing is also assessed. Metrics for investigation are defined and measured on various aspects of two systems. The two systems are selected and developed based on the same user requirements, development technologies, and methodologies. By comparing the two systems against the investigated metrics, we aim to reveal whether the dependency injection improve the code design. Then four test suites from both systems are evaluated in relation to testability. The results demonstrate that the dependency injection does not seem to improve the code design if comparing on the selected metrics. Even though it does not score better, its effect is evident in other software aspects. The testability of the two systems is similar and suffers from the same problem. Meanwhile, mock helps assist software testing and improve testability. The effect of mock technique can be witnessed, especially when it is applied with other test techniques. Explanations and discussions on these findings are addressed in the paper.

Nowadays, assessing software quality and making predictions about the software are not possible. Software metrics are useful tools for assessing software quality and for making predictions. But currently the interpretation of the measured values is based on personal experience. In order to be able to assess software quality, quantitative data has to be obtained. VizzAnalyzer is a program for analyzing open source Java Projects. It can be used for collecting quantitative data for defining thresholds that can support the interpretation of the measurement values. It helps to assess software quality by calculating over 20 different software metrics. I define a process for obtaining, storing and maintaining software projects. I have used the defined process to analyze 60-80 software projects delivering a large database with quantitative data.

This research models the effects of software reuse on object-oriented software development, in particular, the reuse of C++ classes. Two types of reuse (with and without modification) are compared. The common traits of programmers who tend to reuse are identified, and some object-oriented software metrics are correlated with the inherent reusability of a C++ class. These issues are important because software reuse has been shown to increase productivity within the software development process. This research effort describes three experiments. The first characterizes the effects of reusing C++ classes on object-oriented software development using nine development process indicators. The second experiment uses ten similar process indicators to differentiate the effects of writing C++ classes from scratch versus reusing them without modification versus inheriting new classes from existing ones. The last experiment correlates some object-oriented metrics with the expert opinions of the reusability of C++ classes. This research has shown that the black box reuse (reuse without modification) of C++ classes is beneficial to object-oriented software development in many ways. Development time is reduced and system reliability increases. For abstract data type C++ classes, a set of fifteen skills and experiences are shown to be prominent in frequent class reusers. Lastly, a set of object-oriented metrics is used to predict C++ class reusability. All of these results can be used to increase programmer productivity when developing C++ software systems. / Ph. D.

No description available.

Software designs consist of software components and their relationships. Graphs are abstraction of software designs. Graphs composed of nodes and hyperedges are attractive for depicting software designs. Measurement of abstractions quantify relationships that exist among components. Most conventional metrics are based on counting. In contrast, this work adopts information theory because design decisions are information. The goal of this research is to show that information theory-based metrics proposed by Allen, namely size, complexity, coupling, and cohesion, can be useful in real-world software development projects, compared to the counting-based metrics. The thesis includes three case studies with the use of global variables as the abstraction. It is observed that one can use the counting metrics for the size and coupling measures and the information metrics for the complexity and cohesion measures.