# Patent

## Title
Assessing modularity of a program written in object oriented language

## Abstract

The technique relates to a system and method for assessing modularity of a program written in an object oriented language. This technique involves receiving information related to modularization of the program written in the object oriented language. Then the modularization of the program is assessed by calculating object encapsulation metrics, partial types metrics, extension method metrics, delegates metrics and static variable usage metrics. Further, an assessment report of the modularization is generated with respect to the said metrics.

## Background
FIELD
The field relates generally to assessment of modularity of a program, and in particular, to a system and method for assessing modularity of a program written in object oriented language which supports object encapsulation, partial classes, class extension, delegates and usage of static variables.
BACKGROUND
Software modularization is used to maintain the systems modular as part of software maintenance. There are a few assessment frameworks available for measuring the existing modularity of the systems in C and Java. But, there are a few object oriented programming languages that have more rich features than C and Java. These features include object encapsulation, partial classes, class extension, delegates and usage of static variables. The existing modularity metrics tools measure the structural complexity and code dependencies with respect to standard object oriented features of Java. However, the existing metrics and tools are not adequate for assessing modularity of a program written in a language that supports object encapsulation, partial classes, class extension, delegates and usage of static variables.
SUMMARY
The present technique overcomes the above mentioned limitation by using object encapsulation metrics, partial type metrics, extension method metrics, delegates metrics and static variable usage metrics for assessing modularity of an object oriented language, such as C# language.
According to the present embodiment, a method for assessing modularity of a program written in an object oriented language is disclosed. The method includes receiving information related to modularization of the program written in the object oriented language. Thereafter, the modularization of the program is assessed by calculating object encapsulation metrics, partial types metrics, extension method metrics, delegates metrics and static variable usage metrics. Further, an assessment report of the modularization is generated with respect to the said metrics.
In an additional embodiment, a system for assessing modularity of a program written in an object oriented language is disclosed. The system includes an information receiver, a modularization assessor and a report generator. The information receiver is configured to receive information related to modularization of the program written in the object oriented language. The modularization assessor is configured to assess the modularization of the program by calculating object encapsulation metrics, partial types metrics, extension method metrics, delegates metrics and static variable usage metrics. The report generator is configured to generate an assessment report of the modularization with respect to the said metrics.
In another embodiment, a computer readable storage medium for assessing modularity of a program written in an object oriented language is disclosed. The computer readable storage medium which is not a signal stores computer executable instructions for receiving information related to modularization of the program written in the object oriented language, assessing the modularization of the program by calculating object encapsulation metrics, partial types metrics, extension method metrics, delegates metrics and static variable usage metrics and generating an assessment report of the modularization with respect to the said metrics.



DRAWINGS
Various embodiments of the invention will, hereinafter, be described in conjunction with the appended drawings. There is no intention to limit the scope of the invention to such blocks or objects, or to any particular technology. Instead these simplified diagrams are presented by way of illustration to aid in the understanding of the logical functionality of one or more aspects of the instant disclosure and is not presented by way of limitation.
FIG. 1 is a computer architecture diagram illustrating a computing system capable of implementing the embodiments presented herein.
FIG. 2 is a flowchart, illustrating a method for assessing modularity of a program written in an object oriented language, in accordance with an embodiment of the present invention.
FIG. 3 is a block diagram illustrating a system for assessing modularity of a program written in an object oriented language, in accordance with an embodiment of the present invention.



