Abstract Nesting is a fundamental and very commonly used programming construct. In many cases, the wise use of nesting contributes significantly to a programming team elegantly designing a solution to a difficult problem. However, the ease with which nesting constructs may be created and the essentially unlimited depth and breadth to which they may exist also enable a programming team to create programs that may be extremely difficult to understand and maintain. In this paper, nesting and nesting metrics are examined. The authors begin the nesting examination/discussion with a precise definition of the scope of programme selection nodes. The term ‘nodes’ instead of ‘statements’ is used because this work is done on control flow graphs of programme modules. Although there has been much work done on metrics related to nesting, there has not been significant work done on metrics that focus entirely on nesting. Explicit definitions for nesting depth and nesting breadth metrics are given for programme modules. The metrics are validated by comparing them to probably the best known nesting metric, the MaCabe cyclomatic metric. Also, the metrics are compared to the standard lines of code metric. Further, a new nesting concept, the nesting tree, is discussed and it is proposed that nesting trees themselves could be useful nesting measurement values.

It has been established that there is a strong positive correlation between class cohesion (what we call internal connection-based class cohesion) and class maintainability. Unfortunately, the potential for using internal connection-based class cohesion to predict class maintainability is limited because we cannot measure this class cohesion until the class has been designed and coded. In this paper, we define client-based class cohesion which can be measured in the design phase. Thus, we are able in the design phase to use class cohesion to predict class maintainability. Further, the potential exists that measurements of this client-based class cohesion may in some ways be more useful than measurements of internal connection-based cohesion. This may be true because in addition to involving factors internal to the class in question, external factors, i.e., client classes, are also involved. We conduct an empirical study to investigate the extent to which a client-based class cohesion metric can be used individually and in combination with other internal connection-based class cohesion metrics to predict class maintainability. The results of the study indicate that the client-based class cohesion metric is very promising and may lead to improved results.

Cohesion of a software module broadly refers to the relatedness of the elements of the module. A highly cohesive module has elements that all contribute to a single common purpose. Such modules are believed to be more understandable and maintainable. Most existing object-oriented class cohesion metrics measure the cohesion of a class based on internal connections between the methods of the class where two methods are internally connected if they both reference common attributes in the class. In this paper, we propose a client-based class cohesion metric which we name CCC and which measures the cohesion of a class based on how its public methods are used by its clients. The required information for CCC to calculate the cohesion of a class can be extracted during the high-level design phase from class and communication diagrams defined by the Unified Modeling Language (UML). We validate the proposed metric theoretically, and we empirically demonstrate its usefulness. Theoretically, we analyze the compliance of CCC with the cohesion metric properties. Empirically, we investigate the relations between fourteen class cohesion metrics, including CCC, to determine if CCC captures an aspect of cohesion that is not addressed by the other class cohesion metrics. Moreover, we analyze the extent to which the fourteen class cohesion metrics, including CCC, can individually and in combination predict class testability in terms of testing effort. Our results show that CCC captures an aspect of class cohesion that has not been addressed by the other metrics and that CCC is a predictor for class testability in terms of testing effort.

The purpose of this paper is to make a case for the value of many-valued mathematics, often called fuzzy mathematics. We believe there may be a difference between many-valued mathematics and fuzziness, as used by those who work with fuzzy logic and fuzzy set theory and applications thereof. We think that most, if not all, fuzzy mathematics is many-valued. However, for this paper, the difference between many-valued mathematics and fuzzy mathematics, if a difference exists, is not important. We are, in this paper, content to show that many-valued mathematics can contribute to mathematics. We do understand that for those mathematicians who feel that many-valued mathematics does not have a place in mathematics this paper will not cause them to embrace many-valued mathematics, but we would like them to consider that many-valued mathematics might be able to contribute to mathematics. In this paper, we give an example of a mathematical construction which was created and defined in part to help computer scientists understand and be able to use topological ideas and concepts in their work as computer scientists. Thus, one would think that this construction, called topological systems, would be topological (as defined later). However, it seems that topological systems are clearly not topological. Thus, an interesting question is can topological systems be made topological, or said more mathematically, can topological systems be embedded into something which is topological. We answer this question in the affirmative, and we do it by embedding topological systems into something which is many-valued. It may be the case that someone(s) can some day show that topological systems are topological though this seems unlikely. Or it may be the case that someone(s) can embed topological systems into something which is topological but not many-valued. However, our point is that by using something which is many-valued we have added to mathematics, and thus, we have shown a mathematical use of many-valued mathematics. We should also say that the mathematical results in this paper are not new. We do present some ideas, including the motivation for the “topological” embeddings from topological systems, in new, and we think, illuminating ways, but the mathematical results are not new.

