scholarly journals Integration of Ontology and UML Class-Based Modelling for Knowledge Representation

2018 ◽  
Vol 2 (1) ◽  
pp. 10-15
Author(s):  
Rozita Kadar ◽  
Sharifah Mashita Syed-Mohamad ◽  
Putra Sumari ◽  
Nur 'Aini Abdul Rashid
Keyword(s):  
Knowledge Representation ◽  
Software Maintenance ◽  
Source Code ◽  
Program Comprehension ◽  
Software Systems ◽  
Software System ◽  
Source Codes ◽  
Comprehension Process ◽  
Relationship Of ◽  
Maintenance Process

Program comprehension is an important process carried out involving much effort in software maintenance process. A key challenge to developers in program comprehension process is to comprehend a source code. Nowadays, software systems have grown in size ca using increase in developers' tasks to explore and understand millions of lines of source code. Meanwhile, source code is a crucial resource for developers to become familiar with a software system since some system documentations are often unavailable or outdated. However, there are problems exist in understanding source codes, which are tricky with different programming styles, and insufficient comments. Although many researchers have discussed different strategies and techniques to overcome program compr ehension problem, only a shallow knowledge is obtained about the challenges in trying to understand a software system through reading source code. Therefore, this study attempts to overcome the problems in source code comprehension by suggesting a suitable comprehension technique. The proposed technique is based on using ontology approach for knowledge representation. This approach is able to easily explain the concept and relationship of program domain. Thus, the proposed work will create a better way for improving program comprehension.

scholarly journals Survey on Ontology-Based Visualization Techniques towards Program Comprehension Application

2018 ◽  
Vol 3 (1) ◽  
pp. 19-29
Author(s):  
Rozita Kadar ◽  
Jamal Othman ◽  
Naemah Abdul Wahab
Keyword(s):  
Literature Review ◽  
Knowledge Representation ◽  
Software Maintenance ◽  
Source Code ◽  
Program Comprehension ◽  
Software System ◽  
Visualization Techniques ◽  
Use Of Knowledge

A key challenge to software maintainers during performing the software maintenance is to comprehend a source code. Source code plays an important role in aiding software maintainers to get conversant with a software system since some system documentations are often unavailable or outdated. Although there are many researches that have discussed the different strategies and techniques to overcome the program comprehension problem, there exists only a shallow knowledge about the challenges software maintainers face when trying to understand a software system through reading source code. In order to make source code more comprehensible, it needs to make an enhancement regarding to the source code presentation by transforming it into a different view. From the literature review, we found that there are lacks of study that consider the use of knowledge representation to represent source code. Hence, the aim of this work is to review the existing techniques for source code representation based on knowledge representation that could help developers to reduce the amount of their effort needed to understand a source code.

Non-Intrusive Adaptation of System Execution Traces for Performance Analysis of Software Systems

2014 ◽  
pp. 473-493
Author(s):  
Manjula Peiris ◽  
James H. Hill
Keyword(s):  
Performance Analysis ◽  
System Performance ◽  
Source Code ◽  
Software Systems ◽  
Software System ◽  
Original Source ◽  
Performance Properties ◽  
Execution Traces ◽  
Execution Trace ◽  
Analysis Of Performance

This chapter discusses how to adapt system execution traces to support analysis of software system performance properties, such as end-to-end response time, throughput, and service time. This is important because system execution traces contain complete snapshots of a systems execution—making them useful artifacts for analyzing software system performance properties. Unfortunately, if system execution traces do not contain the required properties, then analysis of performance properties is hard. In this chapter, the authors discuss: (1) what properties are required to analysis performance properties in a system execution trace; (2) different approaches for injecting the required properties into a system execution trace to support performance analysis; and (3) show, by example, the solution for one approach that does not require modifying the original source code of the system that produced the system execution.

Code Comment Quality Analysis and Improvement Recommendation: An Automated Approach

2016 ◽  
Vol 26 (06) ◽  
pp. 981-1000 ◽  
Author(s):  
Xiaobing Sun ◽  
Qiang Geng ◽  
David Lo ◽  
Yucong Duan ◽  
Xiangyue Liu ◽  
...  
Keyword(s):  
Software Maintenance ◽  
User Study ◽  
Program Comprehension ◽  
Quality Analysis ◽  
Software Systems ◽  
Sources Of Information ◽  
Software Maintenance And Evolution ◽  
Study Participants ◽  
Quality Assessments

