The document discusses techniques for providing a structured location of software features in code. It involves mapping features to relevant modules, analyzing relationships between modules, and exploring implementation structures of features. This includes identifying inter-feature and intra-feature structures as well as sub-feature structures. The techniques are demonstrated on an example application, and future work is outlined to improve scalability and evaluate effectiveness.
This document summarizes research on refactoring edit histories of source code. It describes how edit histories can become tangled and hard to understand over time. The researchers propose refactoring edit histories by restructuring them without changing the overall effect of the edits. This involves primitive operations like swapping and merging changes. It also describes a supporting tool called Historef that performs history refactoring. Example applications include committing changes by task and selectively undoing changes.
Toward Understanding How Developers Recognize Features in Source Code from De...Shinpei Hayashi
The experiment compared how developers recognized target features in source code based on an original versus a refined natural language description of the feature. For two different features from an FL benchmark, subjects voted on which modules they thought implemented each feature after reading the original or refined description. For some modules actually relevant to the features, more subjects voted for them based on the refined descriptions, indicating the refined descriptions helped contributors recognize the target features.
iFL: An Interactive Environment for Understanding Feature ImplementationsShinpei Hayashi
The document summarizes an interactive environment called iFL that was developed to help understand feature implementations in source code. iFL uses feature location techniques and allows users to provide feedback to improve results. It performs the following steps:
1. It conducts an initial feature location search based on the user's query.
2. It displays the ranked code fragments to the user for review.
3. The user can provide feedback on the relevance of code fragments, which is used to update the search queries and rankings.
4. Additional searches may be performed with the updated queries to improve the results.
An evaluation with sample projects found that iFL reduced the costs of understanding feature implementations in most cases compared
Recording Finer-Grained Software Evolution with IDE: An Annotation-Based Appr...Shinpei Hayashi
This document proposes an annotation-based approach to recording finer-grained software evolution using an IDE. Developers can classify their edit operations according to different modes, and the system structures the edits to generate source code deltas for each intentional change. A prototype implementation as an Eclipse plug-in automates reordering edits based on the modes. This approach aims to avoid mixed changesets and better capture the relationships between changes.
Modeling and Utilizing Security Knowledge for Eliciting Security RequirementsShinpei Hayashi
This document proposes a technique for eliciting security requirements early in the development process. It involves using security knowledge from security targets and common criteria standards. Potential threats are detected by matching scenario descriptions to threat patterns using graph transformation. When a threat is detected, a negative scenario is derived and security objectives are embedded to address the threat. An evaluation of the technique found it could accurately detect threats in scenarios from different domains, though some false positives and negatives occurred. Overall, the technique shows promise for aiding the elicitation of security requirements.
The document discusses techniques for providing a structured location of software features in code. It involves mapping features to relevant modules, analyzing relationships between modules, and exploring implementation structures of features. This includes identifying inter-feature and intra-feature structures as well as sub-feature structures. The techniques are demonstrated on an example application, and future work is outlined to improve scalability and evaluate effectiveness.
This document summarizes research on refactoring edit histories of source code. It describes how edit histories can become tangled and hard to understand over time. The researchers propose refactoring edit histories by restructuring them without changing the overall effect of the edits. This involves primitive operations like swapping and merging changes. It also describes a supporting tool called Historef that performs history refactoring. Example applications include committing changes by task and selectively undoing changes.
Toward Understanding How Developers Recognize Features in Source Code from De...Shinpei Hayashi
The experiment compared how developers recognized target features in source code based on an original versus a refined natural language description of the feature. For two different features from an FL benchmark, subjects voted on which modules they thought implemented each feature after reading the original or refined description. For some modules actually relevant to the features, more subjects voted for them based on the refined descriptions, indicating the refined descriptions helped contributors recognize the target features.
iFL: An Interactive Environment for Understanding Feature ImplementationsShinpei Hayashi
The document summarizes an interactive environment called iFL that was developed to help understand feature implementations in source code. iFL uses feature location techniques and allows users to provide feedback to improve results. It performs the following steps:
1. It conducts an initial feature location search based on the user's query.
2. It displays the ranked code fragments to the user for review.
3. The user can provide feedback on the relevance of code fragments, which is used to update the search queries and rankings.
4. Additional searches may be performed with the updated queries to improve the results.
An evaluation with sample projects found that iFL reduced the costs of understanding feature implementations in most cases compared
Recording Finer-Grained Software Evolution with IDE: An Annotation-Based Appr...Shinpei Hayashi
This document proposes an annotation-based approach to recording finer-grained software evolution using an IDE. Developers can classify their edit operations according to different modes, and the system structures the edits to generate source code deltas for each intentional change. A prototype implementation as an Eclipse plug-in automates reordering edits based on the modes. This approach aims to avoid mixed changesets and better capture the relationships between changes.
Modeling and Utilizing Security Knowledge for Eliciting Security RequirementsShinpei Hayashi
This document proposes a technique for eliciting security requirements early in the development process. It involves using security knowledge from security targets and common criteria standards. Potential threats are detected by matching scenario descriptions to threat patterns using graph transformation. When a threat is detected, a negative scenario is derived and security objectives are embedded to address the threat. An evaluation of the technique found it could accurately detect threats in scenarios from different domains, though some false positives and negatives occurred. Overall, the technique shows promise for aiding the elicitation of security requirements.
Generating Assertion Code from OCL: A Transformational Approach Based on Simi...Shinpei Hayashi
This document presents an approach for generating assertion code from the Object Constraint Language (OCL) using model transformations. The approach constructs a hierarchy of programming languages based on their structural similarities. This allows rules for translating OCL to be reused across multiple implementation languages, saving approximately 50% of the effort compared to creating individual translators. An evaluation implemented the approach in Maude and demonstrated its ability to generate code for Java, Python, Haskell and O'Haskell from a single OCL specification.
Understanding Source Code Differences by Separating Refactoring EffectsShinpei Hayashi
The document discusses separating refactoring effects from source code differences by describing refactoring changes that were made between versions of code. It provides an example of refactoring changes made between two versions of code, including renaming a class and parameters, deleting a for-loop, commenting out code, and renaming a method. The example highlights how refactoring can introduce differences that are not actual behavior changes.
Incremental Feature Location and Identification in Source CodeHiroshi Kazato
This document describes a technique for classifying dependencies between software features to aid in feature location and identification. It combines static dependency analysis with dynamic feature location to classify dependencies as covered, uncovered, incoming, outgoing, or intra-feature. An example application with 8 features is used to demonstrate the technique. By exploring dependencies manually and adding test scenarios, the technique helps narrow the set of uncovered dependencies between features that require further investigation.
Detecting Occurrences of Refactoring with Heuristic SearchShinpei Hayashi
This document describes a technique for detecting refactorings between two versions of a program using heuristic search. Refactorings are detected by generating intermediate program states through applying refactorings, and finding a path from the original to modified program that minimizes differences. Structural differences are used to identify likely refactorings. Candidate refactorings are evaluated and applied to generate new states, with the search terminating when the state matches the modified program. A supporting tool was developed and a case study found the technique could correctly detect an actual series of refactorings between program versions.
Supporting Design Model Refactoring for Improving Class Responsibility Assign...Shinpei Hayashi
The document discusses supporting automated refactoring of class responsibility assignment (CRA) designs. It proposes defining detection rules for CRA "bad smells" based on the GRASP pattern language, and defining transformation rules for refactoring operations. An example refactoring is introduced polymorphism, which separately assigns coordinated responsibilities to individual classes having a common parent class. The authors implemented a tool called RAST to detect CRA smells, suggest refactorings, and apply refactorings to support improving CRA designs.
Class Responsibility Assignment as Fuzzy Constraint SatisfactionShinpei Hayashi
The document proposes formulating class responsibility assignment (CRA) as a fuzzy constraint satisfaction problem (FCSP). It represents CRA criteria like low coupling and high cohesion as fuzzy constraints. An initial CRA can be improved by reassigning responsibilities while satisfying constraints. Users' intentions can also be added as constraints. The approach was evaluated on two systems, showing reasonable accuracy in assigning responsibilities from scratch or improving initial assignments. Constraint satisfaction was fast enough. Developing an interactive design tool to support CRA using this flexible FCSP formulation was discussed.
Feature Location for Multi-Layer System Based on Formal Concept AnalysisHiroshi Kazato
The document proposes a technique to locate features implemented across multiple layers of a system using formal concept analysis. It involves conducting dynamic analysis separately on each layer to extract execution traces, then relating the observed elements using formal concept analysis to build a concept lattice that shows collaborations realizing features composed of program elements from different layers. As a case study, it applies this technique to locate features across the presentation, application, and data layers of the iBATIS JPetStore application.
Sentence-to-Code Traceability Recovery with Domain OntologiesShinpei Hayashi
The document describes a technique for recovering traceability between natural language sentences and source code using domain ontologies. An automated tool was implemented and evaluated on a case study using the JDraw software. Results showed the technique worked well, recovering traceability between 7 sentences and code with higher accuracy than without using the ontology. The ontology helped improve recall and detect traceability in cases where word similarity alone did not work well. Future work is needed to evaluate on larger cases and domains.
Terminology Matching of Requirements Specification Documents and Regulations ...Shinpei Hayashi
The document presents a technique for systematically checking compliance between requirements specifications and regulations by matching terminology. It involves detecting concepts in requirements documents and regulations, instantiating property templates to represent semantic relationships, and checking consistency using a model checker. The technique was implemented and tested on two case studies, demonstrating its ability to identify compliance violations. However, some failures occurred due to structural differences in case frames and relationships between formulas. Future work aims to improve matching accuracy through larger case studies.
Historef: A Tool for Edit History RefactoringShinpei Hayashi
Historef is a tool that helps refactor a project's edit history by grouping related code changes together into logical commits. It works by recording a developer's code edits using an edit recorder plugin in Eclipse, which allows Historef to obtain the changes and invoke refactoring commands to group tangled changes into switched commits, resulting in a cleaner edit history that is easier to understand and work with.
Guiding Identification of Missing Scenarios for Dynamic Feature LocationShinpei Hayashi
1) The document discusses identifying missing scenarios for dynamic feature location which involves specifying modules based on execution profiles obtained from scenarios. A lack of scenarios can lead to insufficient results.
2) It proposes finding clues for new scenarios by prioritizing which unexplored call dependencies to focus on for preparing additional scenarios. This is done by measuring the potential impact of unexplored dependencies using metrics like the number of outgoing unexplored dependencies.
3) The aim is to help guide the identification of missing scenarios that could provide more complete feature location results.
How Can You Improve Your As-is Models? Requirements Analysis Methods Meet GQMShinpei Hayashi
The document describes a method for improving existing models (as-is models) by identifying problems and deriving new models (to-be models). It uses an integrated modeling approach combining goal models, use case descriptions, and context diagrams. Metrics are derived using the GQM method to help identify problems by quantifying aspects of the as-is model. The problems identified are then used to refine goals and develop an improved to-be model in an iterative process.
Generating Assertion Code from OCL: A Transformational Approach Based on Simi...Shinpei Hayashi
This document presents an approach for generating assertion code from the Object Constraint Language (OCL) using model transformations. The approach constructs a hierarchy of programming languages based on their structural similarities. This allows rules for translating OCL to be reused across multiple implementation languages, saving approximately 50% of the effort compared to creating individual translators. An evaluation implemented the approach in Maude and demonstrated its ability to generate code for Java, Python, Haskell and O'Haskell from a single OCL specification.
Understanding Source Code Differences by Separating Refactoring EffectsShinpei Hayashi
The document discusses separating refactoring effects from source code differences by describing refactoring changes that were made between versions of code. It provides an example of refactoring changes made between two versions of code, including renaming a class and parameters, deleting a for-loop, commenting out code, and renaming a method. The example highlights how refactoring can introduce differences that are not actual behavior changes.
Incremental Feature Location and Identification in Source CodeHiroshi Kazato
This document describes a technique for classifying dependencies between software features to aid in feature location and identification. It combines static dependency analysis with dynamic feature location to classify dependencies as covered, uncovered, incoming, outgoing, or intra-feature. An example application with 8 features is used to demonstrate the technique. By exploring dependencies manually and adding test scenarios, the technique helps narrow the set of uncovered dependencies between features that require further investigation.
Detecting Occurrences of Refactoring with Heuristic SearchShinpei Hayashi
This document describes a technique for detecting refactorings between two versions of a program using heuristic search. Refactorings are detected by generating intermediate program states through applying refactorings, and finding a path from the original to modified program that minimizes differences. Structural differences are used to identify likely refactorings. Candidate refactorings are evaluated and applied to generate new states, with the search terminating when the state matches the modified program. A supporting tool was developed and a case study found the technique could correctly detect an actual series of refactorings between program versions.
Supporting Design Model Refactoring for Improving Class Responsibility Assign...Shinpei Hayashi
The document discusses supporting automated refactoring of class responsibility assignment (CRA) designs. It proposes defining detection rules for CRA "bad smells" based on the GRASP pattern language, and defining transformation rules for refactoring operations. An example refactoring is introduced polymorphism, which separately assigns coordinated responsibilities to individual classes having a common parent class. The authors implemented a tool called RAST to detect CRA smells, suggest refactorings, and apply refactorings to support improving CRA designs.
Class Responsibility Assignment as Fuzzy Constraint SatisfactionShinpei Hayashi
The document proposes formulating class responsibility assignment (CRA) as a fuzzy constraint satisfaction problem (FCSP). It represents CRA criteria like low coupling and high cohesion as fuzzy constraints. An initial CRA can be improved by reassigning responsibilities while satisfying constraints. Users' intentions can also be added as constraints. The approach was evaluated on two systems, showing reasonable accuracy in assigning responsibilities from scratch or improving initial assignments. Constraint satisfaction was fast enough. Developing an interactive design tool to support CRA using this flexible FCSP formulation was discussed.
Feature Location for Multi-Layer System Based on Formal Concept AnalysisHiroshi Kazato
The document proposes a technique to locate features implemented across multiple layers of a system using formal concept analysis. It involves conducting dynamic analysis separately on each layer to extract execution traces, then relating the observed elements using formal concept analysis to build a concept lattice that shows collaborations realizing features composed of program elements from different layers. As a case study, it applies this technique to locate features across the presentation, application, and data layers of the iBATIS JPetStore application.
Sentence-to-Code Traceability Recovery with Domain OntologiesShinpei Hayashi
The document describes a technique for recovering traceability between natural language sentences and source code using domain ontologies. An automated tool was implemented and evaluated on a case study using the JDraw software. Results showed the technique worked well, recovering traceability between 7 sentences and code with higher accuracy than without using the ontology. The ontology helped improve recall and detect traceability in cases where word similarity alone did not work well. Future work is needed to evaluate on larger cases and domains.
Terminology Matching of Requirements Specification Documents and Regulations ...Shinpei Hayashi
The document presents a technique for systematically checking compliance between requirements specifications and regulations by matching terminology. It involves detecting concepts in requirements documents and regulations, instantiating property templates to represent semantic relationships, and checking consistency using a model checker. The technique was implemented and tested on two case studies, demonstrating its ability to identify compliance violations. However, some failures occurred due to structural differences in case frames and relationships between formulas. Future work aims to improve matching accuracy through larger case studies.
Historef: A Tool for Edit History RefactoringShinpei Hayashi
Historef is a tool that helps refactor a project's edit history by grouping related code changes together into logical commits. It works by recording a developer's code edits using an edit recorder plugin in Eclipse, which allows Historef to obtain the changes and invoke refactoring commands to group tangled changes into switched commits, resulting in a cleaner edit history that is easier to understand and work with.
Guiding Identification of Missing Scenarios for Dynamic Feature LocationShinpei Hayashi
1) The document discusses identifying missing scenarios for dynamic feature location which involves specifying modules based on execution profiles obtained from scenarios. A lack of scenarios can lead to insufficient results.
2) It proposes finding clues for new scenarios by prioritizing which unexplored call dependencies to focus on for preparing additional scenarios. This is done by measuring the potential impact of unexplored dependencies using metrics like the number of outgoing unexplored dependencies.
3) The aim is to help guide the identification of missing scenarios that could provide more complete feature location results.
How Can You Improve Your As-is Models? Requirements Analysis Methods Meet GQMShinpei Hayashi
The document describes a method for improving existing models (as-is models) by identifying problems and deriving new models (to-be models). It uses an integrated modeling approach combining goal models, use case descriptions, and context diagrams. Metrics are derived using the GQM method to help identify problems by quantifying aspects of the as-is model. The problems identified are then used to refine goals and develop an improved to-be model in an iterative process.