DETAILED DESCRIPTION
The foregoing has broadly outlined the features and technical advantages of the present disclosure in order that the detailed description of the disclosure that follows may be better understood. Additional features and advantages of the disclosure will be described hereinafter which form the subject of the claims of the disclosure. It should be appreciated by those skilled in the art that the conception and specific embodiment disclosed may be readily utilized as a basis for modifying or designing other structures for carrying out the same purposes of the present disclosure. It should also be realized by those skilled in the art that such equivalent constructions do not depart from the spirit and scope of the disclosure as set forth in the appended claims. The novel features which are believed to be characteristic of the disclosure, both as to its organization and method of operation, together with further objects and advantages will be better understood from the following description when considered in connection with the accompanying figures. It is to be expressly understood, however, that each of the figures is provided for the purpose of illustration and description only and is not intended as a definition of the limits of the present disclosure.
Exemplary embodiments of the present invention provide a system and method for assessing modularity of a program written in an object oriented language. This involves receiving information related to modularization of the program written in the object oriented language. Then the modularization of the program is assessed by calculating object encapsulation metrics, partial types metrics, extension method metrics, delegates metrics and static variable usage metrics. Further, an assessment report of the modularization is generated with respect to the said metrics.
FIG. 1 illustrates a generalized example of a suitable computing environment 100 in which all embodiments, techniques, and technologies of this invention may be implemented. The computing environment 100 is not intended to suggest any limitation as to scope of use or functionality of the technology, as the technology may be implemented in diverse general-purpose or special-purpose computing environments. For example, the disclosed technology may be implemented using a computing device (e.g., a server, desktop, laptop, hand-held device, mobile device, PDA, etc.) comprising a processing unit, memory, and storage storing computer-executable instructions implementing the service level management technologies described herein. The disclosed technology may also be implemented with other computer system configurations, including hand held devices, multiprocessor systems, microprocessor-based or programmable consumer electronics, network PCs, minicomputers, mainframe computers, a collection of client/server systems, and the like.
With reference to FIG. 1, the computing environment 100 includes at least one central processing unit 102 and memory 104. The central processing unit 102 executes computer-executable instructions. In a multi-processing system, multiple processing units execute computer-executable instructions to increase processing power and as such, multiple processors can be running simultaneously. The memory 104 may be volatile memory (e.g., registers, cache, RAM), non-volatile memory (e.g., ROM, EEPROM, flash memory, etc.), or some combination of the two. The memory 104 stores software 116 that can implement the technologies described herein. A computing environment may have additional features. For example, the computing environment 100 includes storage 108, one or more input devices 110, one or more output devices 112, and one or more communication connections 114. An interconnection mechanism (not shown) such as a bus, a controller, or a network, interconnects the components of the computing environment 100. Typically, operating system software (not shown) provides an operating environment for other software executing in the computing environment 100, and coordinates activities of the components of the computing environment 100.
FIG. 2 is a flowchart, illustrating a method for assessing modularity of a program written in an object oriented language, in accordance with an embodiment of the present invention. This technique can be used for any language which supports object encapsulation, partial classes, class extension, delegates and usage of static variables. One of those languages which support the above mentioned features is C# programming language. For the purpose of describing the present technique, C# programming language is taken as an example but the present technique does not limited to C# programming language only. The C# programs are modularized into set of modules, each containing set of files, so that the resulting modularization can be assessed using the Modularity Metrics proposed in this disclosure. The modularization information of the object oriented program (or C# program) is received, as in step 202. Thus, once the modularization details are updated in the system, the metrics calculator fetches the same from the database. The modularization of the object oriented program (or C# program) is assessed by calculating object encapsulation metrics, partial types metrics, extension method metrics, delegates metrics and static variable usage metrics, as in step 204. The metadata of the C# programs are extracted to leverage the same for computation of the metrics. Each metric values between 0 and 1. Any value close to 1 means the specific module is doing fine with respect to the features measured by the metric. The details of determining the metrics are discussed herein below. An assessment report of the modularization is generated with respect to the said metrics, as in step 206. The generated report is static HTML report detailing the modules' metrics and the entities having violation with respect to the metrics.
Modularity Metrics:
The following notations will be used in this disclosure to represent the different metrics: The software system is expressed by S which consists of a set of modules ={p1, . . . , pM} where each p is one system module. The set of all classes in system S will be represented by , whereas C(p) will express the subset of the classes contained in module pε. M will be used to represent the set of all methods or functions within the system. M(c) shall express the set of methods defined in class cε, and extending the notation, M(p) will be used to denote the set of functions defined in module pε. Inversely, Mod(c) will be the module in which class cε resides, while Mod(m) shall be the module in which the function mε M resides. The binary operator denoting whether or not there is a call from within the function m to the function m′ will be called Call (m,m′), while the N Calls (m,m′) will yield the number of calls to m′ from m. Similarly, the existence of a use of m′ as a parameter in a function call, within m, shall be FOC (m,m′). The operator InUse(m) analyzes if a method may be called during program execution (belongs to the execution tree). Pure(m)=1 means m does not use any output methods, or modify variables outside its own scope. ImplicitConv(m,f)counts the amount of times within method m that an implicit conversions takes place, applying an implicit conversion function ƒ.
Object Encapsulation Metrics:
Among the guidelines for the C# design, object encapsulation is a main concern. The use of private protected variables is encouraged, offering access to them only through properties, accessors and setters. Clearly, when accessing information through a getter, there should be no changes to the state, otherwise, an external party using the accessor, without knowledge of how it has been implemented, might use it in an unintended way, modifying the state unintentionally.
This situation is clearly undesirable in a properly modularized program, therefore, a State Mutating Accessor metric is defined to show how many of the explicitly defined accessors modify states. Using the notation Acc(S) to denote all the accessors explicitly defined in the software system and VarNonLocalAssig(m) for the amount of modified variables that do not belong to the private scope of method m, it is defined:




  SMA
  =
  
    1
    -
    
      
        
        
          {
          
            
              m
              ∈
              
                Acc
                ⁡
                
                  (
                  S
                  )
                
              
            
            ❘
            
              
                VarNonLocalAssig
                ⁡
                
                  (
                  m
                  )
                
              
              ≠
              0
            
          
          }
        
        
      
      
        
        
          Acc
          ⁡
          
            (
            S
            )
          
        
        
      
    
  




