We gain insight to the COVID-19 pandemic response by the various U.S. states through analysis of open source emergency declaration, mitigation, and response policy data. We propose ASNM + POD, a Partial Ordering Detection extension to the Adaptive Sorted Neighborhood Method to identify redundancies and implied temporal ordering requirements to understand how various U.S. states respond to COVID-19. We further strengthen the well-established ASNM entity matching method and address key limitations of its Longest Common Subsequence extension (ASNM + LCS) through detection of all temporal order requirements. Partial order requirements are determined probabilistically through empirical review of all records’ time-ordered event sequences. We demonstrate effectiveness against a COVID-19 U.S. state policy dataset comprised of daily time-series data pulled from February and October 2022, where attributes are partially and variably populated. ASNM + POD yielded an F1 of 0.995 and an MCC of 0.985, significantly outperforming both ASNM and ASNM + LCS with F1/MCC improvements of 22%/50% and 15%/37%, respectively. Finally, we highlight the limited consensus on policies enacted, the variability in timelines of policy activations/deactivations, and activity at and after the two-year mark.

In this paper we present an empirical study of relationships between three source code lexicons: the identifier, comment, and literal lexicons. We conjecture that shared and unique properties of these lexicons for the given subject system can inform the configuration of a source code retrieval technique for a particular software understanding activity or software evolution task. Thus, we seek to discover these lexicon properties, and so we investigate five lexicon measures that consider term frequency, term density, and term provenance.

As Web services and the semantic Web become more important, enabling technologies such as Web service ontologies will grow larger. The ability of mobile devices, such as cell phones and PDAs, to download and reason across them will be severely limited. Given that an agent on a mobile device only needs a subset of what is described in a Web service ontology, an ontology sub-graph can be created. In this paper, we develop a empirical software engineering approach to build a prediction model to measure the quality in terms of correct query handling of ontology sub-graphs relative to the original ontology - mean average recall of the sub-graph compared to the original ontology is used as the quality standard. Our metrics allow speedy selection of a sub-graph for use by a mobile device.

Abstract Correctness of concurrent software is usually checked by techniques such as peer code reviews or code walkthroughs and testing. These techniques, however, are subject to human error, and thus do not achieve an in‐depth verification of correctness. Model‐checking techniques, which can systematically identify and verify every state that a system can enter, are a powerful alternative method for verifying concurrent systems. However, the usefulness of model checking is limited because the number of states for concurrent models grows exponentially with the number of processes in the system. This is often referred to as the ‘state explosion problem.’ Some processes are a central part of the software operation and must be included in the model. However, we have found that some exponential complexity results due to uncontrolled concurrency introduced by the programmer rather than due to the intrinsic characteristics of the software being modeled. We have performed tests on multimedia synchronization to show the effect of abstraction as well as uncontrolled concurrency using the Promela/SPIN model checker. We begin with a sequential model not expected to have exponential complexity but that results in exponential complexity. In this paper, we provide alternative designs and explain how uncontrolled concurrency can be removed from the code. Copyright © 2007 John Wiley & Sons, Ltd.

Abstract The authors describe their research which improves software reuse by using an automated approach to semantically search for and retrieve reusable software components in large software component repositories and on the World Wide Web (WWW). Using automation and smart (semantic) techniques, their approach speeds up the search and retrieval of reusable software components, while retaining good accuracy, and therefore improves the affordability of software reuse. A program understanding of software components and natural language understanding of user queries was employed. Then the software component descriptions were compared by matching the resulting semantic representations of the user queries to the semantic representations of the software components to search for software components that best match the user queries. A proof of concept system was developed to test the authors' approach. The results of this proof of concept system were compared to human experts, and statistical analysis was performed on the collected experimental data. The results from these experiments demonstrate that this automated semantic‐based approach for software reusable component classification and retrieval is successful when compared to the labor‐intensive results from the experts, thus showing that this approach can significantly benefit software reuse classification and retrieval.

Abstract Empirical studies have shown complexity metrics to be good predictors of testing effort and maintainability in traditional, imperative programming languages. Empirical validation studies have also shown that complexity is a good predictor of initial quality and reliability in object‐oriented (OO) software. To date, one of the most empirically validated OO complexity metrics is the Chidamber and Kemerer Weighted Methods in a Class (WMC). However, there are many more OO complexity metrics whose predictive power has not been as extensively explored. In this study, we explore the predictive ability of several complexity‐related metrics for OO software that have not been heavily validated. We do this by exploring their ability to measure quality in an evolutionary software process, by correlating these metrics to defect data for six versions of Rhino, an open‐source implementation of JavaScript written in Java. Using statistical techniques such as Spearman's correlation, principal component analysis, binary logistic regression models and their respective validations, we show that some lesser known complexity metrics including Michuraet al.'s standard deviation method complexity and Etzkornet al.'s average method complexity are more consistent predictors of OO quality than any variant of the Chidamber and Kemerer WMC metric. We also show that these metrics are useful in identifying fault‐prone classes in software developed using highly iterative or agile software development processes. Copyright © 2008 John Wiley & Sons, Ltd.

