A Context-based Information Retrieval Technique for Recovering Use-Case-to-Source-Code Trace Links in Embedded Software Systems

2013 ◽  
Author(s):  
Jiale Zhou ◽  
Yue Lu ◽  
Kristina Lundqvist
Keyword(s):  
Information Retrieval ◽  
Source Code ◽  
Embedded Software ◽  
Software Systems ◽  
Use Case ◽  
Retrieval Technique

scholarly journals Formation of a knowledge base to support the process of architectural design of software systems

2021 ◽  
Vol 11 (2) ◽  
pp. 154-169
Author(s):  
G.Y. Guskov ◽  
◽  
A.M. Namestnikov ◽  
A.A. Romanov ◽  
A.A. Filippov
Keyword(s):  
Knowledge Base ◽  
Architectural Design ◽  
Source Code ◽  
Data Models ◽  
Software Systems ◽  
Use Case ◽  
Design Organization ◽  
Average Value ◽  
Frag Ments

This article describes an approach to knowledge base (KB) formation for automating the process of architectural de-sign of software systems (SS) based on the experience of previous projects. Software architecting is the presentation of software systems in the form of design artifacts and their architecture. When developing a new SS it is possible to im-prove its quality based on the experience of previous projects. The experience of previous projects is successful archi-tectural solutions contained in the knowledge base of the design organization. Such a KB should be formed in the pro-cess of analyzing design artifacts extracted from previous projects: source code, project diagrams, data models, struc-tured text resources, etc. This article describes a KB model of a design organization and a model of the 1C: Enterprise 8 (1C) application solution as an example of a design artifact. The article also presents a method for generating frag-ments of a KB in the process of analyzing an applied solution for the 1C application and a method for generating use-case diagrams based on the KB content. A set of experiments was executed to evaluate the adequacy of the proposed models and methods. The results of experiments for assessing quality in terms of accuracy (the presence of elements of the expert diagram in the generated diagram) and completeness (the presence of elements in the generated diagram that are absent in the expert diagram) are presented. According to the results of the experiments, the average value of accuracy is 0.875, and the completeness is 0.6.

Morphology, Processing, and Integrating of Information from Large Source Code Warehouses for Decision Support

2011 ◽  
pp. 122-152
Author(s):  
Jörg Rech
Keyword(s):  
Decision Making ◽  
Information Retrieval ◽  
Knowledge Discovery ◽  
Programming Languages ◽  
Source Code ◽  
Object Oriented ◽  
Software Systems ◽  
Test Cases ◽  
Different Sources ◽  
Support Decision Making

Source code occurs in diverse programming languages with documentation using miscellaneous standards, comments in individual styles, extracted metrics or associated test cases that are hard to exploit through information retrieval or knowledge-discovery techniques. Typically, the information about object-oriented source code for a software system is distributed across several different sources, which makes processing complex. In this chapter we describe the morphology of object-oriented source code and how we (pre-) process, integrate and use it for knowledge discovery in software engineering in order to support decision-making regarding the refactoring, reengineering and reuse of software systems.

scholarly journals RECOVERY OF TRACEABILITY LINKS BETWEEN SOFTWARE DOCUMENTATION AND SOURCE CODE

2005 ◽  
Vol 15 (05) ◽  
pp. 811-836 ◽  
Author(s):  
ANDRIAN MARCUS ◽  
JONATHAN I. MALETIC ◽  
ANDREY SERGEYEV
Keyword(s):  
Information Retrieval ◽  
Case Studies ◽  
Semantic Information ◽  
Source Code ◽  
Latent Semantic Indexing ◽  
Automatic Process ◽  
Semantic Indexing ◽  
Software Documentation ◽  
Retrieval Technique ◽  
Positive Results

An approach for the semi-automated recovery of traceability links between software documentation and source code is presented. The methodology is based on the application of information retrieval techniques to extract and analyze the semantic information from the source code and associated documentation. A semi-automatic process is defined based on the proposed methodology. The paper advocates the use of latent semantic indexing (LSI) as the supporting information retrieval technique. Two case studies using existing software are presented comparing this approach with others. The case studies show positive results for the proposed approach, especially considering the flexibility of the methods used.

scholarly journals Using Actors and Use Cases for Software Size Estimation

Electronics ◽  
2021 ◽  
Vol 10 (5) ◽  
pp. 592
Author(s):  
Radek Silhavy ◽  
Petr Silhavy ◽  
Zdenka Prokopova
Keyword(s):  
Project Planning ◽  
Use Cases ◽  
New Method ◽  
Software Systems ◽  
Software Project ◽  
Use Case ◽  
Size Estimation ◽  
Software Size Estimation ◽  
Use Case Points

