@conference {14736,
	title = {State transfer for clear and efficient runtime updates},
	booktitle = {2011 IEEE 27th International Conference on Data Engineering Workshops (ICDEW)},
	year = {2011},
	month = {2011/04/11/16},
	pages = {179 - 184},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {Dynamic software updating (DSU), the practice of updating software while it executes, is a lively area of research. The DSU approach most prominent in both commercial and research systems is in-place updating, in which patches containing program modifications are loaded into a running process. However, in-place updating suffers from several problems: it requires complex tool support, it may adversely affect the performance of normal execution, it requires challenging reasoning to understand the behavior of an updated program, and it requires extra effort to modify program state to be compatible with an update. This paper presents preliminary work investigating the potential for state transfer updating to address these problems. State transfer updates work by launching a new process running the updated program version and transferring program state from the running process to the updated version. In this paper, we describe the use and implementation of Ekiden, a new state transfer updating library for C/C++ programs. Ekiden seeks to redress the difficulties of in-place updating, and we report on our experience updating VSFTPD using Ekiden. This initial experience suggests that state transfer provides the availability benefits of in-place DSU approaches while addressing many of their shortcomings.},
	keywords = {C++ language, C++ program, Cognition, complex tool support, dynamic software updating, efficient runtime update, in-place DSU approach, Libraries, Operating systems, program modification, Program processors, program transfer, program version, Runtime, servers, software libraries, Software maintenance, state transfer update, Steady-state, updating library, VSFTPD},
	isbn = {978-1-4244-9195-7},
	doi = {10.1109/ICDEW.2011.5767632},
	author = {Hayden,C.M. and Smith,E. K and Hicks, Michael W. and Foster, Jeffrey S.}
}
@conference {15494,
	title = {An Extensible Heuristic-Based Framework for GUI Test Case Maintenance},
	booktitle = {Software Testing, Verification and Validation Workshops, 2009. ICSTW {\textquoteright}09. International Conference on},
	year = {2009},
	month = {2009/04//},
	pages = {251 - 254},
	abstract = {Graphical user interfaces (GUIs) make up a large portion of the code comprising many modern software applications. However, GUI testing differs significantly from testing of traditional software. One respect in which this is true is test case maintenance. Due to the way that GUI test cases are often implemented, relatively minor changes to the construction of the GUI can cause a large number of test case executions to malfunction, often because GUI elements referred to by the test cases have been renamed, moved, or otherwise altered. We posit that a general solution to the problem of GUI test case maintenance must be based on heuristics that attempt to match an applicationpsilas GUI elements across versions. We demonstrate the use of some heuristics with framework support. Our tool support is general in that it may be used with other heuristics if needed in the future.},
	keywords = {extensible heuristic-based framework, graphical user interface, Graphical user interfaces, GUI code, GUI test case maintenance, program testing, Software maintenance},
	doi = {10.1109/ICSTW.2009.11},
	author = {McMaster,S. and Memon, Atif M.}
}
@conference {15481,
	title = {Call stack coverage for test suite reduction},
	booktitle = {Software Maintenance, 2005. ICSM{\textquoteright}05. Proceedings of the 21st IEEE International Conference on},
	year = {2005},
	month = {2005/09//},
	pages = {539 - 548},
	abstract = {Test suite reduction is an important test maintenance activity that attempts to reduce the size of a test suite with respect to some criteria. Emerging trends in software development such as component reuse, multi-language implementations, and stringent performance requirements present new challenges for existing reduction techniques that may limit their applicability. A test suite reduction technique that is not affected by these challenges is presented; it is based on dynamically generated language-independent information that can be collected with little run-time overhead. Specifically, test cases from the suite being reduced are executed on the application under test and the call stacks produced during execution are recorded. These call stacks are then used as a coverage requirement in a test suite reduction algorithm. Results of experiments on test suites for the space antenna-steering application show significant reduction in test suite size at the cost of a moderate loss in fault detection effectiveness.},
	keywords = {call stack coverage, component reuse, Fault detection, language-independent information, multi-language implementation, program testing, software development, software fault tolerance, Software maintenance, software reusability, space antenna-steering application, stringent performance requirement, systems analysis, test suite reduction algorithm},
	doi = {10.1109/ICSM.2005.29},
	author = {McMaster,S. and Memon, Atif M.}
}
@conference {15482,
	title = {Rapid "crash testing" for continuously evolving GUI-based software applications},
	booktitle = {Software Maintenance, 2005. ICSM{\textquoteright}05. Proceedings of the 21st IEEE International Conference on},
	year = {2005},
	month = {2005/09//},
	pages = {473 - 482},
	abstract = {Several rapid-feedback-based quality assurance mechanisms are used to manage the quality of continuously evolving software. Even though graphical user interfaces (GUIs) are one of the most important parts of software, there are currently no mechanisms to quickly retest evolving GUI software. We leverage our previous work on GUI testing to define a new automatic GUI re-testing process called "crash testing" that is integrated with GUI evolution. We describe two levels of crash testing: (1) immediate feedback-based in which a developer indicates that a GUI bug was fixed in response to a previously reported crash; only select crash test cases are rerun and the developer is notified of the results in a matter of seconds, and (2) between code changes in which new crash test cases are generated on-the-fly and executed on the GUI. Since the code may be changed by another developer before all the crash tests have been executed, hence requiring restarting of the process, we use a simple rotation-based scheme to ensure that all crash tests are executed over a series of code changes. We show, via empirical studies, that our crash tests are effective at revealing serious problems in the GUI.},
	keywords = {crash testing, graphical user interface software retesting, Graphical user interfaces, GUI-based software application, immediate feedback, program testing, rapid-feedback-based quality assurance, software evolution, Software maintenance, software prototyping, Software quality},
	doi = {10.1109/ICSM.2005.72},
	author = {Xie,Q. and Memon, Atif M.}
}
@article {15474,
	title = {Studying the fault-detection effectiveness of GUI test cases for rapidly evolving software},
	journal = {Software Engineering, IEEE Transactions on},
	volume = {31},
	year = {2005},
	month = {2005/10//},
	pages = {884 - 896},
	abstract = {Software is increasingly being developed/maintained by multiple, often geographically distributed developers working concurrently. Consequently, rapid-feedback-based quality assurance mechanisms such as daily builds and smoke regression tests, which help to detect and eliminate defects early during software development and maintenance, have become important. This paper addresses a major weakness of current smoke regression testing techniques, i.e., their inability to automatically (re)test graphical user interfaces (GUIs). Several contributions are made to the area of GUI smoke testing. First, the requirements for GUI smoke testing are identified and a GUI smoke test is formally defined as a specialized sequence of events. Second, a GUI smoke regression testing process called daily automated regression tester (DART) that automates GUI smoke testing is presented. Third, the interplay between several characteristics of GUI smoke test suites including their size, fault detection ability, and test oracles is empirically studied. The results show that: 1) the entire smoke testing process is feasible in terms of execution time, storage space, and manual effort, 2) smoke tests cannot cover certain parts of the application code, 3) having comprehensive test oracles may make up for not having long smoke test cases, and 4) using certain oracles can make up for not having large smoke test suites.},
	keywords = {daily automated regression tester, Fault diagnosis, fault-detection, formal specification, formal verification, Graphical user interfaces, GUI test cases, program testing, quality assurance mechanism, rapidly evolving software, smoke regression testing technique, software development, software fault tolerance, Software maintenance, software prototyping, Software quality, test oracles},
	isbn = {0098-5589},
	doi = {10.1109/TSE.2005.117},
	author = {Memon, Atif M. and Xie,Q.}
}
@conference {15480,
	title = {Empirical evaluation of the fault-detection effectiveness of smoke regression test cases for GUI-based software},
	booktitle = {Software Maintenance, 2004. Proceedings. 20th IEEE International Conference on},
	year = {2004},
	month = {2004/09//},
	pages = {8 - 17},
	abstract = {Daily builds and smoke regression tests have become popular quality assurance mechanisms to detect defects early during software development and maintenance. In previous work, we addressed a major weakness of current smoke regression testing techniques, i.e., their lack of ability to automatically (re)test graphical user interface (GUI) event interactions - we presented a GUI smoke regression testing process called daily automated regression tester (DART). We have deployed DART and have found several interesting characteristics of GUI smoke tests that we empirically demonstrate in this paper. We also combine smoke tests with different types of test oracles and present guidelines for practitioners to help them generate and execute the most effective combinations of test-case length and test oracle complexity. Our experimental subjects consist of four GUI-based applications. We generate 5000-8000 smoke tests (enough to be run in one night) for each application. Our results show that: (1) short GUI smoke tests with certain test oracles are effective at detecting a large number of faults; (2) there are classes of faults that our smoke test cannot detect; (3) short smoke tests execute a large percentage of code; and (4) the entire smoke testing process is feasible to do in terms of execution time and storage space.},
	keywords = {daily automated regression tester, daily builds, fault-detection effectiveness, graphical user interface, Graphical user interfaces, GUI-based software, program testing, Quality assurance, Regression analysis, smoke regression test cases, software development, software fault tolerance, Software maintenance, Software quality, software quality assurance, test oracle complexity, test oracles, test-case length},
	doi = {10.1109/ICSM.2004.1357785},
	author = {Memon, Atif M. and Xie,Qing}
}
@article {15498,
	title = {Preserving distributed systems critical properties: a model-driven approach},
	journal = {Software, IEEE},
	volume = {21},
	year = {2004},
	month = {2004///},
	pages = {32 - 40},
	abstract = {The need for creating predictability in distributed systems is most often specified in terms of quality-of-service (QoS) requirements, which help define the acceptable levels of dependability with which capabilities such as processing capacity, data throughput, or service availability reach users. For longer-term properties such as scalability, maintainability, adaptability, and system security, we can similarly use persistent software attributes (PSAs) to specify how and to what degree such properties must remain intact as a network expands and evolves over time. The Skoll distributed continuous software quality assurance process helps to identify viable system and software configurations for meeting stringent QOS and PSA requirements by coordinating the use of distributed computing resources. The authors tested their process using the large, rapidly evolving ACE+TAO middleware suite.},
	keywords = {configuration management, formal verification, Middleware, middleware suite, model-driven approach, persistent software attributes, QoS requirements, Quality assurance, quality of service, quality-of-service, Skoll distributed computing resources, software configuration, Software maintenance, Software quality, software quality assurance process, system dependability},
	isbn = {0740-7459},
	doi = {10.1109/MS.2004.50},
	author = {Yilmaz,C. and Memon, Atif M. and Porter, Adam and Krishna,A. S and Schmidt,D. C and Gokhale,A. and Natarajan,B.}
}
@conference {15479,
	title = {DART: a framework for regression testing "nightly/daily builds" of GUI applications},
	booktitle = {Software Maintenance, 2003. ICSM 2003. Proceedings. International Conference on},
	year = {2003},
	month = {2003/09//},
	pages = {410 - 419},
	abstract = {"Nightly/daily building and smoke testing" have become widespread since they often reveal bugs early in the software development process. During these builds, software is compiled, linked, and (re)tested with the goal of validating its basic functionality. Although successful for conventional software, smoke tests are difficult to develop and automatically rerun for software that has a graphical user interface (GUI). In this paper, we describe a framework called DART (daily automated regression tester) that addresses the needs of frequent and automated re-testing of GUI software. The key to our success is automation: DART automates everything from structural GUI analysis; test case generation; test oracle creation; to code instrumentation; test execution; coverage evaluation; regeneration of test cases; and their re-execution. Together with the operating system{\textquoteright}s task scheduler, DART can execute frequently with little input from the developer/tester to retest the GUI software. We provide results of experiments showing the time taken and memory required for GUI analysis, test case and test oracle generation, and test execution. We also empirically compare the relative costs of employing different levels of detail in the GUI test cases.},
	keywords = {automated retesting, automatic test software, coverage evaluation, daily automated regression tester, DART, frequent retesting, graphical user interface, Graphical user interfaces, GUI software, instrumentation coding, program testing, regression testing, Software development management, Software development process, Software maintenance, Software quality, structural GUI analysis, Test Case Generation, test cases regeneration, Test execution, test oracle creation},
	doi = {10.1109/ICSM.2003.1235451},
	author = {Memon, Atif M. and Banerjee,I. and Hashmi,N. and Nagarajan,A.}
}
@conference {16320,
	title = {Software metric classification trees help guide the maintenance of large-scale systems},
	booktitle = {, Conference on Software Maintenance, 1989., Proceedings},
	year = {1989},
	month = {1989/10/16/19},
	pages = {116 - 123},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {The 80:20 rule states that approximately 20\% of a software system is responsible for 80\% of its errors. The authors propose an automated method for generating empirically-based models of error-prone software objects. These models are intended to help localize the troublesome 20\%. The method uses a recursive algorithm to automatically generate classification trees whose nodes are multivalued functions based on software metrics. The purpose of the classification trees is to identify components that are likely to be error prone or costly, so that developers can focus their resources accordingly. A feasibility study was conducted using 16 NASA projects. On average, the classification trees correctly identified 79.3\% of the software modules that had high development effort or faults},
	keywords = {automated method, automatic programming, classification, Classification tree analysis, classification trees, Computer errors, empirically-based models, error-prone software objects, Fault diagnosis, feasibility study, high development effort, Large-scale systems, multivalued functions, NASA, NASA projects, recursive algorithm, Software algorithms, software engineering, Software maintenance, Software measurement, software metrics, software modules, Software systems, trees (mathematics)},
	isbn = {0-8186-1965-1},
	doi = {10.1109/ICSM.1989.65202},
	author = {Selby,R. W and Porter, Adam}
}