There has been a recent explosion in data as the number of RDF triples increases. With this increase, RDF datasets and their graph relationships become more complex. Accordingly, there is a need to store and handle these huge volumes of triples with highly desired scalability. Therefore, we attempt in this paper to bridge the gaps of the current RDF storage methods in RDBMS by combing the strengths and most sophisticated database physical models with the inferencing techniques that ontology and Formal Concept Analysis (FCA) support. We, thus, aim at analyzing and narrowing the gap between a state-of-the-art method by developing an RDF storage model based on ontologies with the help of FCA clustering solutions for speed and high scalability. Hence, we have proposed a new framework, TripleFCA, to maximize the information retrieval benefits and improve the query response time of RDF triple storages. Our evaluation shows that TripleFCA decreases major bottlenecks of property-table, one of the state-of-the-art RDF storage methods into RDBMS, and yields a much better performance thanks to the benefits of combining ontology and FCA over RDF storage. Our results also demonstrate the weaknesses of property-table and how they can be mitigated.

Many complexity measures have been introduced to capture different aspects of code complexity. A factor that (in most cases) increases the difficulty of code is the excessive use of nesting constructs. In this work, we examine the difficulty created by nesting constructs in object oriented programs. We concentrate on measuring the scope of predicate (selection) statements within a method and between different methods by employing a new model named the control call inheritance graph (CCI). Unlike classic control flow graphs, the CCI graph captures the flow of control between the different statements of a method, between the different statements of different methods, and the flow created by inheritance relationships among different classes.

Quality Function Deployment (QFD) is a well-known concept that has proved its applicability in several domains to enhance quality of designing and manufacturing products while reducing design time and cost. The main idea behind QFD is to listen to customers' requirements and translate these needs into design characteristics. In this paper, we provide an analytical approach of the use of QFD in the domain of Web services. Specifically, we are looking on Web service description which is the main artifact that is used to describe Web service quality characteristics and then retrieve those Web services.

The structured data available in the semantic web have been rapidly increasing with the contribution of linked open data and other similar community initiatives in recent years. Thus, searching and processing large data have become more challenging. Building a summary graph can help reduce the computational complexity and query time in semantic searches by providing an intermediate index structure which contains entity type classes and relations between them. In the current study, we propose an algorithm for discovering the types of entities in RDF data and for building a summary graph structure for faster computational processing.

With the increasing number of Web services, the Semantic Web research community is moving toward enhancing procedures so that clients may effectively discover appropriate Web services that maximally satisfy not only functional but also non-functional requirements. Using purely syntactic approaches to discover Web services has limited efficiency. Therefore, semantic matchmaking registries can play an important role in providing better results. However, most of the semantic registries make decisions based on only functional requirements. Due to the proliferation of Web services that have similar functionality, there is a need to further filter Web services according to Quality of Service (QoS) specifications. This work introduces a rich QoS ontology inspired from the World Wide Web Consortium that defines relationships among QoS attributes. The QoS attributes defined here are mainly used to define network related characteristics. However, the work can be extended by defining QoS ontologies for other domains. Additionally, we extend the test collection OWLS-TC according to the QoS ontology. The extension is intended to integrate quantified values for QoS attributes into Web service descriptions. A matchmaking algorithm based on similarity measurements is presented. Moreover, deterministic and adaptive parameter control techniques are introduced to guide the requester, when needed, to adjust QoS specifications so better similarity can be achieved. Parameter control algorithms integrate Pellet, an OWL reasoner, to reason about dependencies among QoS concepts in the QoS ontology.

Over the last few decades, a lot of research has been done to measure software quality including using high-level design metrics to measure the quality of the design. R. C. Martin's metrics are some of the best-known software package metrics. Martin began with a set of object oriented design principles and designed his metrics based on these principles. In this paper we begin with Martin's principles and use them to modify his instability and abstractness metrics which were defined to identify poorly designed packages which are hard to maintain and reuse. We modify Martin's metrics based on the concept of responsibility, our motivation is that packages with different levels of responsibility should have different weights with respect to the instability and abstraction metrics. We present a case study to validate the modified metrics, the comparative study shows the differences between the proposed metrics and Martin's metrics. We found that the proposed instability and abstractness metrics are very promising and lead to improved results.

Nesting is a fundamental and very commonly used programming construct. In many cases, the wise use of nesting contributes significantly to a programming team's elegantly designing a solution to a difficult problem. However, the ease with which nesting constructs may be created and the essentially unlimited depth and breadth to which they may exist also enable a programming team to create structures which may be extremely difficult to understand and maintain. In this paper, we examine nesting and nesting metrics. In particular, we discuss nesting and complexity, we give a new definition for the scope of a selection statement, we define simple and precise metrics for nesting depth and breadth, and we present a new nesting concept, the nesting tree.

The authors define a software process model (SPM). The SPM is a model of evolution of the full set of documents produced in a software project. It is a general model for software development using any development approach, providing a framework for measuring, analyzing, and understanding the software development process. The authors use the model to characterize formally research in software measures and metrics. Data obtained from two software projects are presented in the SPM format.>

A solution is obtained to the problem of defining a software measure or a family of measures which simultaneously detect those aspects of software complexity that are detected by the software science measures and the cyclomatic number. The authors present a family of measures, called weighted measures that is built on the software science measures by adding weights to certain operators and operands; the size of the weights is determined by a theorem which relates nesting levels and the cyclomatic number. Thus, by construction the weighted measures synthesize the software science measures and the cyclomatic number. Further, by applying the weighted measures, the software science measures, and the cyclomatic number to sample programs, it is shown that the weighted measures also synthesize in practice the software science measures and the cyclomatic number.>