@conference {15491,
	title = {An Initial Characterization of Industrial Graphical User Interface Systems},
	booktitle = {Software Testing Verification and Validation, 2009. ICST {\textquoteright}09. International Conference on},
	year = {2009},
	month = {2009/04//},
	pages = {11 - 20},
	abstract = {To date we have developed and applied numerous model-based GUI testing techniques; however, we are unable to provide definitive improvement schemes to real-world GUI test planners, as our data was derived from open source applications, small compared to industrial systems. This paper presents a study of three industrial GUI-based software systems developed at ABB, including data on classified defects detected during late-phase testing and customer usage, test suites, and source code change metrics. The results show that (1) 50\% of the defects found through the GUI are categorized as data access and handling, control flow and sequencing, correctness, and processing defects, (2) system crashes exposed defects 12-19\% of the time, and (3) GUI and non-GUI components are constructed differently, in terms of source code metrics.},
	keywords = {Graphical user interfaces, GUI-based software systems, industrial graphical user interface systems, model-based GUI testing techniques, program testing, software metrics, source code change metrics},
	doi = {10.1109/ICST.2009.11},
	author = {Brooks,P.A. and Robinson,B.P. and Memon, Atif M.}
}
@conference {15485,
	title = {Introducing a test suite similarity metric for event sequence-based test cases},
	booktitle = {Software Maintenance, 2009. ICSM 2009. IEEE International Conference on},
	year = {2009},
	month = {2009/09//},
	pages = {243 - 252},
	abstract = {Most of today{\textquoteright}s event driven software (EDS) systems are tested using test cases that are carefully constructed as sequences of events; they test the execution of an event in the context of its preceding events. Because sizes of these test suites can be extremely large, researchers have developed techniques, such as reduction and minimization, to obtain test suites that are ldquosimilarrdquo to the original test suite, but smaller. Existing similarity metrics mostly use code coverage; they do not consider the contextual relationships between events. Consequently, reduction based on such metrics may eliminate desirable test cases. In this paper, we present a new parameterized metric, CONTeSSi(n) which uses the context of n preceding events in test cases to develop a new context-aware notion of test suite similarity for EDS. This metric is defined and evaluated by comparing four test suites for each of four open source applications. Our results show that CONT eSSi(n) is a better indicator of the similarity of EDS test suites than existing metrics.},
	keywords = {event driven software systems, event sequence-based test cases, open source systems, program testing, public domain software, software metrics, Software testing, test suite similarity metric},
	doi = {10.1109/ICSM.2009.5306305},
	author = {Brooks,P.A. and Memon, Atif M.}
}
@article {14805,
	title = {A tool to help tune where computation is performed},
	journal = {IEEE Transactions on Software Engineering},
	volume = {27},
	year = {2001},
	month = {2001/07//},
	pages = {618 - 629},
	abstract = {We introduce a new performance metric, called load balancing factor (LBF), to assist programmers when evaluating different tuning alternatives. The LBF metric differs from traditional performance metrics since it is intended to measure the performance implications of a specific tuning alternative rather than quantifying where time is spent in the current version of the program. A second unique aspect of the metric is that it provides guidance about moving work within a distributed or parallel program rather than reducing it. A variation of the LBF metric can also be used to predict the performance impact of changing the underlying network. The LBF metric is computed incrementally and online during the execution of the program to be tuned. We also present a case study that shows that our metric can accurately predict the actual performance gains for a test suite of six programs},
	keywords = {Computational modeling, Current measurement, Distributed computing, distributed program, distributed programming, load balancing factor, Load management, parallel program, parallel programming, Performance analysis, performance evaluation, Performance gain, performance metric, Programming profession, software metrics, software performance evaluation, Testing, Time measurement, tuning},
	isbn = {0098-5589},
	doi = {10.1109/32.935854},
	author = {Eom, Hyeonsang and Hollingsworth, Jeffrey K}
}
@conference {14784,
	title = {LBF: a performance metric for program reorganization},
	booktitle = {18th International Conference on Distributed Computing Systems, 1998. Proceedings},
	year = {1998},
	month = {1998/05/26/29},
	pages = {222 - 229},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {We introduce a new performance metric, called Load Balancing Factor (LBF), to assist programmers with evaluating different tuning alternatives. The LBF metric differs from traditional performance metrics since it is intended to measure the performance implications of a specific tuning alternative rather than quantifying where time is spent in the current version of the program. A second unique aspect of the metric is that it provides guidance about moving work within a distributed or parallel program rather than reducing it. A variation of the LBF metric can also be used to predict the performance impact of changing the underlying network. The LBF metric can be computed incrementally and online during the execution of the program to be tuned. We also present a case study that shows that our metric can predict the actual performance gains accurately for a test suite of six programs},
	keywords = {case study, Computational modeling, computer network, Computer science, Debugging, distributed processing, distributed program, Educational institutions, Integrated circuit testing, LBF metric, load balancing factor, Load management, measurement, NIST, parallel program, parallel programming, performance metric, program reorganization, program tuning, Programming profession, resource allocation, software metrics, software performance evaluation, US Department of Energy},
	isbn = {0-8186-8292-2},
	doi = {10.1109/ICDCS.1998.679505},
	author = {Eom, H. and Hollingsworth, Jeffrey K}
}
@article {14804,
	title = {Modeling and evaluating design alternatives for an on-line instrumentation system: a case study},
	journal = {IEEE Transactions on Software Engineering},
	volume = {24},
	year = {1998},
	month = {1998/06//},
	pages = {451 - 470},
	abstract = {This paper demonstrates the use of a model-based evaluation approach for instrumentation systems (ISs). The overall objective of this study is to provide early feedback to tool developers regarding IS overhead and performance; such feedback helps developers make appropriate design decisions about alternative system configurations and task scheduling policies. We consider three types of system architectures: network of workstations (NOW), symmetric multiprocessors (SMP), and massively parallel processing (MPP) systems. We develop a Resource OCCupancy (ROCC) model for an on-line IS for an existing tool and parameterize it for an IBM SP-2 platform. This model is simulated to answer several {\textquotedblleft}what if{\textquotedblright} questions regarding two policies to schedule instrumentation data forwarding: collect-and-forward (CF) and batch-and-forward (BF). In addition, this study investigates two alternatives for forwarding the instrumentation data: direct and binary tree forwarding for an MPP system. Simulation results indicate that the BF policy can significantly reduce the overhead and that the tree forwarding configuration exhibits desirable scalability characteristics for MPP systems. Initial measurement-based testing results indicate more than 60 percent reduction in the direct IS overhead when the BF policy was added to Paradyn parallel performance measurement tool},
	keywords = {alternative system configurations, Application software, batch-and-forward, collect-and-forward, Computer aided software engineering, design alternatives, design decisions, Feedback, IBM SP-2 platform, Instruments, massively parallel processing, model-based evaluation approach, Monitoring, multiprocessing programs, on-line instrumentation system, Paradyn parallel performance measurement tool, PARALLEL PROCESSING, Real time systems, scalability characteristics, software metrics, software tools, Space technology, symmetric multiprocessors, system architectures, system monitoring, System testing, task scheduling policies, tool developers, tree forwarding configuration, Workstations},
	isbn = {0098-5589},
	doi = {10.1109/32.689402},
	author = {Waheed, A. and Rover, D. T and Hollingsworth, Jeffrey K}
}
@conference {14813,
	title = {MDL: a language and compiler for dynamic program instrumentation},
	booktitle = {, 1997 International Conference on Parallel Architectures and Compilation Techniques., 1997. Proceedings},
	year = {1997},
	month = {1997/11/10/14},
	pages = {201 - 212},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {We use a form of dynamic code generation, called dynamic instrumentation, to collect data about the execution of an application program. Dynamic instrumentation allows us to instrument running programs to collect performance and other types of information. The instrumentation code is generated incrementally and can be inserted and removed at any time. Our instrumentation currently runs on the SPARC, PA-RISC, Power 2, Alpha, and x86 architectures. Specification of what data to collect are written in a specialized language called the Metric Description Language, that is part of the Paradyn Parallel Performance Tools. This language allows platform independent descriptions of how to collect performance data. It also provides a concise way to specify, how to constrain performance data to particular resources such as modules, procedures, nodes, files, or message channels (or combinations of these resources). We also describe the details of how we weave instrumentation into a running program},
	keywords = {Alpha architecture, application program, application program interfaces, Application software, compiler generators, Computer science, dynamic code generation, Dynamic compiler, dynamic program instrumentation, Educational institutions, files, instrumentation code, Instruments, MDL, measurement, message channels, Message passing, Metric Description Language, modules, nodes, Operating systems, optimising compilers, PA-RISC, Paradyn Parallel Performance Tools, Parallel architectures, parallel programming, performance data, platform independent descriptions, Power 2 architecture, Power generation, procedures, program debugging, Program processors, running programs, Runtime, software metrics, SPARC, Specification languages, x86 architecture},
	isbn = {0-8186-8090-3},
	doi = {10.1109/PACT.1997.644016},
	author = {Hollingsworth, Jeffrey K and Niam, O. and Miller, B. P and Zhichen Xu and Goncalves,M. J.R and Ling Zheng}
}
@article {17485,
	title = {Visual and textual consistency checking tools for graphical user interfaces},
	journal = {IEEE Transactions on Software Engineering},
	volume = {23},
	year = {1997},
	month = {1997/11//},
	pages = {722 - 735},
	abstract = {Designing user interfaces with consistent visual and textual properties is difficult. To demonstrate the harmful effects of inconsistency, we conducted an experiment with 60 subjects. Inconsistent interface terminology slowed user performance by 10 to 25 percent. Unfortunately, contemporary software tools provide only modest support for consistency control. Therefore, we developed SHERLOCK, a family of consistency analysis tools, which evaluates visual and textual properties of user interfaces. It provides graphical analysis tools such as a dialog box summary table that presents a compact overview of visual properties of all dialog boxes. SHERLOCK provides terminology analysis tools including an interface concordance, an interface spellchecker, and terminology baskets to check for inconsistent use of familiar groups of terms. Button analysis tools include a button concordance and a button layout table to detect variant capitalization, distinct typefaces, distinct colors, variant button sizes, and inconsistent button placements. We describe the design, software architecture, and the use of SHERLOCK. We tested SHERLOCK with four commercial prototypes. The outputs, analysis, and feedback from designers of the applications are presented},
	keywords = {button analysis tools, Color, dialog box summary table, experiment, graphical analysis tools, Graphical user interfaces, human factors, inconsistent interface terminology, interface color, interface spell checker, Output feedback, Prototypes, SHERLOCK, Software architecture, Software design, software metrics, software prototyping, software tools, Terminology, terminology analysis tools, Testing, textual consistency checking tools, user interface management systems, User interfaces, user performance, visual consistency checking tools},
	isbn = {0098-5589},
	doi = {10.1109/32.637386},
	author = {Mahajan,R. and Shneiderman, Ben}
}
@article {16330,
	title = {Empirically guided software development using metric-based classification trees},
	journal = {IEEE Software},
	volume = {7},
	year = {1990},
	month = {1990/03//},
	pages = {46 - 54},
	abstract = {The identification of high-risk components early in the life cycle is addressed. A solution that casts this as a classification problem is examined. The proposed approach derives models of problematic components, based on their measurable attributes and those of their development processes. The models provide a basis for forecasting which components are likely to share the same high-risk properties, such as being error-prone or having a high development cost. Developers can use these classification techniques to localize the troublesome 20\% of the system. The method for generating the models, called automatic generation of metric-based classification trees, uses metrics from previous releases or projects to identify components that are historically high-risk.},
	keywords = {Application software, Area measurement, automatic generation, classification problem, Classification tree analysis, Costs, empirically guided software development, Error correction, life cycle, measurable attributes, metric-based classification trees, Predictive models, Programming, software engineering, Software measurement, software metrics, Software systems},
	isbn = {0740-7459},
	doi = {10.1109/52.50773},
	author = {Porter, Adam and Selby,R. W}
}
@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}
}
