DOCSLIB.ORG

Investigating the Applicability of Software Metrics and Technical Debt on X++ Abstract Syntax Tree in XML Format – Calculations Using Xquery Expressions

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Investigating the Applicability of Software Metrics and Technical Debt on X++ Abstract Syntax Tree in XML Format – Calculations Using Xquery Expressions Linköping University | Department of Computer and Information Science Master’s thesis, 30 ECTS | Datateknik 202019 | LIU-IDA/LITH-EX-A--2019/101--SE Investigating the applicability of Software Metrics and Technical Debt on X++ Abstract Syntax Tree in XML format – calculations using XQuery expressions Tillämpning av mjukvarumetri och tekniska skulder från en XML representation av abstrakta syntaxträd för X++ kodprogram David Tran Supervisor : Jonas Wallgren Examiner : Martin Sjölund External supervisor : Laurent Ricci Linköpings universitet SE–581 83 Linköping +46 13 28 10 00 , www.liu.se Upphovsrätt Detta dokument hålls tillgängligt på Internet ‐ eller dess framtida ersättare ‐ under 25 år frånpublicer‐ ingsdatum under förutsättning att inga extraordinära omständigheter uppstår. Tillgång till dokumentet innebär tillstånd för var och en att läsa, ladda ner, skriva ut enstakako‐ pior för enskilt bruk och att använda det oförändrat för ickekommersiell forskning och för undervis‐ ning. Överföring av upphovsrätten vid en senare tidpunkt kan inte upphäva detta tillstånd. Allannan användning av dokumentet kräver upphovsmannens medgivande. För att garantera äktheten, säker‐ heten och tillgängligheten finns lösningar av teknisk och administrativ art. Upphovsmannens ideella rätt innefattar rätt att bli nämnd som upphovsman i den omfattning som god sed kräver vid användning av dokumentet på ovan beskrivna sätt samt skydd mot att dokumentet ändras eller presenteras i sådan form eller i sådant sammanhang som är kränkande för upphovsman‐ nens litterära eller konstnärliga anseende eller egenart. För ytterligare information om Linköping University Electronic Press se förlagets hemsida http://www.ep.liu.se/. Copyright The publishers will keep this document online on the Internet ‐ or its possible replacement ‐ for a period of 25 years starting from the date of publication barring exceptional circumstances. The online availability of the document implies permanent permission for anyone to read, to down‐ load, or to print out single copies for his/hers own use and to use it unchanged for non‐commercial research and educational purpose. Subsequent transfers of copyright cannot revoke this permission. All other uses of the document are conditional upon the consent of the copyright owner. The publisher has taken technical and administrative measures to assure authenticity, security and accessibility. According to intellectual property law the author has the right to be mentioned when his/her work is accessed as described above and to be protected against infringement. For additional information about the Linköping University Electronic Press and its procedures for publication and for assurance of document integrity, please refer to its www homepage: http://www.ep.liu.se/. © David Tran Abstract This thesis investigates how XML representation of X++ abstract syntax trees (AST) residing in an XML database can be subject to static code analysis. Microsoft Dynamics 365 for Finance & Operations comprises a large and complex corpus of X++ source code and intuitive ways of visualizing and analysing the state of the code base in terms of software metrics and technical debt are non-existent. A solution is to extend an internal web application and semantic search tool called SocrateX, to calculate software metrics and technical debt. This is done by creating a web service to construct XQuery and XPath code to be queried to the XML database. The values are stored in a relational database and imported to Power BI for intuitive visualization. Software metrics have been chosen based on the amount of previous research and compatibility with the X++ AST, whereas technical debt has been estimated using the SQALE method. This thesis concludes that XML representations of X++ abstract syntax trees are viable candidates for measuring quality of source codes with the use of functional query programming languages. Acknowledgments First and foremost, all work for this thesis has been carried out at Microsoft Development Center in Copenhagen. I would like to thank Laurent Ricci for being my mentor and giving me the opportunity to conduct my thesis at Microsoft. Secondly, I would like to thank my supervisor Jonas Wallgren for his indispensable help and feedback throughout writing this thesis and to Martin Sjölund for being my examiner. My friends in Norrköping, you know who you are. Thank you for making the five years of studying fly by in the blink of an eye. Thank you, Tobias Matts, for being my opponent in this thesis and for giving me valuable feedback on my report. I would also like to express my deepest gratitude to my family: Minh Tran, Phuong Nguyen and Amanda Tran, for their unconditional love and support throughout my five years’ time at Linköping University. Without them, I would not have this opportunity. Lastly, I want to thank Tu Do for being my rock during this thesis. There are no words that can express how much your encouragement, love and support have meant to me. v Contents Abstract iii Acknowledgments v Contents vii List of Figures ix List of Tables xi 1 Introduction 1 1.1 Motivation .......................................... 1 1.2 Aim .............................................. 2 1.3 Research questions ..................................... 2 1.4 Delimitations ........................................ 2 2 Background 5 2.1 Microsoft Development Center .............................. 5 2.1.1 Microsoft Dynamics 365 for Finance & Operations ............. 5 2.2 SocrateX ........................................... 5 3 Theory 7 3.1 Quality Assessment in Software Engineering ..................... 7 3.1.1 Software Development Life Cycle ........................ 7 3.1.2 Quality in Software ................................ 8 3.2 Trees ............................................. 10 3.3 Software metrics ...................................... 10 3.3.1 Traditional metrics ................................ 11 3.3.2 Chidamber & Kemerer Metric Suite ...................... 14 3.4 Technical Debt ....................................... 17 3.5 SQALE Method ...................................... 17 3.5.1 The SQALE Quality Model ........................... 18 3.5.2 The SQALE Analysis Model .......................... 21 3.5.3 The SQALE Indices ................................ 22 3.6 X++ Programming Language .............................. 22 3.6.1 Language Specific Restrictions ......................... 23 3.7 XML ............................................. 25 3.7.1 XPath ........................................ 26 3.7.2 XQuery ....................................... 29 3.8 XLNT Framework ..................................... 30 3.9 SocrateX ........................................... 30 3.9.1 ASP.NET Core .................................. 30 3.9.2 Angular Framework ................................ 30 vii 3.9.3 BaseX ........................................ 31 3.9.4 SocrateX Architecture .............................. 31 3.10 Entity Framework Core .................................. 32 3.11 Power BI ........................................... 33 3.12 Related Work ........................................ 33 4 Method 37 4.1 Approach .......................................... 37 4.1.1 Constructs in XML abstract syntax tree ................... 37 4.1.2 Applicability of software metrics ........................ 38 4.1.3 Applicability of technical debt ......................... 39 4.1.4 Integration with SocrateX ............................ 39 4.2 Implementation ....................................... 39 4.2.1 Traditional metrics ................................ 39 4.2.2 Chidamber & Kemerer Metric Suite ...................... 41 4.2.3 SQALE Method for Technical Debt ...................... 44 4.2.4 Web service - Static Code Analysis ....................... 46 4.2.5 Power BI ...................................... 52 4.2.6 Report Module in Angular ............................ 52 5 Results 55 5.1 Performance benchmark .................................. 55 5.2 Software metric values ................................... 55 5.3 Power BI Report ...................................... 56 5.3.1 Overview page ................................... 57 5.3.2 Artifact page .................................... 58 5.3.3 Software metric page ............................... 58 5.3.4 Rule page ...................................... 59 5.3.5 Team page ..................................... 59 6 Discussion 61 6.1 Results ............................................ 61 6.1.1 Database design and XQuery expressions ................... 61 6.1.2 XQuery performance ............................... 61 6.1.3 Software metrics .................................. 62 6.1.4 Technical Debt ................................... 64 6.1.5 Power BI Report .................................. 64 6.2 Method ............................................ 64 6.2.1 Validity ....................................... 65 6.2.2 Replicability .................................... 65 6.2.3 Reliability ...................................... 66 6.2.4 Source criticism .................................. 66 6.3 The work in a wider context ............................... 66 7 Conclusion 67 7.1 Consequences ........................................ 68 7.2 Future Work ........................................ 68 7.2.1 Historical data support .............................. 68 7.2.2 Task scheduler and Assembly in ASP.NET Core . 68 7.2.3 XQuery parallelism ................................ 68 7.2.4 Code refactoring .................................. 69
Load more