Software size estimation represents a complex task, which is based on data analysis or on an algorithmic estimation approach. Software size estimation is a nontrivial task, which is important for software project planning and management. In this paper, a new method called Actors and Use Cases Size Estimation is proposed. The new method is based on the number of actors and use cases only. The method is based on stepwise regression and led to a very significant reduction in errors when estimating the size of software systems compared to Use Case Points-based methods. The proposed method is independent of Use Case Points, which allows the elimination of the effect of the inaccurate determination of Use Case Points components, because such components are not used in the proposed method.

scholarly journals Same but Different: Consistently Developing and Evolving Software Architecture Models and Their Implementation

2020 ◽  
pp. 87-112
Author(s):  
Marco Konersmann ◽  
Michael Goedicke
Keyword(s):  
Performance Evaluation ◽  
Software Architecture ◽  
Software Quality ◽  
Source Code ◽  
Use Case ◽  
Program Code ◽  
Separate Representation ◽  
Main Driver ◽  
Integrated Architecture ◽  
Architecture Specification

AbstractAs software architecture is a main driver for the software quality, source code is often accompanied by software architecture specifications. When the implementation is changed, the architecture specification is often not updated along with the code, which introduces inconsistencies between these artifacts. Such inconsistencies imply a risk of misunderstandings and errors during the development, maintenance, and evolution, causing serious degradation over the lifetime of the system. In this chapter we present the Explicitly Integrated Architecture approach and its tool Codeling, which remove the necessity for a separate representation of software architecture by integrating software architecture information with the program code. By using our approach, the specification can be extracted from the source code and changes in the specification can be propagated to the code. The integration of architecture information with the code leaves no room for inconsistencies between the artifacts and creates links between artifacts. We evaluate the approach and tool in a use case with real software in development and with a benchmark software, accompanied by a performance evaluation.

scholarly journals Synthesis of Code Anomalies: Revealing Design Problems in the Source Code

2020 ◽  
Author(s):  
Willian N. Oizumi ◽  
Alessandro F. Garcia
Keyword(s):  
Software Engineering ◽  
Source Code ◽  
New Technique ◽  
Software Systems ◽  
Identification Task ◽  
Software Projects ◽  
Design Problems ◽  
Engineering Community ◽  
Synthesis Technique ◽  
A New Technique

Design problems affect most software projects and make their maintenance expensive and impeditive. Thus, the identification of potential design problems in the source code – which is very often the only available and upto-date artifact in a project – becomes essential in long-living software systems. This identification task is challenging as the reification of design problems in the source code tend to be scattered through several code elements. However, stateof-the-art techniques do not provide enough information to effectively help developers in this task. In this work, we address this challenge by proposing a new technique to support developers in revealing design problems. This technique synthesizes information about potential design problems, which are materialized in the implementation under the form of syntactic and semantic anomaly agglomerations. Our evaluation shows that the proposed synthesis technique helps to reveal more than 1200 design problems across 7 industry-strength systems, with a median precision of 71% and a median recall of 78%. The relevance of our work has been widely recognized by the software engineering community through 2 awards and 7 publications in international and national venues.

ALBIS

2013 ◽  
pp. 188-206
Author(s):  
Lerina Aversano ◽  
Carmine Grasso ◽  
Maria Tortorella
Keyword(s):  
Information Retrieval ◽  
Software Maintenance ◽  
Business Processes ◽  
Semantic Analysis ◽  
Software Systems ◽  
Complex Task ◽  
Process Performance ◽  
Definition Of ◽  
Support Software

The evaluation of the alignment level existing between a business process and the supporting software systems is a critical concern for an organization, as the higher the alignment level is, the better the process performance is. Monitoring the alignment implies the characterization of all the items it involves and definition of measures for evaluating it. This is a complex task, and the availability of automatic tools for supporting evaluation and evolution activities may be precious. This chapter presents the ALBIS Environment (Aligning Business Processes and Information Systems), designed to support software maintenance tasks. In particular, the proposed environment allows the modeling and tracing between business and software entities and the measurement of their alignment degree. An information retrieval approach is embedded in ALBIS based on two processing phases including syntactic and semantic analysis. The usefulness of the environment is discussed through two case studies.

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.

Sign in / Sign up

Export Citation Format

Share Document