@article {14690,
	title = {Evaluating Dynamic Software Update Safety Using Systematic Testing},
	journal = {IEEE Transactions on Software Engineering},
	volume = {PP},
	year = {2011},
	pages = {1 - 1},
	abstract = {Dynamic software updating (DSU) systems patch programs on the fly without incurring downtime. To avoid failures due to the updating process itself, many DSU systems employ timing restrictions. However, timing restrictions are theoretically imperfect, and their practical effectiveness is an open question. This paper presents the first significant empirical evaluation of three popular timing restrictions: activeness safety (AS), which prevents updates to active functions; con-freeness safety (CFS), which only allows modifications to active functions when doing so is provably type-safe; and manual identification of the event-handling loops during which an update may occur. We evaluated these timing restrictions using a series of DSU patches to three programs: OpenSSH, vsftpd, and ngIRCd. We systematically applied updates at each distinct update point reached during execution of a suite of system tests for these programs to determine which updates pass and which fail. We found that all three timing restrictions prevented most failures, but only manual identification allowed none. Further, although CFS and AS allowed many more update points, manual identification still supported updates with minimal delay. Finally, we found that manual identification required the least developer effort. Overall, we conclude that manual identification is most effective.},
	keywords = {and serviceability, Availability, Computer Systems Organization, Delay, Manuals, Performance of Systems, reliability, Safety, servers, software, software engineering, Test execution, Testing and Debugging},
	isbn = {0098-5589},
	doi = {10.1109/TSE.2011.101},
	author = {Hayden,C. and Smith,E. and Hardisty,E. and Hicks, Michael W. and Foster, Jeffrey S.}
}
@conference {15486,
	title = {Prioritizing component compatibility tests via user preferences},
	booktitle = {Software Maintenance, 2009. ICSM 2009. IEEE International Conference on},
	year = {2009},
	month = {2009/09//},
	pages = {29 - 38},
	abstract = {Many software systems rely on third-party components during their build process. Because the components are constantly evolving, quality assurance demands that developers perform compatibility testing to ensure that their software systems build correctly over all deployable combinations of component versions, also called configurations. However, large software systems can have many configurations, and compatibility testing is often time and resource constrained. We present a prioritization mechanism that enhances compatibility testing by examining the ldquomost importantrdquo configurations first, while distributing the work over a cluster of computers. We evaluate our new approach on two large scientific middleware systems and examine tradeoffs between the new prioritization approach and a previously developed lowest-cost-configuration-first approach.},
	keywords = {compatibility testing prioritization, component configurations, computer clusters, Middleware, Middleware systems, object-oriented programming, program testing, software engineering, Software systems, third-party components, user preferences},
	doi = {10.1109/ICSM.2009.5306357},
	author = {Yoon,Il-Chul and Sussman, Alan and Memon, Atif M. and Porter, Adam}
}
@inbook {19586,
	title = {Flow Analysis, Linearity, and PTIME},
	booktitle = {Static Analysis},
	series = {Lecture Notes in Computer Science},
	year = {2008},
	month = {2008/01/01/},
	pages = {255 - 269},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	abstract = {Flow analysis is a ubiquitous and much-studied component of compiler technology{\textemdash}and its variations abound. Amongst the most well known is Shivers{\textquoteright} 0CFA; however, the best known algorithm for 0CFA requires time cubic in the size of the analyzed program and is unlikely to be improved. Consequently, several analyses have been designed to approximate 0CFA by trading precision for faster computation. Henglein{\textquoteright}s simple closure analysis, for example, forfeits the notion of directionality in flows and enjoys an {\textquotedblleft}almost linear{\textquotedblright} time algorithm. But in making trade-offs between precision and complexity, what has been given up and what has been gained? Where do these analyses differ and where do they coincide? We identify a core language{\textemdash}the linear λ-calculus{\textemdash}where 0CFA, simple closure analysis, and many other known approximations or restrictions to 0CFA are rendered identical. Moreover, for this core language, analysis corresponds with (instrumented) evaluation. Because analysis faithfully captures evaluation, and because the linear λ-calculus is complete for ptime, we derive ptime-completeness results for all of these analyses.},
	keywords = {Logics and Meanings of Programs, Mathematical Logic and Formal Languages, Programming Languages, Compilers, Interpreters, Programming Techniques, software engineering},
	isbn = {978-3-540-69163-1, 978-3-540-69166-2},
	url = {http://link.springer.com/chapter/10.1007/978-3-540-69166-2_17},
	author = {David Van Horn and Mairson, Harry G.},
	editor = {Alpuente, Mar{\'\i}a and Vidal, Germ{\'a}n}
}
@inbook {19491,
	title = {Ecotopia: An Ecological Framework for Change Management in Distributed Systems},
	booktitle = {Architecting Dependable Systems IV},
	series = {Lecture Notes in Computer Science},
	year = {2007},
	month = {2007/01/01/},
	pages = {262 - 286},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	abstract = {Dynamic change management in an autonomic, service-oriented infrastructure is likely to disrupt the critical services delivered by the infrastructure. Furthermore, change management must accommodate complex real-world systems, where dependability and performance objectives are managed across multiple distributed service components and have specific criticality/value models. In this paper, we present Ecotopia, a framework for change management in complex service-oriented architectures (SOA) that is ecological in its intent: it schedules change operations with the goal of minimizing the service-delivery disruptions by accounting for their impact on the SOA environment. The change-planning functionality of Ecotopia is split between multiple objective-advisors and a system-level change-orchestrator component. The objective advisors assess the change-impact on service delivery by estimating the expected values of the Key Performance Indicators (KPIs), during and after change. The orchestrator uses the KPI estimations to assess the per-objective and overall business-value changes over a long time-horizon and to identify the scheduling plan that maximizes the overall business value. Ecotopia handles both external change requests, like software upgrades, and internal changes requests, like fault-recovery actions. We evaluate the Ecotopia framework using two realistic change-management scenarios in distributed enterprise systems.},
	keywords = {Autonomic Computing, Dynamic Change Management, Fault-Tolerant Architecture, Operating systems, Performability, Service Orchestration, software engineering},
	isbn = {978-3-540-74033-9, 978-3-540-74035-3},
	url = {http://link.springer.com/chapter/10.1007/978-3-540-74035-3_12},
	author = {Tudor Dumitras and Ro{\c s}u, Daniela and Dan, Asit and Narasimhan, Priya},
	editor = {Lemos, Rog{\'e}rio de and Gacek, Cristina and Romanovsky, Alexander}
}
@inbook {19453,
	title = {How Smart Homes Learn: The Evolution of the Networked Home and Household},
	booktitle = {UbiComp 2007: Ubiquitous Computing},
	series = {Lecture Notes in Computer Science},
	year = {2007},
	month = {2007/01/01/},
	pages = {127 - 144},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	abstract = {Despite a growing desire to create smart homes, we know little about how networked technologies interact with a house{\textquoteright}s infrastructure. In this paper, we begin to close this gap by presenting findings from a study that examined the relationship between home networking and the house itself{\textemdash}and the work that results for householders as a consequence of this interaction. We discuss four themes that emerged: an ambiguity in understanding the virtual boundaries created by wireless networks, the home network control paradox, a new home network access paradox, and the relationship between increased responsibilities and the possibilities of wireless networking.},
	keywords = {Computer Communication Networks, computers and society, home networking, Information Systems Applications (incl.Internet), infrastructure, smart home, software engineering, Systems and Data Security, User Interfaces and Human Computer Interaction},
	isbn = {978-3-540-74852-6, 978-3-540-74853-3},
	url = {http://link.springer.com/chapter/10.1007/978-3-540-74853-3_8},
	author = {Marshini Chetty and Sung, Ja-Young and Grinter, Rebecca E.},
	editor = {Krumm, John and Abowd, Gregory D. and Seneviratne, Aruna and Strang, Thomas}
}
@article {12352,
	title = {Parameterized Looped Schedules for Compact Representation of Execution Sequences in DSP Hardware and Software Implementation},
	journal = {IEEE Transactions on Signal Processing},
	volume = {55},
	year = {2007},
	month = {2007/06//},
	pages = {3126 - 3138},
	abstract = {In this paper, we present a technique for compact representation of execution sequences in terms of efficient looping constructs. Here, by a looping construct, we mean a compact way of specifying a finite repetition of a set of execution primitives. Such compaction, which can be viewed as a form of hierarchical run-length encoding (RLE), has application in many very large scale integration (VLSI) signal processing contexts, including efficient control generation for Kahn processes on field-programmable gate arrays (FPGAs), and software synthesis for static dataflow models of computation. In this paper, we significantly generalize previous models for loop-based code compaction of digital signal processing (DSP) programs to yield a configurable code compression methodology that exhibits a broad range of achievable tradeoffs. Specifically, we formally develop and apply to DSP hardware and software synthesis a parameterizable loop scheduling approach with compact format, dynamic reconfigurability, and low-overhead decompression},
	keywords = {Application software, array signal processing, code compression methodology, compact representation, Compaction, data compression, Design automation, Digital signal processing, digital signal processing chips, DSP, DSP hardware, embedded systems, Encoding, Field programmable gate arrays, field-programmable gate arrays (FPGAs), FPGA, Hardware, hierarchical runlength encoding, high-level synthesis, Kahn process, loop-based code compaction, looping construct, parameterized loop schedules, program compilers, reconfigurable design, runlength codes, scheduling, Signal generators, Signal processing, Signal synthesis, software engineering, software implementation, static dataflow models, Very large scale integration, VLSI},
	isbn = {1053-587X},
	doi = {10.1109/TSP.2007.893964},
	author = {Ming-Yung Ko and Zissulescu,C. and Puthenpurayil,S. and Bhattacharyya, Shuvra S. and Kienhuis,B. and Deprettere,E. F}
}
@article {15471,
	title = {Semantics-Preserving Design of Embedded Control Software from Synchronous Models},
	journal = {Software Engineering, IEEE Transactions on},
	volume = {33},
	year = {2007},
	month = {2007/08//},
	pages = {497 - 509},
	abstract = {The design of embedded controllers is experiencing a growth in complexity as embedded systems increase their functionality while they become ubiquitous in electronic appliances, cars, airplanes, etc. As requirements become more challenging, mathematical models gain importance for mastering complexity. Among the different computational models proposed, synchronous models have proved to be the most widely used for control dominated applications. While synchronous models simplify the way of dealing with concurrency by decoupling functional and timing aspects, their software implementation on multitasking and multiprocessor platforms is far from straightforward, because of the asynchronous nature of most industrial software platforms. Known solutions in the literature either restrict the solution space or focus on special cases. We present a method for preserving the synchronous semantics through buffer-based intertask communication mechanisms, grounded on an abstraction of the target platform. This allows us to deal with any task set and, most importantly, being independent of the implementation, to explore the design space effectively.},
	keywords = {embedded control software, embedded systems, multiprocessing programs, multiprocessor, multitasking, semantics-preserving design, software engineering, software implementation, systems analysis},
	isbn = {0098-5589},
	doi = {10.1109/TSE.2007.70718},
	author = {Mangeruca,L. and Baleani,M. and Ferrari,A. and Sangiovanni-Vincentelli,A.}
}
@article {15475,
	title = {Skoll: A Process and Infrastructure for Distributed Continuous Quality Assurance},
	journal = {Software Engineering, IEEE Transactions on},
	volume = {33},
	year = {2007},
	month = {2007/08//},
	pages = {510 - 525},
	abstract = {Software engineers increasingly emphasize agility and flexibility in their designs and development approaches. They increasingly use distributed development teams, rely on component assembly and deployment rather than green field code writing, rapidly evolve the system through incremental development and frequent updating, and use flexible product designs supporting extensive end-user customization. While agility and flexibility have many benefits, they also create an enormous number of potential system configurations built from rapidly changing component implementations. Since today{\textquoteright}s quality assurance (QA) techniques do not scale to handle highly configurable systems, we are developing and validating novel software QA processes and tools that leverage the extensive computing resources of user and developer communities in a distributed, continuous manner to improve software quality significantly. This paper provides several contributions to the study of distributed, continuous QA (DCQA). First, it shows the structure and functionality of Skoll, which is an environment that defines a generic around-the-world, around-the-clock QA process and several sophisticated tools that support this process. Second, it describes several novel QA processes built using the Skoll environment. Third, it presents two studies using Skoll: one involving user testing of the Mozilla browser and another involving continuous build, integration, and testing of the ACE+TAO communication software package. The results of our studies suggest that the Skoll environment can manage and control distributed continuous QA processes more effectively than conventional QA processes. For example, our DCQA processes rapidly identified problems that had taken the ACE+TAO developers much longer to find and several of which they had not found. Moreover, the automatic analysis of QA results provided developers information that enabled them to quickly find the root causes of problems},
	keywords = {ACE+TAO communication software package, component assembly, component deployment, distributed continuous quality assurance, distributed development teams, distributed processing, end-user customization, flexible product design, incremental development, object-oriented programming, Skoll, software engineering, Software quality, systems analysis},
	isbn = {0098-5589},
	doi = {10.1109/TSE.2007.70719},
	author = {Porter, Adam and Yilmaz,C. and Memon, Atif M. and Schmidt,D. C and Natarajan,B.}
}
@conference {12830,
	title = {A Software Architectural Approach to Security by Design},
	booktitle = {Computer Software and Applications Conference, 2006. COMPSAC {\textquoteright}06. 30th Annual International},
	volume = {2},
	year = {2006},
	month = {2006/09/17/21},
	pages = {83 - 86},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {This paper shows how an architecture description notation that has support for timed events can be used to provide a meta-language for specifying exact communication semantics. The advantages of such an approach is that a designer is made fully aware of the ramifications of her design choices so that an attacker can no longer take advantage of hidden assumptions},
	keywords = {architecture description notation, Clocks, communication semantics, Computer architecture, computer crime, computer security, Connectors, Costs, Degradation, Delay, Educational institutions, security design, security of data, Software architecture, software engineering},
	isbn = {0-7695-2655-1},
	doi = {10.1109/COMPSAC.2006.102},
	author = {Ray,A. and Cleaveland, Rance}
}
@inbook {19486,
	title = {Architecting and Implementing Versatile Dependability},
	booktitle = {Architecting Dependable Systems III},
	series = {Lecture Notes in Computer Science},
	year = {2005},
	month = {2005/01/01/},
	pages = {212 - 231},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	abstract = {Distributed applications must often consider and select the appropriate trade-offs among three important aspects {\textendash} fault-tolerance, performance and resources. We introduce a novel concept, called versatile dependability, that provides a framework for analyzing and reasoning about these trade-offs in dependable software architectures. We present the architecture of a middleware framework that implements versatile dependability by providing the appropriate {\textquotedblright}knobs{\textquotedblright} to tune and re-calibrate the trade-offs. Our framework can adjust the properties and the behavior of the system at development-time, at deployment-time, and throughout the application{\textquoteright}s life-cycle. This renders the versatile dependability approach useful both to applications that require static fault-tolerance configurations supporting the loss/addition of resources and changing workloads, as well as to applications that evolve in terms of their dependability requirements. Through a couple of specific examples, one on adapting the replication style at runtime and the other on tuning the system scalability under given constraints, we demonstrate concretely how versatile dependability can provide an extended coverage of the design space of dependable distributed systems.},
	keywords = {Operating systems, software engineering},
	isbn = {978-3-540-28968-5, 978-3-540-31648-0},
	url = {http://link.springer.com/chapter/10.1007/11556169_10},
	author = {Tudor Dumitras and Srivastava, Deepti and Narasimhan, Priya},
	editor = {Lemos, Rog{\'e}rio de and Gacek, Cristina and Romanovsky, Alexander}
}
@inbook {19494,
	title = {Fault-Tolerant Middleware and the Magical 1\%},
	booktitle = {Middleware 2005},
	series = {Lecture Notes in Computer Science},
	year = {2005},
	month = {2005/01/01/},
	pages = {431 - 441},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	abstract = {Through an extensive experimental analysis of over 900 possible configurations of a fault-tolerant middleware system, we present empirical evidence that the unpredictability inherent in such systems arises from merely 1\% of the remote invocations. The occurrence of very high latencies cannot be regulated through parameters such as the number of clients, the replication style and degree or the request rates. However, by selectively filtering out a {\textquotedblleft}magical 1\%{\textquotedblright} of the raw observations of various metrics, we show that performance, in terms of measured end-to-end latency and throughput, can be bounded, easy to understand and control. This simple statistical technique enables us to guarantee, with some level of confidence, bounds for percentile-based quality of service (QoS) metrics, which dramatically increase our ability to tune and control a middleware system in a predictable manner.},
	keywords = {Computer Communication Networks, Information Systems Applications (incl.Internet), Operating systems, Programming Languages, Compilers, Interpreters, Programming Techniques, software engineering},
	isbn = {978-3-540-30323-7, 978-3-540-32269-6},
	url = {http://link.springer.com/chapter/10.1007/11587552_24},
	author = {Tudor Dumitras and Narasimhan, Priya},
	editor = {Alonso, Gustavo}
}
@conference {19182,
	title = {Unifying artifacts and activities in a visual tool for distributed software development teams},
	booktitle = {26th International Conference on Software Engineering, 2004. ICSE 2004. Proceedings},
	year = {2004},
	month = {2004},
	pages = {387 - 396},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {In large projects, software developers struggle with two sources of complexity - the complexity of the code itself, and the complexity of the process of producing it. Both of these concerns have been subjected to considerable research investigation, and tools and techniques have been developed to help manage them. However, these solutions have generally been developed independently, making it difficult to deal with problems that inherently span both dimensions. We describe Augur, a visualization tool that supports distributed software development processes. Augur creates visual representations of both software artifacts and software development activities, and, crucially, allows developers to explore the relationship between them. Augur is designed not for managers, but for the developers participating in the software development process. We discuss some of the early results of informal evaluation with open source software developers. Our experiences to date suggest that combining views of artifacts and activities is both meaningful and valuable to software developers.},
	keywords = {Augur, complexity management, distributed programming, distributed software development teams, open source software developers, program visualisation, Programming, public domain software, software artifacts, software engineering, software tools, visual representations, visual tool, visualization tool},
	isbn = {0-7695-2163-0},
	author = {Jon Froehlich and Dourish,P.}
}
@conference {15428,
	title = {What test oracle should I use for effective GUI testing?},
	booktitle = {Automated Software Engineering, 2003. Proceedings. 18th IEEE International Conference on},
	year = {2003},
	month = {2003/10//},
	pages = {164 - 173},
	abstract = {Test designers widely believe that the overall effectiveness and cost of software testing depends largely on the type and number of test cases executed on the software. In this paper we show that the test oracle used during testing also contributes significantly to test effectiveness and cost. A test oracle is a mechanism that determines whether software executed correctly for a test case. We define a test oracle to contain two essential parts: oracle information that represents expected output; and an oracle procedure that compares the oracle information with the actual output. By varying the level of detail of oracle information and changing the oracle procedure, a test designer can create different types of test oracles. We design 11 types of test oracles and empirically compare them on four software systems. We seed faults in software to create 100 faulty versions, execute 600 test cases on each version, for all 11 types of oracles. In all, we report results of 660,000 test runs on software. We show (1) the time and space requirements of the oracles, (2) that faults are detected early in the testing process when using detailed oracle information and complex oracle procedures, although at a higher cost per test case, and (3) that employing expensive oracles results in detecting a large number of faults using relatively smaller number of test cases.},
	keywords = {empirical studies, graphical user interface, Graphical user interfaces, GUI testing, oracle information, oracle procedure, oracle space requirement, oracle time requirements, program testing, software engineering, Software testing, test cost, test effectiveness, test oracle},
	doi = {10.1109/ASE.2003.1240304},
	author = {Memon, Atif M. and Banerjee,I. and Nagarajan,A.}
}
@conference {12098,
	title = {A trend analysis of exploitations},
	booktitle = {2001 IEEE Symposium on Security and Privacy, 2001. S\&P 2001. Proceedings},
	year = {2001},
	month = {2001///},
	pages = {214 - 229},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {We have conducted an empirical study of a number of computer security exploits and determined that the rates at which incidents involving the exploit are reported to CERT can be modeled using a common mathematical framework. Data associated with three significant exploits involving vulnerabilities in phf, imap, and bind can all be modeled using the formula C=I+S{\texttimes}√M where C is the cumulative count of reported incidents, M is the time since the start of the exploit cycle, and I and S are the regression coefficients determined by analysis of the incident report data. Further analysis of two additional exploits involving vulnerabilities in mountd and statd confirm the model. We believe that the models will aid in predicting the severity of subsequent vulnerability exploitations, based on the rate of early incident reports},
	keywords = {Computer science, computer security exploits, Data analysis, data mining, Educational institutions, exploitations, Performance analysis, Predictive models, Regression analysis, Risk management, security of data, software engineering, system intrusions, System software, trend analysis, vulnerabilities, vulnerability exploitation},
	isbn = {0-7695-1046-9},
	doi = {10.1109/SECPRI.2001.924300},
	author = {Browne,H. K and Arbaugh, William A. and McHugh,J. and Fithen,W. L}
}
@article {17283,
	title = {Low-effort, high-payoff user interface reengineering},
	journal = {IEEE Software},
	volume = {14},
	year = {1997},
	month = {1997/08//Jul},
	pages = {66 - 72},
	abstract = {Although increasingly sophisticated design methodologies for developing new user interfaces exist, low-effort, high-payoff user interface reengineering represents a new direction-and opportunity. Yet reengineering a working system is complex and risky because of the potential disruption to users and managers, their justifiable fear of change, and the lack of guarantees that such changes will be for the better. Our largely positive experiences with the projects described here lead us to believe that user interface reengineering is a viable and important process. Low effort, high-payoff improvement recommendations can probably be made for most existing systems. Nevertheless, a narrowly focused user interface reengineering plan may be inappropriate when the major problems lie outside the scope of the user interface, such as inadequate functionalities, frequent crashes, and network problems. Attempts at improving less severe problems while ignoring deeper ones may be perceived as insensitive by the users. In such cases it is important to consider either making similar short-term improvements for other parts of the systems or postponing short-term user interface reengineering in favour of a more complete system reengineering. Similarly, the need for interface stability might outweigh the benefits of the short-term improvements if a complete reengineering is planned for the near future. But most likely these proposed diagnostic strategies and opportunities for improvement are only a prelude to the much larger task of business reengineering, which implies extensive user interface reengineering},
	keywords = {Business process re-engineering, complete system reengineering, Design methodology, Error analysis, Hardware, inadequate functionalities, interface stability, iterative methods, low-effort high-payoff user interface reengineering, short-term improvements, short-term user interface reengineering, software engineering, Software testing, System analysis and design, System testing, systems re-engineering, User centered design, user centred design, User interfaces},
	isbn = {0740-7459},
	doi = {10.1109/52.595958},
	author = {Plaisant, Catherine and Rose,A. and Shneiderman, Ben and Vanniamparampil,A. J}
}
@book {13298,
	title = {Image Analysis and Processing: 8th International Conference, Iciap {\textquoteright}95, San Remo, Italy, September 13-15, 1995 : Proceedings},
	year = {1995},
	month = {1995/09/28/},
	publisher = {Springer},
	organization = {Springer},
	abstract = {This book presents the proceedings of the 8th International Conference on Image Analysis and Processing, ICIAP {\textquoteright}95, held in Sanremo, Italy in September 1995 under the sponsorship of the International Association of Pattern Recognition IAPR.The volume presents 108 papers selected from more than 180 submissions together with six invited contributions. The papers are written by a total of 265 contributing authors and give a comprehensive state-of-the-art report on all current issues of image analysis and processing. Theoretical aspects are addressed as well as systems design and advanced applications, particularly in medical imaging.},
	keywords = {Artificial intelligence, COMPUTER AIDED DESIGN, Computer Graphics, Computer science, Computer vision, Computers / CAD-CAM, Computers / Computer Graphics, Computers / Computer Science, Computers / Computer Vision \& Pattern Recognition, Computers / Image Processing, Computers / Intelligence (AI) \& Semantics, Computers / Optical Data Processing, Computers / Software Development \& Engineering / General, Electronic books, IMAGE PROCESSING, Image processing/ Congresses, Imaging systems, Optical data processing, Optical pattern recognition, software engineering},
	isbn = {9783540602989},
	author = {Braccini,Carlo and De Floriani, Leila and Vernazza,Gianni}
}
@book {18433,
	title = {Software Specification: A Comparison of Formal Methods},
	year = {1994},
	month = {1994///},
	publisher = {Intellect Books},
	organization = {Intellect Books},
	keywords = {Computer software, Computer software/ Specifications, Computers / General, Computers / Programming / General, Formal methods (Computer science), software engineering, specifications},
	isbn = {9781567500332},
	author = {Gannon,John D. and Purtilo,James and Zelkowitz, Marvin V}
}
@article {16795,
	title = {Performance comparison of three modern DBMS architectures},
	journal = {IEEE Transactions on Software Engineering},
	volume = {19},
	year = {1993},
	month = {1993/02//},
	pages = {120 - 138},
	abstract = {The introduction of powerful workstations connected through local area networks (LANs) inspired new database management system (DBMS) architectures that offer high performance characteristics. The authors examine three such software architecture configurations: client-server (CS), the RAD-UNIFY type of DBMS (RU), and enhanced client-server (ECS). Their specific functional components and design rationales are discussed. Three simulation models are used to provide a performance comparison under different job workloads. Simulation results show that the RU almost always performs slightly better than the CS, especially under light workloads, and that ECS offers significant performance improvement over both CS and RU. Under reasonable update rates, the ECS over CS (or RU) performance ratio is almost proportional to the number of participating clients (for less than 32 clients). The authors also examine the impact of certain key parameters on the performance of the three architectures and show that ECS is more scalable that the other two},
	keywords = {client-server, Computational modeling, Computer architecture, database management systems, DBMS architectures, design rationales, functional components, Indexes, Local area networks, Military computing, Packaging, Performance analysis, performance evaluation, RAD-UNIFY type, simulation models, simulation results, Software architecture, software architecture configurations, software engineering, Throughput, Workstations},
	isbn = {0098-5589},
	doi = {10.1109/32.214830},
	author = {Delis,A. and Roussopoulos, Nick}
}
@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}
}
@book {18419,
	title = {Requirements For a Software Engineering Environment: Proceedings of the University of Maryland Workshop, May 5-8, 1986},
	year = {1989},
	month = {1989///},
	publisher = {Intellect Books},
	organization = {Intellect Books},
	keywords = {Computers / General, software engineering, Software engineering/ Congresses},
	isbn = {9780893914479},
	author = {Zelkowitz, Marvin V}
}
@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}
}
@article {16323,
	title = {Learning from examples: generation and evaluation of decision trees for software resource analysis},
	journal = {IEEE Transactions on Software Engineering},
	volume = {14},
	year = {1988},
	month = {1988/12//},
	pages = {1743 - 1757},
	abstract = {A general solution method for the automatic generation of decision (or classification) trees is investigated. The approach is to provide insights through in-depth empirical characterization and evaluation of decision trees for one problem domain, specifically, that of software resource data analysis. The purpose of the decision trees is to identify classes of objects (software modules) that had high development effort, i.e. in the uppermost quartile relative to past data. Sixteen software systems ranging from 3000 to 112000 source lines have been selected for analysis from a NASA production environment. The collection and analysis of 74 attributes (or metrics), for over 4700 objects, capture a multitude of information about the objects: development effort, faults, changes, design style, and implementation style. A total of 9600 decision trees are automatically generated and evaluated. The analysis focuses on the characterization and evaluation of decision tree accuracy, complexity, and composition. The decision trees correctly identified 79.3\% of the software modules that had high development effort or faults, on the average across all 9600 trees. The decision trees generated from the best parameter combinations correctly identified 88.4\% of the modules on the average. Visualization of the results is emphasized, and sample decision trees are included},
	keywords = {Analysis of variance, Artificial intelligence, Classification tree analysis, Data analysis, decision theory, Decision trees, Fault diagnosis, Information analysis, machine learning, metrics, NASA, production environment, software engineering, software modules, software resource analysis, Software systems, Termination of employment, trees (mathematics)},
	isbn = {0098-5589},
	doi = {10.1109/32.9061},
	author = {Selby,R. W and Porter, Adam}
}