Program comprehension is one of the first and most frequently performed activities during software maintenance and evolution. In a program, there are not only source code, but also comments. Comments in a program is one of the main sources of information for program comprehension. If a program has good comments, it will be easier for developers to understand it. Unfortunately, for many software systems, due to developers’ poor coding style or hectic work schedule, it is often the case that a number of methods and classes are not written with good comments. This can make it difficult for developers to understand the methods and classes, when they are performing future software maintenance tasks. To deal with this problem, in this paper we propose an approach which assesses the quality of a code comment and generates suggestions to improve comment quality. A user study is conducted to assess the effectiveness of our approach and the results show that our comment quality assessments are similar to the assessments made by our user study participants, the suggestions provided by our approach are useful to improve comment quality, and our approach can improve the accuracy of the previous comment quality analysis approaches.

Tracing Links Between Business Processes and Software Systems

2013 ◽  
Vol 5 (2) ◽  
pp. 46-64 ◽  
Author(s):  
Lerina Aversano ◽  
Maria Tortorella
Keyword(s):  
Information Retrieval ◽  
Business Process ◽  
Software Maintenance ◽  
Business Processes ◽  
Semantic Analysis ◽  
Process Models ◽  
Software Systems ◽  
Software System ◽  
Business Process Models

The traceability links existing between a business process and the supporting software systems s is a critical concern for the organizations, as it directly affects their performance. Methodologies and tools are needed for detecting these kinds of relationships and keeping an evidence of the existing connections. This paper proposes an approach for modelling a business processes evidencing the links existing between their activities and the components of the supporting software systems. The approach described in this paper is concerned with the use of information retrieval techniques to software maintenance and, in particular, to the problem of recovering traceability links between the business process models and the components of the supporting software system. An information retrieval approach is introduced based on two processing phases including syntactic and semantic analysis. The application of the approach is explored through a case study.

Formal Methods for Specifying and Analyzing Complex Software Systems

2010 ◽  
pp. 243-264
Author(s):  
Xudong He ◽  
Huiqun Yu ◽  
Yi Deng
Keyword(s):  
Formal Methods ◽  
Architectural Design ◽  
Source Code ◽  
Modern Society ◽  
Past Research ◽  
Software Systems ◽  
Grand Challenge ◽  
Software System ◽  
Research Experience ◽  
System Specification

Software has been a major enabling technology for advancing modern society, and is now an indispensable part of daily life. Because of the increased complexity of these software systems, and their critical societal role, more effective software development and analysis technologies are needed. How to develop and ensure the dependability of these complex software systems is a grand challenge. It is well known that a highly dependable complex software system cannot be developed without a rigorous development process and a precise specification and design documentation. Formal methods are one of the most promising technologies for precisely specifying, modeling, and analyzing complex software systems. Although past research experience and practice in computer science have convincingly shown that it is not possible to formally verify program behavior and properties at the program source code level due to its extreme huge size and complexity, recently advances in applying formal methods during software specification and design, especially at software architecture level, have demonstrated significant benefits of using formal methods. In this chapter, we will review several well-known formal methods for software system specification and analysis. We will present recent advances of using these formal methods for specifying, modeling, and analyzing software architectural design.

Handling of Software Quality Defects in Agile Software Development

2011 ◽  
pp. 90-113 ◽  
Author(s):  
J. Rech
Keyword(s):  
Software Development ◽  
Software Quality ◽  
Software Maintenance ◽  
Agile Software Development ◽  
Agile Development ◽  
Software Systems ◽  
Software System ◽  
History Of ◽  
Effective Development ◽  
Agile Software

Software quality assurance is concerned with the efficient and effective development of large, reliable, and high-quality software systems. In agile software development and maintenance, refactoring is an important phase for the continuous improvement of a software system by removing quality defects like code smells. As time is a crucial factor in agile development, not all quality defects can be removed in one refactoring phase (especially in one iteration). Documentation of quality defects that are found during automated or manual discovery activities (e.g., pair programming) is necessary to avoid wasting time by rediscovering them in later phases. Unfortunately, the documentation and handling of existing quality defects and refactoring activities is a common problem in software maintenance. To recall the rationales why changes were carried out, information has to be extracted from either proprietary documentations or software versioning systems. In this chapter, we describe a process for the recurring and sustainable discovery, handling, and treatment of quality defects in software systems. An annotation language is presented that is used to store information about quality defects found in source code and that represents the defect and treatment history of a part of a software system. The process and annotation language can not only be used to support quality defect discovery processes, but is also applicable in testing and inspection processes.

scholarly journals Rule Based Event Log Generation Technique using Reverse Engineering

2019 ◽  
Vol 8 (9S3) ◽  
pp. 1176-1179
Keyword(s):  
Software Maintenance ◽  
Fault Injection ◽  
Source Code ◽  
Maintenance Cost ◽  
Software Systems ◽  
Primary Input ◽  
Rule Based ◽  
Generation Technique ◽  
Rule Based Approach ◽  
Injection Experiment