Partial Types Metrics:

Both when working on a large project, and when making use of automatically generated code, it can be desirable to split a class definition over more than one source files. (Kindly note that this feature is not available in Java.) For this, C# offers the Partial Types. While it may be a useful tool for the development stage, it is important, for a proper modularization of the code, to minimize the amount of types defined across the modules. The language designers already set certain restrictions to the use of this tool, demanding all partial declarations work on the same namespace and are share the assembly. Nevertheless, while being a proper limitation in order to obtain a working program, it may not be enough to ensure properly modularized code, since it would be possible to share the namespace across a big multi module project, and, as long as it uses a single assembly, the programmer can spread partial definitions across the entire project. Clearly, having to look in different modules for parts of a class is not a desirable trait for a modularized program, so an Intermodule Type Definition Index (ITDI) is defined for a given module p, as the ratio between the classes with partial definitions in both p and a different module p′, over the amount of classes defined in p:




  
    ITDI
    ⁡
    
      (
      p
      )
    
  
  =
  
    1
    -
    
      
        
        
          {
          
            
              c
              ∈
              
                M
                ⁡
                
                  (
                  c
                  )
                
              
            
            ❘
            
              
                                ⁢
                
                  Part
                  ⁡
                  
                    (
                    
                      c
                      ,
                      p
                    
                    )
                  
                
              
              ⩓
              
                Part
                ⁡
                
                  (
                  
                    c
                    ,
                    
                      p
                      ′
                    
                  
                  )
                
              
              ⩓
              
                
                  p
                  ′
                
                ≠
                p
              
            
          
          }
        
        
      
      
        
        
          M
          ⁡
          
            (
            c
            )
          
        
        
      
    
  




Here, Part(c,p) will be used to indicate that there is a definition of class c with a partial modifier in module p.
This metric may be extended to entire system by taking an average across all the modules:




  
    ITDI
    ⁡
    
      (
      S
      )
    
  
  =
  
        ⁢
    
      ITDI
      ⁡
      
        (
        p
        )
      
    
  




Extension Method Metrics:

Another tool to improve the language flexibility is the concept of extension methods. These allow a client to extend a class provided by a supplier without having to either modify it or inherit from it, but rather defining his own separate extension methods. This is also the only way to extend a sealed class, which cannot be inherited from. Once again, the problem for modularization comes when the extended methods and the class reside in different modules. To analyze this problem the Intermodule Extension Method Usage (IEMU) is created, which has two different parts. For this formulae Ext(m,c) is used to imply that method m extends class c. First, the proportion of the methods of a module p is considered which extend classes outside p (IEMU1):




  
    
      IEMU
      1
    
    ⁡
    
      (
      p
      )
    
  
  =
  
    1
    -
    
      
        
        
          {
          
            
              m
              ∈
              
                M
                ⁡
                
                  (
                  p
                  )
                
              
            
            ❘
            
              
                
                  ∃
                  
                    c
                    ∈
                    C
                  
                
                ⁢
                
                  Ext
                  ⁡
                  
                    (
                    
                      m
                      ,
                      c
                    
                    )
                  
                
              
              ⩓
              
                
                  Mod
                  ⁡
                  
                    (
                    c
                    )
                  
                
                ≠
                p
              
            
          
          }
        
        
      
      
        
        
          M
          ⁡
          
            (
            p
            )
          
        
        
      
    
  