Abstract Many application areas today make use of ontologies. With the advent of semantic Web technologies, ontology based systems have become widespread. Developing an ontology is part of the necessary early development of an ontology‐based system. Since the validity and quality of the ontology data directly affects the validity and quality of the system using the ontology, evolution of the ontology data directly affects the evolution and/or maintenance of the ontology‐based systems that depend on and employ the ontology data. Our research examines the quality, completeness, and stability of ontology data as ontologies evolve. We propose a metrics suite, based on standard software quality concepts, to measure the complexity and cohesion of ontology data. First we theoretically validate our metrics. Then we examine empirically whether our metrics determine ontology data quality, by comparing them to human evaluator ratings. We conclude that several of our metrics successfully determine ontology complexity or cohesion. Finally, we examine, over evolving ontology data, whether our metrics determine ontology completeness and stability. We determine that various metrics reflect different kinds of changes. Our experiments indicate our metrics' measure ontology stability and completeness; however, interpretation of specific metrics values and the interaction of different metrics requires further study. Copyright © 2007 John Wiley & Sons, Ltd.

Empirical validation of software metrics suites to predict fault proneness in object-oriented (OO) components is essential to ensure their practical use in industrial settings. In this paper, we empirically validate three OO metrics suites for their ability to predict software quality in terms of fault-proneness: the Chidamber and Kemerer (CK) metrics, Abreu's Metrics for Object-Oriented Design (MOOD), and Bansiya and Davis' Quality Metrics for Object-Oriented Design (QMOOD). Some CK class metrics have previously been shown to be good predictors of initial OO software quality. However, the other two suites have not been heavily validated except by their original proposers. Here, we explore the ability of these three metrics suites to predict fault-prone classes using defect data for six versions of Rhino, an open-source implementation of JavaScript written in Java. We conclude that the CK and QMOOD suites contain similar components and produce statistical models that are effective in detecting error-prone classes. We also conclude that the class components in the MOOD metrics suite are not good class fault-proneness predictors. Analyzing multivariate binary logistic regression models across six Rhino versions indicates these models may be useful in assessing quality in OO classes produced using modern highly iterative or agile software development processes.

Program comprehension involves the process of extracting properties from a program in order to achieve a better understanding of the software system. The most common approaches are code-based with focus primarily on the program code. More attention needs to be given to information encoded in comments and identifiers and the valuable clues they may provide. This paper describes a technique that combines a code-based program understanding approach with a comment understanding approach. The goal is to match the comments and identifiers to the code in order to obtain a comprehensive understanding of the software under analysis. The method has application to software development and maintenance. It can also be used as an instructional tool for software students

Abstract Assessing progress and stability in rapid, highly iterative and agile object‐oriented software development processes is difficult because program evolution appears somewhat disorderly. With agile software development methods, the expected time to reach software stability is obscured by the dynamic nature of the agile process itself. The System Design Instability (SDI) metric was developed to help analyze object‐oriented software evolution under these conditions. In this paper we examine a new version of SDI, called SDIe, based on the maximum entropy in a system. We believe our new measure is easier to calculate than the original version of SDI since it is based on data that are more commonly available than those used by SDI; also, SDIe gives a more accurate indication of software stability and maturity since it suffers less from data spikes. To validate the new metric, we use maintenance data from a commercial software project, developed using an agile process; these are the same data that were collected and analyzed in the original SDI study. In addition, we apply the refined SDI metric to the evolution of a well‐established, open‐source, iteratively‐developed software product. The results of our case study indicate our new SDIe metric is a viable measure of system design stability. Copyright © 2006 John Wiley & Sons, Ltd.

Abstract This paper presents a new semantically‐based metric for object‐oriented systems, called the Semantic Class Definition Entropy (SCDE) metric, which examines the implementation domain content of a class to measure class complexity. The domain content is determined using a knowledge‐based program understanding system. The metric's examination of the domain content of a class provides a more direct mapping between the metric and common human complexity analysis than is possible with traditional complexity measures based on syntactic aspects (software aspects related to the format of the code). Additionally, this metric represents a true design metric that can measure complexity early in the life cycles of software maintenance and software development. The SCDE metric is correlated with analyses from a human expert team, and is also compared to syntactic complexity measures. Copyright © 2002 John Wiley & Sons, Ltd.

An automated tool to assist in the understanding of legacy code components can be useful both in the areas of software reuse and software maintenance. Most previous work in this area has concentrated on functionally-oriented code. Whereas object-oriented code has been shown to be inherently more reusable than functionally-oriented code, in many cases the eventual reuse of the object-oriented code was not considered during development. A knowledge-based, natural language processing approach to the automated understanding of object-oriented code as an aid to the reuse of object-oriented code is described. A system, called the PATRicia system (Program Analysis Tool for Reuse) that implements the approach is examined. The natural language processing/information extraction system that comprises a large part of the PATRicia system is discussed and the knowledge-base of the PATRicia system, in the form of conceptual graphs, is described. Reports provided by natural language-generation in the PATRicia system are described.

Software reuse has been demonstrated to increase productivity, reduce costs and improve software quality. Most research in the area of extraction of reusable code from legacy code has concentrated on code created in the functional decomposition paradigm. However, in recent years much object-oriented code has been written. This paper describes a knowledge-based approach to the identification of reusable components in object-oriented legacy code.