@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}
}
@article {14708,
	title = {Modular Information Hiding and Type-Safe Linking for C},
	journal = {IEEE Transactions on Software Engineering},
	volume = {34},
	year = {2008},
	month = {2008/06//May},
	pages = {357 - 376},
	abstract = {This paper presents CMod, a novel tool that provides a sound module system for C. CMod works by enforcing four rules that are based on principles of modular reasoning and on current programming practice. CMod{\textquoteright}s rules flesh out the convention that .h header files are module interfaces and .c source files are module implementations. Although this convention is well-known, existing explanations of it are incomplete, omitting important subtleties needed for soundness. In contrast, we have proven formally that CMod{\textquoteright}s rules enforce both information hiding and type-safe linking. To use CMod, the programmer develops and builds their software as usual, redirecting the compiler and linker to CMod{\textquoteright}s wrappers. We evaluated CMod by applying it to 30 open source programs, totaling more than one million LoC. Violations to CMod{\textquoteright}s rules revealed more than a thousand information hiding errors, dozens of typing errors, and hundreds of cases that, although not currently bugs, make programming mistakes more likely as the code evolves. At the same time, programs generally adhere to the assumptions underlying CMod{\textquoteright}s rules, and so we could fix rule violations with a modest effort. We conclude that CMod can effectively support modular programming in C: it soundly enforces type-safe linking and information-hiding while being largely compatible with existing practice.},
	keywords = {C language, CMOD, Code design, Coding Tools and Techniques, compiler, data encapsulation, Information hiding, modular information hiding, modular reasoning, modules, object-oriented programming, open source programs, packages, program compilers, public domain software, reliability, software reusability, type-safe linking},
	isbn = {0098-5589},
	doi = {10.1109/TSE.2008.25},
	author = {Srivastava,S. and Hicks, Michael W. and Foster, Jeffrey S. and Jenkins,P.}
}
@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.}
}