Secondly, the ratio between the classes in package p is considered that are extended by external methods over the total amount of classes in p (IEMU2):




  
    
      IEMU
      2
    
    ⁡
    
      (
      p
      )
    
  
  =
  
    1
    -
    
      
        
        
          {
          
            
              c
              ∈
              
                C
                ⁡
                
                  (
                  p
                  )
                
              
            
            ❘
            
              
                
                  ∃
                  
                    m
                    ∈
                    M
                  
                
                ⁢
                
                  Ext
                  ⁡
                  
                    (
                    
                      m
                      ,
                      c
                    
                    )
                  
                
              
              ⩓
              
                
                  Mod
                  ⁡
                  
                    (
                    m
                    )
                  
                
                ≠
                p
              
            
          
          }
        
        
      
      
        
        
          C
          ⁡
          
            (
            p
            )
          
        
        
      
    
  




Finally, the IEMU metric is obtained for module p as the minimum between the two:

IEMU(p)=min{IEMU1,IEMU2}

To generalize to the entire system the average of it is determined over all modules:




  
    IEMU
    ⁡
    
      (
      S
      )
    
  
  =
  
        ⁢
    
      IEMU
      ⁡
      
        (
        p
        )
      
    
  




Delegates:

In a similar fashion to the function pointers used in C++, C# offers a system to pass a function as a parameter, which is much more type safe and less likely to produce run time type errors. This tool is the Delegate.
A Delegate type is declared as the prototype of a function, meaning which parameters it receives and what it returns. A function can receive, as a parameter, a previously delegate type. If so, when the function is called the name of a function that complies with the delegate declaration can be passed as the parameter, which creates an immutable delegate “pointing” to this function. Within the calling function, every time the delegate is used, the function linked to it is called. To add multicast functionality, a single delegate can be linked to multiple methods, calling them in chain whenever it is summoned.
This is useful both for functional programming first order functions, but also for improving modularization. It is much clearer and easier to modify a module that assigns external methods to delegates and then does all the internal work with those delegates than one which directly calls on the external methods all though out the code. The delegate, here, would act as a decoupling mechanism between the module providing the called function and the one using it, much in the same way published APIs and Interfaces do. Therefore, a metric is proposed to measure the extent to which this tool is used to channel the intermodule traffic, called Delegate Usage Index (DUI). It will be defined as the ratio between the times an external function is called through a delegate associated to it and all calls to external functions, both direct and through delegates. Notably, since delegates can be dynamically assigned, a call to a delegate might result, at runtime, in a call to an internal or an external function, but, since exclusively static code analysis is done, the “external call” is considered the use of a delegate with the potential of pointing to an external function.




  
    DUI
    ⁡
    
      (
      p
      )
    
  
  =
  
    
      
        ∑
        
          
            m
            j
          
          ∈
          
            M
            ⁡
            
              (
              p
              )
            
          
        
      
      ⁢
      
        
      
      ⁢
      
        
          ∑
          
            
              f
              k
            
            ∈
            
              {
              
                M
                -
                
                  M
                  ⁡
                  
                    (
                    p
                    )
                  
                
              
              }
            
          
        
        ⁢
        
          
            N
            ⁢
            Calls
          
          ⁡
          
            (
            
              
                m
                j
              
              ,
              
                Del
                ⁡
                
                  (
                  
                    f
                    k
                  
                  )
                
              
            
            )
          
        
      
    
    
      
        ∑
        
          
            m
            j
          
          ∈
          
            M
            ⁡
            
              (
              p
              )
            
          
        
      
      ⁢
      
        
      
      ⁢
      
        
          ∑
          
            
              f
              k
            
            ∈
            
              {
              
                M
                -
                
                  M
                  ⁡
                  
                    (
                    p
                    )
                  
                
              
              }
            
          
        
        ⁢
        
          (
          
            
              N
              ⁢
              
                
              
              ⁢
              
                Calls
                ⁡
                
                  (
                  
                    
                      m
                      j
                    
                    ,
                    
                      Del
                      ⁡
                      
                        (
                        
                          f
                          k
                        
                        )
                      
                    
                  
                  )
                
              
            
            +
            
              N
              ⁢
              
                
              
              ⁢
              
                Calls
                ⁡
                
                  (
                  
                    
                      m
                      j
                    
                    ,
                    
                      f
                      k
                    
                  
                  )
                
              
            
          
          )
        
      
    
  