In many software systems logging has been implemented inaccurately, their effectiveness during the maintenance period to identify the failures and address them quickly is very less. This in turn increases the software maintenance cost and reduces reliability of the system as many errors are unreported. This paper aims at proposing and studying a rule based approach to make the logs more effective. The source code of the target systems gets reverse engineered and acts as the primary input for this approach to introduce the automated logs into the source code. This is instrumented by a logger code driven by a set of predefined rules which are woven around the life cycle of the system entities. The validity of the approach is verified by means of a preliminary fault injection experiment into a real world system.

A REVIEW OF DESIGN PATTERN MINING TECHNIQUES

2009 ◽  
Vol 19 (06) ◽  
pp. 823-855 ◽  
Author(s):  
JING DONG ◽  
YAJING ZHAO ◽  
TU PENG
Keyword(s):  
Design Patterns ◽  
Architectural Design ◽  
Pattern Mining ◽  
Source Code ◽  
Software Systems ◽  
Software System ◽  
Original Design ◽  
Trace Back ◽  
Mining Design

The quality of a software system highly depends on its architectural design. High quality software systems typically apply expert design experience which has been captured as design patterns. As demonstrated solutions to recurring problems, design patterns help to reuse expert experience in software system design. They have been extensively applied in the industry. Mining the instances of design patterns from the source code of software systems can assist in the understanding of the systems and the process of re-engineering them. More importantly, it also helps to trace back to the original design decisions, which are typically missing in legacy systems. This paper presents a review on current techniques and tools for mining design patterns from source code or design of software systems. We classify different approaches and analyze their results in a comparative study. We also examine the disparity of the discovery results of different approaches and analyze possible reasons with some insight.

Handling of Software Quality Defects in Agile Software Development

2009 ◽  
pp. 242-265
Author(s):  
Jörg Rech
Keyword(s):  
Software Development ◽  
Software Quality ◽  
Software Maintenance ◽  
Agile Software Development ◽  
Agile Development ◽  
Software Systems ◽  
Software System ◽  
History Of ◽  
Effective Development ◽  
Agile Software

Software quality assurance is concerned with the efficient and effective development of large, reliable, and high-quality software systems. In agile software development and maintenance, refactoring is an important phase for the continuous improvement of a software system by removing quality defects like code smells. As time is a crucial factor in agile development, not all quality defects can be removed in one refactoring phase (especially in one iteration). Documentation of quality defects that are found during automated or manual discovery activities (e.g., pair programming) is necessary to avoid wasting time by rediscovering them in later phases. Unfortunately, the documentation and handling of existing quality defects and refactoring activities is a common problem in software maintenance. To recall the rationales why changes were carried out, information has to be extracted from either proprietary documentations or software versioning systems. In this chapter, we describe a process for the recurring and sustainable discovery, handling, and treatment of quality defects in software systems. An annotation language is presented that is used to store information about quality defects found in source code and that represents the defect and treatment history of a part of a software system. The process and annotation language can not only be used to support quality defect discovery processes, but is also applicable in testing and inspection processes.

scholarly journals A New Metaheuristic-Based Hierarchical Clustering Algorithm for Software Modularization

Complexity ◽  
2020 ◽  
Vol 2020 ◽  
pp. 1-25
Author(s):  
Masoud Aghdasifam ◽  
Habib Izadkhah ◽  
Ayaz Isazadeh
Keyword(s):  
Hierarchical Clustering ◽  
Software Maintenance ◽  
Clustering Algorithm ◽  
Source Code ◽  
Internal Quality ◽  
Software Systems ◽  
Software Module ◽  
Clustering Problem ◽  
Software Refactoring ◽  
Code Structure

Software refactoring is a software maintenance action to improve the software internal quality without changing its external behavior. During the maintenance process, structural refactoring is performed by remodularizing the source code. Software clustering is a modularization technique to remodularize artifacts of source code aiming to improve readability and reusability. Due to the NP hardness of the clustering problem, evolutionary approaches such as the genetic algorithm have been used to solve this problem. In the structural refactoring literature, there exists no search-based algorithm that employs a hierarchical approach for modularization. Utilizing global and local search strategies, in this paper, a new search-based top-down hierarchical clustering approach, named TDHC, is proposed that can be used to modularize the system. The output of the algorithm is a tree in which each node is an artifact composed of all artifacts in its subtrees and is a candidate to be a software module (i.e., cluster). This tree helps a software maintainer to have better vision on source code structure to decide appropriate composition points of artifacts aiming to create modules (i.e., files, packages, and components). Experimental results on seven folders of Mozilla Firefox with different functionalities and five other software systems show that the TDHC produces modularization closer to the human expert’s decomposition (i.e., directory structure) than the other existing algorithms. The proposed algorithm is expected to help a software maintainer for better remodularization of a source code. The source codes and dataset related to this paper can be accessed at https://github.com/SoftwareMaintenanceLab.

Sign in / Sign up

Export Citation Format

Share Document