Recommended publications
  • The Use of Summation to Aggregate Software Metrics Hinders the Performance of Defect Prediction Models
    IEEE TRANSACTIONS ON SOFTWARE ENGINEERING, VOL. XX, NO. XX, XXX 2016 1 The Use of Summation to Aggregate Software Metrics Hinders the Performance of Defect Prediction Models Feng Zhang, Ahmed E. Hassan, Member, IEEE, Shane McIntosh, Member, IEEE, and Ying Zou, Member, IEEE Abstract—Defect prediction models help software organizations to anticipate where defects will appear in the future. When training a defect prediction model, historical defect data is often mined from a Version Control System (VCS, e.g., Subversion), which records software changes at the file-level. Software metrics, on the other hand, are often calculated at the class- or method-level (e.g., McCabe’s Cyclomatic Complexity). To address the disagreement in granularity, the class- and method-level software metrics are aggregated to file-level, often using summation (i.e., McCabe of a file is the sum of the McCabe of all methods within the file). A recent study shows that summation significantly inflates the correlation between lines of code (Sloc) and cyclomatic complexity (Cc) in Java projects. While there are many other aggregation schemes (e.g., central tendency, dispersion), they have remained unexplored in the scope of defect prediction. In this study, we set out to investigate how different aggregation schemes impact defect prediction models. Through an analysis of 11 aggregation schemes using data collected from 255 open source projects, we find that: (1) aggregation schemes can significantly alter correlations among metrics, as well as the correlations between metrics and
    [Show full text]
  • Software Maintainability a Brief Overview & Application to the LFEV 2015
    Software Maintainability A Brief Overview & Application to the LFEV 2015 Adam I. Cornwell Lafayette College Department of Electrical & Computer Engineering Easton, Pennsylvania [email protected] Abstract — This paper gives a brief introduction on For “lexical level” approaches which base what software maintainability is, the various methods complexity on program code, the following which have been devised to quantify and measure software maintainability, its relevance to the ECE 492 measurands are typical: individual and average Senior Design course, and some practical lines of code; number of commented lines, implementation guidelines. executable statements, blank lines, tokens, and data declarations; source code readability, or the Keywords — Software Maintainability; Halstead ratio of LOC to commented LOC; Halstead Metrics; McCabe’s Cyclomatic complexity; radon Metrics, including Halstead Length, Volume, and Effort; McCabe’s Cyclomatic Complexity; the I. INTRODUCTION control structure nesting level; and the number of Software Maintainability is an important knots, or the number of times the control flow concept in the upkeep of long-term software crosses. The final measurand is not as useful with systems. According to the IEEE, software object oriented programming but can still be of maintainability is defined as “the ease with which some use. a software system or component can be modified to correct faults, improve performance or other “Psychological complexity” approaches measure attributes, or adapt to a changed environment difficulty and are based on understandability and [1].” Software Maintainability can be measured the user [3]. The nature of the file and the using various devised methods, although none difficulty experienced by those working with the have been conclusively shown to work in a large file are what contribute to these kinds of variety of software systems [6].
    [Show full text]
  • A Metrics-Based Software Maintenance Effort Model
    A Metrics-Based Software Maintenance Effort Model Jane Huffman Hayes Sandip C. Patel Liming Zhao Computer Science Department Computer Science Department Computer Science Department Lab for Advanced Networking University of Louisville University of Kentucky University of Kentucky [email protected] [email protected] [email protected] (corresponding author) Abstract planning a new software development project. Albrecht introduced the notion of function points (FP) to estimate We derive a model for estimating adaptive software effort [1]. Mukhopadhyay [19] proposes early software maintenance effort in person hours, the Adaptive cost estimation based on requirements alone. Software Maintenance Effort Model (AMEffMo). A number of Life Cycle Management (SLIM) [23] is based on the metrics such as lines of code changed and number of Norden/Rayleigh function and is suitable for large operators changed were found to be strongly correlated projects. Shepperd et al. [27] argued that algorithmic cost to maintenance effort. The regression models performed models such as COCOMO and those based on function well in predicting adaptive maintenance effort as well as points suggested an approach based on using analogous provide useful information for managers and maintainers. projects to estimate the effort for a new project. In addition to the traditional off-the-self models such as 1. Introduction COCOMO, machine-learning methods have surfaced recently. In [17], Mair et al. compared machine-learning Software maintenance typically accounts for at least 50 methods in building software effort prediction systems. percent of the total lifetime cost of a software system [16]. There has also been some work toward applying fuzzy Schach et al.
    [Show full text]
  • Understanding the Syntactic Rule Usage in Java
    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by UCL Discovery Understanding the Syntactic Rule Usage in Java Dong Qiua, Bixin Lia,∗, Earl T. Barrb, Zhendong Suc aSchool of Computer Science and Engineering, Southeast University, China bDepartment of Computer Science, University College London, UK cDepartment of Computer Science, University of California Davis, USA Abstract Context: Syntax is fundamental to any programming language: syntax defines valid programs. In the 1970s, computer scientists rigorously and empirically studied programming languages to guide and inform language design. Since then, language design has been artistic, driven by the aesthetic concerns and intuitions of language architects. Despite recent studies on small sets of selected language features, we lack a comprehensive, quantitative, empirical analysis of how modern, real-world source code exercises the syntax of its programming language. Objective: This study aims to understand how programming language syntax is employed in actual development and explore their potential applications based on the results of syntax usage analysis. Method: We present our results on the first such study on Java, a modern, mature, and widely-used programming language. Our corpus contains over 5,000 open-source Java projects, totalling 150 million source lines of code (SLoC). We study both independent (i.e. applications of a single syntax rule) and dependent (i.e. applications of multiple syntax rules) rule usage, and quantify their impact over time and project size. Results: Our study provides detailed quantitative information and yields insight, particularly (i) confirming the conventional wisdom that the usage of syntax rules is Zipfian; (ii) showing that the adoption of new rules and their impact on the usage of pre-existing rules vary significantly over time; and (iii) showing that rule usage is highly contextual.
    [Show full text]
  • Development of an Enhanced Automated Software Complexity Measurement System
    Journal of Advances in Computational Intelligence Theory Volume 1 Issue 3 Development of an Enhanced Automated Software Complexity Measurement System Sanusi B.A.1, Olabiyisi S.O.2, Afolabi A.O.3, Olowoye, A.O.4 1,2,4Department of Computer Science, 3Department of Cyber Security, Ladoke Akintola University of Technology, Ogbomoso, Nigeria. Corresponding Author E-mail Id:- [email protected] [email protected] [email protected] 4 [email protected] ABSTRACT Code Complexity measures can simply be used to predict critical information about reliability, testability, and maintainability of software systems from the automatic measurement of the source code. The existing automated code complexity measurement is performed using a commercially available code analysis tool called QA-C for the code complexity of C-programming language which runs on Solaris and does not measure the defect-rate of the source code. Therefore, this paper aimed at developing an enhanced automated system that evaluates the code complexity of C-family programming languages and computes the defect rate. The existing code-based complexity metrics: Source Lines of Code metric, McCabe Cyclomatic Complexity metrics and Halstead Complexity Metrics were studied and implemented so as to extend the existing schemes. The developed system was built following the procedure of waterfall model that involves: Gathering requirements, System design, Development coding, Testing, and Maintenance. The developed system was developed in the Visual Studio Integrated Development Environment (2019) using C-Sharp (C#) programming language, .NET framework and MYSQL Server for database design. The performance of the system was tested efficiently using a software testing technique known as Black-box testing to examine the functionality and quality of the system.
    [Show full text]
  • DRE) for Software
    Exceeding 99% in Defect Removal Efficiency (DRE) for Software Draft 11.0 September 6, 2016 Capers Jones, VP and CTO, Namcook Analytics LLC Abstract Software quality depends upon two important variables. The first variable is that of “defect potentials” or the sum total of bugs likely to occur in requirements, architecture, design, code, documents, and “bad fixes” or new bugs in bug repairs. Defect potentials are measured using function point metrics, since “lines of code” cannot deal with requirements and design defects. (This paper uses IFPUG function points version 4.3. The newer SNAP metrics are only shown experimentally due to insufficient empirical quality data with SNAP as of 2016. However an experimental tool is included for calculating SNAP defects.) The second important measure is “defect removal efficiency (DRE)” or the percentage of bugs found and eliminated before release of software to clients. The metrics of Defect Potentials and Defect Removal Efficiency (DRE) were developed by IBM circa 1973 and are widely used by technology companies and also by insurance companies, banks, and other companies with large software organizations. The author’s Software Risk Master (SRM) estimating tool predicts defect potentials and defect removal efficiency (DRE) as standard quality outputs for all software projects. Web: www.Namcook.com Email: [email protected] Copyright © 2016 by Capers Jones. All rights reserved. 1 Introduction Defect potentials and defect removal efficiency (DRE) are useful quality metrics developed by IBM circa 1973 and widely used by technology companies as well as by banks, insurance companies, and other organizations with large software staffs. This combination of defect potentials using function points and defect removal efficiency (DRE) are the only accurate and effective measures for software quality.
    [Show full text]
  • Empirical Evaluation of the Effectiveness and Reliability of Software Testing Adequacy Criteria and Reference Test Systems
    Empirical Evaluation of the Effectiveness and Reliability of Software Testing Adequacy Criteria and Reference Test Systems Mark Jason Hadley PhD University of York Department of Computer Science September 2013 2 Abstract This PhD Thesis reports the results of experiments conducted to investigate the effectiveness and reliability of ‘adequacy criteria’ - criteria used by testers to determine when to stop testing. The research reported here is concerned with the empirical determination of the effectiveness and reliability of both tests sets that satisfy major general structural code coverage criteria and test sets crafted by experts for testing specific applications. We use automated test data generation and subset extraction techniques to generate multiple tests sets satisfying widely used coverage criteria (statement, branch and MC/DC coverage). The results show that confidence in the reliability of such criteria is misplaced. We also consider the fault-finding capabilities of three test suites created by the international community to serve to assure implementations of the Data Encryption Standard (a block cipher). We do this by means of mutation analysis. The results show that not all sets are mutation adequate but the test suites are generally highly effective. The block cipher implementations are also seen to be highly ‘testable’ (i.e. they do not mask faults). 3 Contents Abstract ............................................................................................................................ 3 Table of Tables ...............................................................................................................
    [Show full text]
  • The Commenting Practice of Open Source
    The Commenting Practice of Open Source Oliver Arafat Dirk Riehle Siemens AG, Corporate Technology SAP Research, SAP Labs LLC Otto-Hahn-Ring 6, 81739 München 3410 Hillview Ave, Palo Alto, CA 94304, USA [email protected] [email protected] Abstract lem domain is well understood [15]. Agile software devel- opment methods can cope with changing requirements and The development processes of open source software are poorly understood problem domains, but typically require different from traditional closed source development proc- co-location of developers and fail to scale to large project esses. Still, open source software is frequently of high sizes [16]. quality. This raises the question of how and why open A host of successful open source projects in both well source software creates high quality and whether it can and poorly understood problem domains and of small to maintain this quality for ever larger project sizes. In this large sizes suggests that open source can cope both with paper, we look at one particular quality indicator, the den- changing requirements and large project sizes. In this pa- sity of comments in open source software code. We find per we focus on one particular code metric, the comment that successful open source projects follow a consistent density, and assess it across 5,229 active open source pro- practice of documenting their source code, and we find jects, representing about 30% of all active open source that the comment density is independent of team and pro- projects. We show that commenting source code is an on- ject size. going and integrated practice of open source software de- velopment that is consistently found across all these pro- Categories and Subject Descriptors D.2.8 [Metrics]: jects.
    [Show full text]
  • Differences in the Definition and Calculation of the LOC Metric In
    Differences in the Definition and Calculation of the LOC Metric in Free Tools∗ István Siket Árpád Beszédes Department of Software Engineering Department of Software Engineering University of Szeged, Hungary University of Szeged, Hungary [email protected] [email protected] John Taylor FrontEndART Software Ltd. Szeged, Hungary [email protected] Abstract The software metric LOC (Lines of Code) is probably one of the most controversial metrics in software engineering practice. It is relatively easy to calculate, understand and use by the different stakeholders for a variety of purposes; LOC is the most frequently applied measure in software estimation, quality assurance and many other fields. Yet, there is a high level of variability in the definition and calculation methods of the metric which makes it difficult to use it as a base for important decisions. Furthermore, there are cases when its usage is highly questionable – such as programmer productivity assessment. In this paper, we investigate how LOC is usually defined and calculated by today’s free LOC calculator tools. We used a set of tools to compute LOC metrics on a variety of open source systems in order to measure the actual differences between results and investigate the possible causes of the deviation. 1 Introduction Lines of Code (LOC) is supposed to be the easiest software metric to understand, compute and in- terpret. The issue with counting code is determining which rules to use for the comparisons to be valid [5]. LOC is generally seen as a measure of system size expressed using the number of lines of its source code as it would appear in a text editor, but the situation is not that simple as we will see shortly.
    [Show full text]
  • SOFTWARE TESTING Aarti Singh
    © November 2015 | IJIRT | Volume 2 Issue 6 | ISSN: 2349-6002 SOFTWARE TESTING Aarti Singh ABSTRACT:- Software testing is an investigation can be installed and run in its conducted to provide stakeholders with intended environments, and information about the quality of the product or achieves the general result its stakeholders service under test Software testing can also desire. provide an objective, independent view of Software testing can be conducted as soon as thesoftware to allow the business to appreciate executable software (even if partially complete) and understand the risks of software exists. The overall approach to software implementation.In this paper we will discuss development often determines when and how testing about testing levels suct as alpha testing , beta is conducted. For example, in a phased process, most testing, unit testing , integrity testing, testing testing occurs after system requirements have been cycle and their requirement n comparison defined and then implemented in testable programs. between varius testing such as static and dynamic HISTORY: testing. The separation of debugging from testing was initially introduced by Glenford J. Myers in INTRODUCTION: 1979.[] Although his attention was on breakage Software testing involves the execution of a testing ("a successful test is one that finds a bug) it software component or system component to illustrated the desire of the software engineering evaluate one or more properties of interest. In community to separate fundamental development general, these
    [Show full text]
  • Lightweight Requirements Engineering Metrics Designing And
    Universiteit Leiden ICT in Business and the Public Sector Lightweight Requirements Engineering Metrics Designing and evaluating requirements engineering metrics for software development in complex IT environments – Case study Name: Jenny Yung Student-no: s0952249 Date: 18/04/2019 1st supervisor: Werner Heijstek 2nd supervisor: Guus Ramackers Pagina 1 van 83 Abstract The software development industry is relatively young and has matured considerably in the past 15 years. With several major transformations, the industry continues to seek ways to improve their delivery. A while ago, the waterfall method was the standard option for software development projects. Today, agile methodology is used more frequently. New development engineering practices are developed like standardization, continuous integration or continuous delivery. However, the consensus of being predictable and repeatable is not yet there. Agile software development and delivery are still not sufficiently reliable, resulting in expensive and unpredictable projects. In this thesis, measurements in requirements engineering are introduced. This paper presents a maturity model to assess the requirements engineering in complex IT environments. Companies strive to improve their software production and delivery, and the study aims to find a lightweight requirements metric method. The method is compared with a library of abstract metric models. The case study is performed at three different companies, and experts evaluated the conceptual metric system. As a result, a Requirements Engineering Maturity scan (REMS) is created. The tool suggests appropriate generic requirements metrics to deal with the encountered project. The paper concludes a review with related work and a discussion of the prospects for REMS. Keywords: Requirements Engineering • Quality Measurements • Metrics • ISO/IEC 9126 • Agile Methodology • Requirements Engineering Maturity Scan • Complex IT Infrastructure • Pagina 2 van 83 Acknowledgement Anyone writing a thesis will tell you it is a lot of work, and they are right.
    [Show full text]
  • Understanding ROI Metrics for Software Test Automation
    University of South Florida Scholar Commons Graduate Theses and Dissertations Graduate School 2005 Understanding ROI Metrics for Software Test Automation Naveen Jayachandran University of South Florida Follow this and additional works at: https://scholarcommons.usf.edu/etd Part of the American Studies Commons Scholar Commons Citation Jayachandran, Naveen, "Understanding ROI Metrics for Software Test Automation" (2005). Graduate Theses and Dissertations. https://scholarcommons.usf.edu/etd/2938 This Thesis is brought to you for free and open access by the Graduate School at Scholar Commons. It has been accepted for inclusion in Graduate Theses and Dissertations by an authorized administrator of Scholar Commons. For more information, please contact [email protected]. Understanding ROI Metrics for Software Test Automation by Naveen Jayachandran A thesis submitted in partial fulfillment of the requirements for the degree of Master of Science in Computer Science Department of Computer Science and Engineering College of Engineering University of South Florida Co-Major Professor: Dewey Rundus, Ph.D. Co-Major Professor: Alan Hevner, Ph.D. Member: Rafael Perez, Ph.D. Date of Approval: June 2, 2005 Keywords: Return on investment metrics, automated testing feasibility, manual vs. automated testing, software quality assurance, regression testing, repetitive testing © Copyright 2005, Naveen Jayachandran Dedication To my Parents, Suja, Rocky and Reemo. Acknowledgements I would like to thank my major professors Dr. Alan Hevner and Dr. Dewey Rundus for recognizing and encouraging my interest, giving me this opportunity and providing constant support for my research. I have gained immensely from this experience enabling me to truly appreciate the saying – ‘The journey is more important than the destination’.
    [Show full text]