![]() ![]() However, developers still do not easily know what the functional features that each cluster expresses are. The previous studies focused on clustering a software unit. Each of these concerns is implemented in a set of classes. ![]() In a large-sized package, there are a number of functional features or concerns. This article also focuses on exploiting linguistic information in the source code to understand functional features of different clusters in large-sized packages. The generated clusters corresponding to different functional features are used to divide a system into different units. ![]() These approaches usually take the whole system as input and generate clusters at some granularity levels, for example, class level or method level. Hence, some studies focused on understanding the functional features of a system and proposed semantic clustering, which exploits linguistic information in the source code, such as identifier names and comments. Then, they can implement source code level changes. A feature or functional point represents a functionality that is defined by requirements and accessible to developers and users. Specifically, they need to know the functional points of a system and where in the source code corresponds to these functional features. But before implementing a change request in the source code, developers should know which part in the source code is related to the change request. These approaches are more suitable in the process of implementing a change request in the source code. Static structural dependencies based approaches usually cluster classes in a system based on static structural dependencies among program elements, such as variable and class references, procedure calls, use of packages, and association and inheritance relationships among classes. There are several approaches that cluster programs based on static structural dependencies in the source code. With such clustering, developers can understand a system more easily. To aid program understanding, classes in these large-sized packages can be clustered into smaller-sized groups. However, for packages with many classes in them, it is more challenging for developers to understand these classes, their relationships, and their functionalities. For small-sized packages (with several classes), it is easy for developers to understand them. Then, interesting packages are selected, and developers further go deep into classes in the packages. Packages are first taken into consideration. For an object oriented Java software system, developers can also understand a system in such a top-down way. In practice, the natural top-down program comprehension process can effectively facilitate developers to understand the system step by step. Moreover, some documents affiliated to the system also become outdated or inaccessible, which makes program comprehension more difficult. As software evolves, its complexity becomes increasingly higher. Developers working on software maintenance tasks spend around 60% of their time for program comprehension. It is a process whereby a software practitioner understands a program using both knowledge of the domain and semantic and syntax knowledge, to build a mental model of the program. Program comprehension is one of the most frequently performed activities in software maintenance. In addition, we find that the topic that labels each cluster is useful for program comprehension. The results show that the effectiveness of our approach is better than Latent Semantic Indexing- (LSI-) and Probabilistic Latent Semantic Analysis- (PLSA-) based clustering approaches. Empirical studies on four real-world software projects demonstrate the effectiveness of our approach. Thus, these large-sized packages are separated as small-sized clusters, which are easier for developers to comprehend. In this article, we focus on understanding these large-sized packages and propose a novel program comprehension approach for large-sized packages, which utilizes the Latent Dirichlet Allocation (LDA) model to cluster large-sized packages. However, for large-sized packages, they are difficult to understand. For small-sized packages in the system, developers can easily comprehend them. The packages in the system are of different sizes. Given a target system for comprehension, developers may first focus on the package comprehension. With the increasing size and complexity of an evolving system, program comprehension becomes an increasingly difficult activity. During software maintenance and evolution, one of the important tasks faced by developers is to understand a system quickly and accurately. ![]()
0 Comments
Leave a Reply. |