Here, Del(f) refers to a delegate which may be assigned to method f, during the program execution.
The index can be extended to review the usage of delegates as decoupling mechanisms throughout the system by:




  
    DUI
    ⁡
    
      (
      S
      )
    
  
  =
  
        ⁢
    
      DUI
      ⁡
      
        (
        p
        )
      
    
  




Static Variable Usage:

C#, like Java, provides static variables for maintaining information at the class level, along with the class definition which provides variables for defining the state of the objects of the class. Static variables are supposed to be used to share information at the class level, but it can be used by other classes based on the scope defined for those static variables. Problems arise when the classes from different modules start accessing the Static variables of one module. This metric measures the same by defining two metrics, average of them will be the final value of the IMSVU metric—Inter Module Static Variables Usage metric.
Metric one M1(p) is defined as the ratio between the count of static variables of other modules accessed by module p and the count of all static variables accessed by module p.
Metric two M2(p) is defined as the ratio between the count of static variables of this module p accessed by other modules and the count of static variables defined in module p.

IMSVU(p)=(M1+M2)/2.

This can be augmented by having weighted approach based on the nature of the project, where in, two weights w1, w2 are defined whose sum will be one.

IMSVU(enhanced)(p)=w1*M1+w2*M2;

The IMSVU for the entire system would be the average of the module level values.




  
    IMSVU
    ⁡
    
      (
      S
      )
    
  
  =
  
        ⁢
    
      IMSVU
      ⁡
      
        (
        p
        )
      
    
  




FIG. 3 is a block diagram illustrating a system for assessing modularity of a program written in an object oriented language, in accordance with an embodiment of the present invention. The system includes an information receiver 302, a modularization assessor 304, a metadata extractor 306 and a report generator 308. The information receiver 302 is configured to receive information related to modularization of the program written in the object oriented language. The modularization assessor 306 is configured to assess the modularization of the program by calculating object encapsulation metrics, partial types metrics, extension method metrics, delegates metrics and static variable usage metrics. The metadata extractor 306 is configured to extract metadata of the program to calculate the said metrics. Each metric values between 0 and 1. Any value close to 1 means the specific module is doing fine with respect to the features measured by the metric. The details of determining the metrics are discussed herein above with reference to FIG. 2. The report generator 308 is configured to generate an assessment report of the modularization with respect to the said metrics. The generated report is static HTML report detailing the modules' metrics and the entities having violation with respect to the metrics.
The above mentioned description is presented to enable a person of ordinary skill in the art to make and use the invention and is provided in the context of the requirement for obtaining a patent. Various modifications to the preferred embodiment will be readily apparent to those skilled in the art and the generic principles of the present invention may be applied to other embodiments, and some features of the present invention may be used without the corresponding use of other features. Accordingly, the present invention is not intended to be limited to the embodiment shown but is to be accorded the widest scope consistent with the principles and features described herein.

## Claims

1. A computer implemented method for assessing modularity of a program written in an object oriented language, comprising:
receiving, by a processor, information related to modularization of the program written in the object oriented language;
extracting, by the processor, metadata of the program;
assessing, by the processor, using the extracted metadata, the modularization of the program by calculating object encapsulation metrics, extension method metrics comprising one or more metrics that measure the extent to which extension methods, that extend classes without modifying the classes and without inheriting from the classes, and the classes extended by the extension methods are defined in different modules, and static variable usage metrics, wherein each of the said metrics range between poor modularization and optimal modularization, wherein calculating at least one of the extension method metrics comprises:
determining a first ratio between:
a number of methods, defined in a module, that extend one or more classes that are not defined in the module, and
a total number of methods defined in the module;

determining a second ratio between:
a number of classes, defined in the module, that are extended by one or more methods that are not defined in the module, and
a total number of classes defined in the module; and

selecting the smallest of the first and second ratios as an extension method metric for the module; and

generating, by the processor, an assessment report of the modularization with respect to the said metrics.

2. The method as claimed in claim 1, wherein the program comprises a plurality of modules and at least one of the plurality of modules comprises one or more classes.

