“There probably isn’t a ‘best ’ way to build the system, or even any major part of it; much more important is to avoid choosing a terrible way, and to have clear division of responsibilities among the parts. ” – Butler Lampson [33] Operating system code is complex. But, while substantial complexity is inherent to this domain, some complexity is caused by modularity problems. The goal of the work proposed here is to explore aspectoriented programming as a means of making this kind of complexity unnecessary. Towards this end, we need to identify aspects of the system, use the proposed mechanisms of AOP to modularize them, and establish the impact this approach has on the code. 1

Abstract not found

Evolving and maintaining software requires adequate documentation of its implementation. However, due to the software's constant evolution, the documentation and implementation do not remain synchronised. Intentional software views have been proposed as a documentation technique to alleviate this problem. Creating such views is not at all a trivial task, however. In this paper, we propose to use a learning algorithm that derives such intentional software views from extensional software views, which are much easier to build. The resulting approach combines the advantages of intentional software views with the ease of constructing extensional views.

Program comprehension is often regarded as a learning process where programmers actively acquire knowledge from various software artifacts to construct well formed, representative mental models of existing software systems. In this research, we introduce a novel ontology-based program comprehension model that addresses both the challenge of knowledge acquisition and the construction of mental models. Our approach provides ontological support for program comprehension by: 1) representing various software artifacts, including source code and documents as formal ontologies; 2) utilizing ontological reasoning services to allow programmers not only to reason about properties of the software systems, but also to actively acquire and construct new concepts based on their current understanding; and 3) introducing an ontology-based comprehension model and a supporting comprehension methodology that characterize program comprehension as an iterative process of concept recognition and relationship discovery. The research presented in this thesis is significant for several reasons. Firstly, we describe program comprehension as a process of mental ontology construction, which is

Abstract — During maintenance developers cannot read the entire code of large systems. They need a way to get a quick understanding of source code entities (such as, classes, methods, packages, etc.), so they can efficiently identify and then focus on the ones related to their task at hand. Sometimes reading just a method header or a class name does not tell enough about its purpose and meaning, while reading the entire implementation takes too long. We study a solution which mitigates the two approaches, i.e., short and accurate textual descriptions that illustrate the software entities without having to read the details of the implementation. We create such descriptions using techniques from automatic text summarization. The paper presents a study that investigates the suitability of various such techniques for generating source code summaries. The results indicate that a combination of text summarization techniques is most appropriate for source code summarization and that developers generally agree with the summaries produced. Keywords-text summarization, program comprehension I.