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.

An eye-tracking study of 18 developers reading and summarizing Java methods is presented. The developers provide a written summary for methods assigned to them. In total, 63 methods are used from five different systems. Previous studies on this topic use only short methods presented in isolation usually as images. In contrast, this work presents the study in the Eclipse IDE allowing access to all the source code in the system. The developer can navigate via scrolling and switching files while writing the summary. New eye-tracking infrastructure allows for this improvement in the study environment. Data collected includes eye gazes on source code, written summaries, and time to complete each summary. Unlike prior work that concluded developers focus on the signature the most, these results indicate that they tend to focus on the method body more than the signature. Moreover, both experts and novices tend to revisit control flow terms rather than reading them for a long period. They also spend a significant amount of gaze time and have higher gaze visits when they read call terms. Experts tend to revisit the body of the method significantly more frequently than its signature as the size of the method increases. Moreover, experts tend to write their summaries from source code lines that they read the most.

δ-Hyperbolicity is a graph parameter that shows how close to a tree a graph is metrically. In this work, we propose a method that reduces the size of the graph to only a subset that is responsible for maximizing its δ-hyperbolicity using the local dominance relationship between vertices. Furthermore, we empirically show that the hyperbolicity of a graph can be found in a set of vertices that are in close proximity. That is, the hyperbolicity in graphs is, to some extent, a local property. Moreover, we show that this set is close to the graph's center. Our observations have crucial implications on computing the value of the δ-hyperbolicity of graphs.

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.

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.