3. The method as claimed in claim 1, wherein each of the said metrics has a value between 0 and 1, wherein a value of 0 denotes poor modularization and a value of 1 denotes optimal modularization.

4. The method as claimed in claim 1, wherein the report is generated in HTML form.

5. The method as claimed in claim 1, wherein the report comprises the object encapsulation metrics, extension method metrics, and static variable usage metrics of at least one module of the program and one or more entities having violation with respect to the said metrics.

6. The method as claimed in claim 1, wherein:
an absence of extension methods results in an extension method metric value of optimal modularization.

7. The method as claimed in claim 1, wherein the assessing further comprises calculating delegates metrics that range between poor modularization and optimal modularization.

8. The method as claimed in claim 7, wherein the delegates metrics comprises one or more metrics that measure a ratio between:
a number of calls made in a module to external functions via one or more delegates, and
a total number of calls made in a module to external functions.

9. A system for assessing modularity of a program written in an object oriented language comprising:
a processor in operable communication with a processor readable storage medium, the processor readable storage medium containing one or more programming instructions whereby the processor is configured to implement:
an information receiver, wherein the information receiver receives information related to modularization of the program written in the object oriented language;
a metadata extractor, wherein the metadata extractor extracts metadata of the program;
a modularization assessor, wherein the modularization assessor, using the extracted metadata of the program, assesses the modularization of the program by calculating object encapsulation metrics, extension method metrics, and static variable usage metrics, wherein the metrics range between poor and optimal modularization, wherein calculating at least one of the extension method metric comprises:
determining a first ratio between:
a number of methods, defined in a module, that extend one or more classes that are not defined in the module, and
a total number of methods defined in the module;

determining a second ratio between:
a number of classes, defined in the module, that are extended by one or more methods that are not defined in the module, and
a total number of classes defined in the module; and

selecting the smallest of the first and second ratios as an extension method metric for the module; and

a report generator, wherein the report generator generates an assessment report of the modularization with respect to the said metrics, wherein the assessment report indicates at least one modularization violation that comprises a non-optimal extension method metric value which indicates that at least one extension method, which extends a class without modifying the class and without inheriting from the class, is defined in a different module than the class extended by the extension method.

10. The system as claimed in claim 9, wherein the program comprises a plurality of modules and at least one of the plurality of modules comprises one or more classes.

11. The system as claimed in claim 9, wherein each of the said metrics has a value between 0 and 1, wherein a value of 1 denotes optimal modularization.

12. The system as claimed in claim 9, wherein the report is generated in HTML form.

13. The system as claimed in claim 9, wherein the report comprises the object encapsulation metrics, extension method metrics, and static variable usage metrics of at least one module of the program and one or more entities having the modularization violation with respect to the said metrics.

14. A non-transitory computer readable medium having stored thereon instructions for assessing modularity of a program written in an object oriented language, comprising machine executable code which when executed by at least one processor, causes the at least one processor to perform steps comprising:
receiving information related to modularization of the program written in the object oriented language;
extracting metadata of the program;
assessing, using the extracted metadata, the modularization of the program by calculating object encapsulation metrics, partial types metrics, extension method metrics comprising one or more metrics that measure the extent to which one or more extension methods, that extend one or more classes without modifying the one or more classes and without inheriting from the one or more classes, and the one or more classes extended by the one or more extension methods are defined in different modules, delegates metrics, and static variable usage metrics, further wherein calculating at least one of the extension method metrics comprises:
determining a first ratio between:
a number of classes, defined in a module, that are extended by one or more extension methods that are not defined in the module, and
a total number of classes defined in the module;

determining a second ratio between:
a number of methods, defined in the module, that extend one or more classes that are not defined in the module, and
a total number of methods defined in the module; and

selecting the smallest of the first and second ratios as an extension method metric for the module; and

generating an assessment report of the modularization with respect to the said metrics, wherein the assessment report indicates that at least one class is extended by at least one extension method defined in a different module than the at least one class.

15. The non-transitory computer readable medium as claimed in claim 14, wherein the program comprises a plurality of modules and at least one of the plurality of modules comprises one or more classes.

16. The non-transitory computer readable medium as claimed in claim 14, wherein the report comprises the object encapsulation metrics, partial types metrics, extension method metrics, delegates metrics, and static variable usage metrics of at least one module of the program and one or more entities having violation with respect to the said metrics.