Source Code Comments Research Articles

Smart Contract Classification With a Bi-LSTM Based Approach

With the number of smart contracts growing rapidly, retrieving the relevant smart contracts quickly and accurately has become an important issue. A key step for recognizing the related smart contracts is able to classify them accurately. Different from traditional text, the smart contract is composed of several parts: source code, code comments and other useful information like account information. How to make good use of those different kinds of features for effective classification is a problem need to be solved. Inspired by this, we proposed a smart contract classification approach based on Bi-LSTM model and Gaussian LDA, which can use a variety of information as inputs of the model, including source code, comments, tags, account and other content information. Bi-LSTM is utilized to capture grammar rules and context information in source code, while Gaussian LDA model is employed to generate comments feature where the semantics of the comments are enriched by embeddings. We also use attention mechanism to focus on the more relevant features in smart contracts for tags and fuse account information to provide additional information for classification. The experimental results show that the classification performance of the proposed model is superior to other baseline models.

Neural Network-based Detection of Self-Admitted Technical Debt

Technical debt is a metaphor to reflect the tradeoff software engineers make between short-term benefits and long-term stability. Self-admitted technical debt (SATD), a variant of technical debt, has been proposed to identify debt that is intentionally introduced during software development, e.g., temporary fixes and workarounds. Previous studies have leveraged human-summarized patterns (which represent n-gram phrases that can be used to identify SATD) or text-mining techniques to detect SATD in source code comments. However, several characteristics of SATD features in code comments, such as vocabulary diversity, project uniqueness, length, and semantic variations, pose a big challenge to the accuracy of pattern or traditional text-mining-based SATD detection, especially for cross-project deployment. Furthermore, although traditional text-mining-based method outperforms pattern-based method in prediction accuracy, the text features it uses are less intuitive than human-summarized patterns, which makes the prediction results hard to explain. To improve the accuracy of SATD prediction, especially for cross-project prediction, we propose a Convolutional Neural Network-- (CNN) based approach for classifying code comments as SATD or non-SATD. To improve the explainability of our model’s prediction results, we exploit the computational structure of CNNs to identify key phrases and patterns in code comments that are most relevant to SATD. We have conducted an extensive set of experiments with 62,566 code comments from 10 open-source projects and a user study with 150 comments of another three projects. Our evaluation confirms the effectiveness of different aspects of our approach and its superior performance, generalizability, adaptability, and explainability over current state-of-the-art traditional text-mining-based methods for SATD classification.

Automating Change-Level Self-Admitted Technical Debt Determination

Technical debt (TD) is a metaphor to describe the situation where developers introduce suboptimal solutions during software development to achieve short-term goals that may affect the long-term software quality. Prior studies proposed different techniques to identify TD, such as identifying TD through code smells or by analyzing source code comments. Technical debt identified using comments is known as Self-Admitted Technical Debt (SATD) and refers to TD that is introduced intentionally. Compared with TD identified by code metrics or code smells, SATD is more reliable since it is admitted by developers using comments. Thus far, all of the state-of-the-art approaches identify SATD at the file-level. In essence, they identify whether a file has SATD or not. However, all of the SATD is introduced through software changes. Previous studies that identify SATD at the file-level in isolation cannot describe the TD context related to multiple files. Therefore, it is beneficial to identify the SATD once a change is being made. We refer to this type of TD identification as “Change-level SATD Determination”, which determines whether or not a change introduces SATD. Identifying SATD at the change-level can help to manage and control TD by understanding the TD context through tracing the introducing changes. To build a change-level SATD Determination model, we first identify TD from source code comments in source code files of all versions. Second, we label the changes that first introduce the SATD comments as TD-introducing changes. Third, we build the determination model by extracting 25 features from software changes that are divided into three dimensions, namely diffusion, history and message, respectively. To evaluate the effectiveness of our proposed model, we perform an empirical study on 7 open source projects containing a total of 100,011 software changes. The experimental results show that our model achieves a promising and better performance than four baselines in terms of AUC and cost-effectiveness (i.e., percentage of TD-introducing changes identified when inspecting 20 percent of changed LOC). On average across the 7 experimental projects, our model achieves AUC of 0.82, cost-effectiveness of 0.80, which is a significant improvement over the comparison baselines used. In addition, we found that “Diffusion” is the most discriminative dimension among the three dimensions of features for determining TD-introducing changes.

Classifying code comments in Java software systems

Code comments are a key software component containing information about the underlying implementation. Several studies have shown that code comments enhance the readability of the code. Nevertheless, not all the comments have the same goal and target audience. In this paper, we investigate how 14 diverse Java open and closed source software projects use code comments, with the aim of understanding their purpose. Through our analysis, we produce a taxonomy of source code comments; subsequently, we investigate how often each category occur by manually classifying more than 40,000 lines of code comments from the aforementioned projects. In addition, we investigate how to automatically classify code comments at line level into our taxonomy using machine learning; initial results are promising and suggest that an accurate classification is within reach, even when training the machine learner on projects different than the target one. Data and Materials [https://doi.org/10.5281/zenodo.2628361].

Automatically detecting the scopes of source code comments

Comments convey useful information about the system functionalities and many methods for software engineering tasks take comments as an important source for many software engineering tasks such as code semantic analysis, code reuse and so on. However, unlike structural doc comments, it is challenging to identify the relationship between the functional semantics of the code and its corresponding textual descriptions nested inside the code and apply it to automatic analyzing and mining approaches in software engineering tasks efficiently.In this paper, we propose a general method for the detection of source code comment scopes. Based on machine learning, our method utilized features of code snippets and comments to detect the scopes of source code comments automatically in Java programs. On the dataset of comment-statement pairs from 4 popular open source projects, our method achieved a high accuracy of 81.45% in detecting the scopes of comments. Furthermore, the results demonstrated the feasibility and effectiveness of our comment scope detection method on new projects.Moreover, our method was applied to two specific software engineering tasks in our studies: analyzing software repositories for outdated comment detection and mining software repositories for comment generation. As a general approach, our method provided a solution to comment-code mapping. It improved the performance of baseline methods in both tasks, which demonstrated that our method is conducive to automatic analyzing and mining approaches on software repositories.

Identification of Self-Admitted Technical Debt Using Enhanced Feature Selection Based on Word Embedding

Self-admitted technical debt (SATD) is annotated in source code comments by developers and has been recognized as a great source of discovering flawed software. To reduce manual effort, some recent studies have focused on automated detection of SATD using text classification methods. To train their classifier, these methods need labeled samples, which also require a lot of effort to obtain. We developed a new SATD identification method, which takes advantage of a large corpus of unlabeled code comments, extracted from open source projects, to train a word embedding model. After applying feature selection, the pre-trained word embedding is used for discovering semantically similar features in source code comments to enhance the original feature set. By using such enhanced feature set for classification, our goal was to improve the identification of SATD when compared to existing methods. The proposed feature enhancement method was used with the three most common feature selection methods (CHI, IG, and MI), and three well-known text classification algorithms (NB, SVM, and ME) and was tested on ten open source projects. The experimental results show a significant improvement in SATD identification over the compared methods. With an achieved 82% of correct predictions of SATD, the proposed method seems to be a good candidate to be adopted in practice.

A Survey of Automatic Generation of Source Code Comments: Algorithms and Techniques

As an integral part of source code files, code comments help improve program readability and comprehension. However, developers sometimes do not comment on their program code adequately due to the incurred extra efforts, lack of relevant knowledge, unawareness of the importance of code commenting or some other factors. As a result, code comments can be inadequate, absent or even mismatched with source code, which affects the understanding, reusing and the maintenance of software. To solve these problems of code comments, researchers have been concerned with generating code comments automatically. In this work, we aim at conducting a survey of automatic code commenting researches. First, we generally analyze the challenges and research framework of automatic generation of program comments. Second, we present the classification of representative algorithms, the design principles, strengths and weaknesses of each category of algorithms. Meanwhile, we also provide an overview of the quality assessment of the generated comments. Finally, we summarize some future directions for advancing the techniques of automatic generation of code comments and the quality assessment of comments.

KAPPA: Kinetic approach to physical processes in atmospheres library in C++

KAPPA, an open-source software library for the computation of thermodynamic and transport properties in non-equilibrium gas flows and species production rates, is presented. Thermodynamic properties rely on custom databases which describe the characteristics of atoms and molecules and interaction features. Mixture thermodynamic properties are formulated from species quantities. Species production rates are based on elementary chemical reactions and vibrational energy transitions. Transport properties are derived from kinetic theory which provides relationships for transport coefficients depending on the flow model. Several levels of non-equilibrium flow description are implemented: the detailed state-to-state (STS) approach, multi-temperature and one-temperature models. Sets of transport coefficients depend on the deviation from equilibrium; in the state-to-state model, they include state-resolved diffusion coefficients for each pair of vibrational states. A highly modular, object-oriented application program interface (API) has been developed. The adopted object-oriented programming paradigm (OOP), along with the implemented models of state-resolved physico-chemical relaxation rates, is presented. The design of the library allows it to be easily included in existing CFD codes and is aimed at code reusability and readability.Program Title: KAPPAProgram Files doi:http://dx.doi.org/10.17632/mrx9n35bvs.1Licensing provisions: GNU General Public Licence, version 3.Programming language: C++; developed and tested with Intel Compiler v. 18.x and GNU.External routines/libraries: KAPPA must be linked to yaml-cpp [1] in order to read human-readable database files and to Armadillo [2] for solving algebraic linear systems.Nature of problem: Numerical computation of transport properties and rate exchange coefficients for non-equilibrium reacting flows.Solution method: Non-equilibrium reacting flow is treated by a rigorous state-to-state (STS) kinetic theory approach.Restrictions: At present, KAPPA is validated for computing transport properties and rate exchange coefficients using the state-to-state (STS) approach; 1- and 2-temperature models have still to be validated, but they are already implemented. C++ compiler is mandatory.Unusual features: KAPPA is an open-source object-oriented highly modular and easy-to-maintain C++ software library which implements rigorous mathematical kinetic theory models.Additional comments: KAPPA project adopts Git [3], a free and open source distributed version control system. A public repository dedicated to KAPPA project [4] has been created on github, a web-based hosting service for software development projects using git versioning system. Finally, a comprehensive documentation [5] is provided parsing source code comments by means of doxygen software [6].

Using Natural Language Processing to Automatically Detect Self-Admitted Technical Debt

The metaphor of technical debt was introduced to express the trade off between productivity and quality, i.e., when developers take shortcuts or perform quick hacks. More recently, our work has shown that it is possible to detect technical debt using source code comments (i.e., self-admitted technical debt), and that the most common types of self-admitted technical debt are design and requirement debt. However, all approaches thus far heavily depend on the manual classification of source code comments. In this paper, we present an approach to automatically identify design and requirement self-admitted technical debt using Natural Language Processing (NLP). We study 10 open source projects: Ant, ArgoUML, Columba, EMF, Hibernate, JEdit, JFreeChart, JMeter, JRuby and SQuirrel SQL and find that 1) we are able to accurately identify self-admitted technical debt, significantly outperforming the current state-of-the-art based on fixed keywords and phrases; 2) words related to sloppy code or mediocre source code quality are the best indicators of design debt, whereas words related to the need to complete a partially implemented requirement in the future are the best indicators of requirement debt; and 3) we can achieve 90 percent of the best classification performance, using as little as 23 percent of the comments for both design and requirement self-admitted technical debt, and 80 percent of the best performance, using as little as 9 and 5 percent of the comments for design and requirement self-admitted technical debt, respectively. The last finding shows that the proposed approach can achieve a good accuracy even with a relatively small training dataset.

Identifying self-admitted technical debt in open source projects using text mining

Technical debt is a metaphor to describe the situation in which long-term code quality is traded for short-term goals in software projects. Recently, the concept of self-admitted technical debt (SATD) was proposed, which considers debt that is intentionally introduced, e.g., in the form of quick or temporary fixes. Prior work on SATD has shown that source code comments can be used to successfully detect SATD, however, most current state-of-the-art classification approaches of SATD rely on manual inspection of the source code comments. In this paper, we proposed an automated approach to detect SATD in source code comments using text mining. In our approach, we utilize feature selection to select useful features for classifier training, and we combine multiple classifiers from different source projects to build a composite classifier that identifies SATD comments in a target project. We investigate the performance of our approach on 8 open source projects that contain 212,413 comments. Our experimental results show that, on every target project, our approach outperforms the state-of-the-art and the baselines approaches in terms of F1-score. The F1-score achieved by our approach ranges between 0.518 - 0.841, with an average of 0.737, which improves over the state-of-the-art approach proposed by Potdar and Shihab by 499.19%. When compared with the text mining-based baseline approaches, our approach significantly improves the average F1-score by at least 58.49%. When compared with a natural language processing-based baseline, our approach also significantly improves its F1-score by 27.95%. Our proposed approach can be used by project personnel to effectively identify SATD with minimal manual effort.

Inferring software behavioral models with MapReduce

In the real world practice, software systems are often built without developing any explicit upfront model. This can cause serious problems that may hinder the almost inevitable future evolution, since at best the only documentation about the software is in the form of source code comments. To address this problem, research has been focusing on automatic inference of models by applying machine learning algorithms to execution logs. However, the logs generated by a real software system may be very large and the inference algorithm can exceed the processing capacity of a single computer. This paper proposes a scalable, general approach to the inference of behavior models that can handle large execution logs via parallel and distributed algorithms implemented using the MapReduce programming model and executed on a cluster of interconnected execution nodes. The approach consists of two distributed phases that perform trace slicing and model synthesis . For each phase, a distributed algorithm using MapReduce is developed. With the parallel data processing capacity of MapReduce, the problem of inferring behavior models from large logs can be efficiently solved. The technique is implemented on top of Hadoop. Experiments on Amazon clusters show efficiency and scalability of our approach. • A distributed trace slicing algorithm using MapReduce. • A distributed model synthesis algorithm using MapReduce. • A novel approach for inferring software behavior models with MapReduce. • Experimental results show promising performance of this approach.

Analysis of the Documentation of ERP Software Projects

Software documentation is a basic component of the software development process and it is very important in all the phases of a software system life cycle. It is plays a very important role from the point of view of both the software engineer and user. Software documentation usually includes textual documentation required by the Software engineering standards, API documentation, Wiki pages and source code comments. Surveys and studies indicate that the documentation is not always available and, if available, only partially addresses the developers’ needs, as it is often wrong, incomplete, out-of-date and ambiguous. In the context of ERP – Enterprise Resource Planning, the relevance of the software documentation is even more important due to the complexity of such a kind of software systems and the strategic role they have within operative organizations. This paper focuses on the quality assessment of the documentation of ERP open source systems with the aim of understanding if they include high quality documentation for adequately support anyone want to adopt them and/or executing maintenance activities. Specifically, a quality model is defined and its application to three Open source software system is performed.

OFF, Open source Finite volume Fluid dynamics code: A free, high-order solver based on parallel, modular, object-oriented Fortran API

OFF, an open source (free software) code for performing fluid dynamics simulations, is presented. The aim of OFF is to solve, numerically, the unsteady (and steady) compressible Navier–Stokes equations of fluid dynamics by means of finite volume techniques: the research background is mainly focused on high-order (WENO) schemes for multi-fluids, multi-phase flows over complex geometries. To this purpose a highly modular, object-oriented application program interface (API) has been developed. In particular, the concepts of data encapsulation and inheritance available within Fortran language (from standard 2003) have been stressed in order to represent each fluid dynamics “entity” (e.g. the conservative variables of a finite volume, its geometry, etc…) by a single object so that a large variety of computational libraries can be easily (and efficiently) developed upon these objects. The main features of OFF can be summarized as follows:Programming LanguageOFF is written in standard (compliant) Fortran 2003; its design is highly modular in order to enhance simplicity of use and maintenance without compromising the efficiency;Parallel Frameworks Supported the development of OFF has been also targeted to maximize the computational efficiency: the code is designed to run on shared-memory multi-cores workstations and distributed-memory clusters of shared-memory nodes (supercomputers); the code’s parallelization is based on Open Multiprocessing (OpenMP) and Message Passing Interface (MPI) paradigms;Usability, Maintenance and Enhancement in order to improve the usability, maintenance and enhancement of the code also the documentation has been carefully taken into account; the documentation is built upon comprehensive comments placed directly into the source files (no external documentation files needed): these comments are parsed by means of doxygen free software producing high quality html and latex documentation pages; the distributed versioning system referred as git has been adopted in order to facilitate the collaborative maintenance and improvement of the code;CopyrightsOFF is a free software that anyone can use, copy, distribute, study, change and improve under the GNU Public License version 3.The present paper is a manifesto of OFF code and presents the currently implemented features and ongoing developments. This work is focused on the computational techniques adopted and a detailed description of the main API characteristics is reported. OFF capabilities are demonstrated by means of one and two dimensional examples and a three dimensional real application. Program summaryProgram title:OFFCatalogue identifier: AESV_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AESV_v1_0.htmlProgram obtainable from: CPC Program Library, Queen’s University, Belfast, N. IrelandLicensing provisions: GNU General Public Licence, version 3No. of lines in distributed program, including test data, etc.: 60466No. of bytes in distributed program, including test data, etc.: 595575Distribution format: tar.gzProgramming language: Fortran (standard 2003 or newer); developed and tested with Intel Fortran Compiler v. 12.x or newer.Computer: Designed for shared-memory multi-cores workstations and for hybrid distributed/shared-memory supercomputers, but any computer system with a Fortran (2003+) compiler is suited.Operating system: Designed for POSIX architecture and tested on GNU/Linux one.Has the code been vectorized or parallelized?: Hybrid parallelization by means of MPI library and OpenMP paradigm, tested on up to 256 processors.RAM: [1 MB; 1 GB] x core, simulation-dependentClassification: 4.3, 4.10, 12.External routines: The proprietary library [1] must be linked for producing binary outputs in Tecplot Inc. format; the MPI library [2] must be linked for running on distribute-memory parallel systemsNature of problem:Numerical solution of the Compressible Navier–Stokes equations for multi-fluids multi-phase flows in complex geometriesSolution method:Fully-conservative Finite Volume scheme based on very high-order WENO Positivity-Preserving reconstruction technique and Strong Stability Preserving high-order Runge–Kutta time integration. Structured multi-block general curvilinear and body-fitted grids constitute the underlining numerical grids. MPI and OpenMP paradigms are used for parallel computations. Pre-processing tool to deal with commercial meshing softwares is provided as well as post-processing one for numerical results visualizationRestrictions:At present, OFF is validated for simulating inviscid and single-phase flows (viscous fluxes computation and fully coupled Eulerian /Lagrangian schemes have still to be validated, but they are already implemented); modern Fortran compiler is mandatoryUnusual features:OFF is a complex CFD software strongly based on Object-Oriented Programming paradigm by means of modern Fortran standard (2003 or higher)Additional comments:OFF project adopts Git [3], a free and open source distributed version control system. A public repository dedicated to OFF project [4] has been created on github, a web-based hosting service for software development projects using git versioning system. Finally, a comprehensive documentation [5] is provided parsing source code comments by means of doxygen software [6]Running time:The running time depends on the available computation resources, the complexity of the problem and the selected accuracy of the numerical scheme. Simple one dimensional problems require few minutes on personal workstation-like systems whereas complex three dimensional problems needing high accuracy (e.g. DNS) could require weeks on supercomputers. OFF has proven to have a good scalability on small clusters (e.g. CASPUR facilities, namely on Matrix, a GNU/Linux cluster composed by 320 nodes each one constituted by a dual Opteron quadcore at 2.1GHz with 16/32 GB of RAM)

基于主题建模和静态分析技术的软件代码功能性主题获取方法

Recently, topic modeling-based source code comprehension has become one of the research hotspots. Researchers mine functional topics from source code with topic modeling techniques, and use these functional topics to help developers comprehend the functional concerns of a software system and the corresponding implementations in source code. However, because diverse kinds of topics, including functional topics and other noisy topics, are mixed together in the raw topics mined from source code, developers have to identify functional topics manually. The manual identification process is difficult and time-consuming due to the fact that only basic information (e.g. associated words) is provided by previous approaches. In this paper, we propose a topic modeling and static analysis-based approach to obtain functional topics from source code. Firstly, we execute source code preprocessing with a series of Filtering Heuristics, and then mine raw topics from source code using topic modeling techniques. Then, we conduct static analysis on source code to obtain structural relationships, based on which we propose a novel metric called Topic Cohesion to identify functional topics from the raw topics. Finally, we locate source code elements that implement the topics, and generate topic descriptions using source code comments for the developers to comprehend the topics. Experiments on a set of open source software show that our approach can effectively obtain functional topics and their associated information, which helps developer comprehend the functional concerns of a software system and the corresponding implementations in source code.

How Software Developers Use Tagging to Support Reminding and Refinding

Developers frequently add annotations to source code to help them remember pertinent information and mark locations of interest for future investigation. Finding and refinding these notes is a form of navigation that is integral to software maintenance. Although there is some tool support in modern development environments for authoring and navigating these comments, we have observed that these annotations often fail to remind and are sometimes difficult to find by the programmer. To address these shortcomings, we have designed a new approach for software navigation called tags for software engineering activities (TagSEA). TagSEA combines the notion of waypointing (a mechanism for marking locations in spatial navigation) with social tagging to support programmers in defining semantically rich annotations to source code comments. The tool provides support for creating, editing, navigating, and managing these annotations. We present the results from two empirical studies, where we observed and then analyzed how professional programmers used source code annotations to support their development activities over 24 months. Our findings indicate that the addition of semantic information to annotations can improve their value. We also provide suggestions on how annotation tools in general may be improved.

Analyzing the co-evolution of comments and source code

Source code comments are a valuable instrument to preserve design decisions and to communicate the intent of the code to programmers and maintainers. Nevertheless, commenting source code and keeping comments up-to-date is often neglected for reasons of time or programmers obliviousness. In this paper, we investigate the question whether developers comment their code and to what extent they add comments or adapt them when they evolve the code. We present an approach to associate comments with source code entities to track their co-evolution over multiple versions. A set of heuristics are used to decide whether a comment is associated with its preceding or its succeeding source code entity. We analyzed the co-evolution of code and comments in eight different open source and closed source software systems. We found with statistical significance that (1) the relative amount of comments and source code grows at about the same rate; (2) the type of a source code entity, such as a method declaration or an if-statement, has a significant influence on whether or not it gets commented; (3) in six out of the eight systems, code and comments co-evolve in 90% of the cases; and (4) surprisingly, API changes and comments do not co-evolve but they are re-documented in a later revision. As a result, our approach enables a quantitative assessment of the commenting process in a software system. We can, therefore, leverage the results to provide feedback during development to increase the awareness of when to add comments or when to adapt comments because of source code changes.

A Library to Generate Synthetic Precipitation Data

A critical issue in biophysical modeling projects is to develop a set of reusable libraries to support the development of future applications. This is true for weather modeling as well. Rain is a software component providing a collection of stochastic approaches to generate precipitation data on daily and subdaily time steps. Synthetic data generated on a daily time step consists of precipitation occurrence and amount. Subdaily generation includes time of peak, peak intensity, storm arrival, and duration. The software design allows for extension of the models implemented without recompiling the component. The component, inclusive of a hypertext help file and of documentation generated from source code comments, has been released as compiled .NET and Java versions, allowing application development in either programming environment. Illustrative examples of Windows‐based applications using Rain are provided as source code. A sample web service and a web application were also developed as possible use of the component.

Two controlled experiments assessing the usefulness of design pattern documentation in program maintenance

Using design patterns is claimed to improve programmer productivity and software quality. Such improvements may manifest both at construction time (in faster and better program design) and at maintenance time (in faster and more accurate program comprehension). The paper focuses on the maintenance context and reports on experimental tests of the following question: does it help the maintainer if the design patterns in the program code are documented explicitly (using source code comments) compared to a well-commented program without explicit reference to design patterns? Subjects performed maintenance tasks on two programs ranging from 360 to 560 LOC including comments. The experiments tested whether pattern comment lines (PCL) help during maintenance if patterns are relevant and sufficient program comments are already present. This question is a challenge for the experimental methodology: A setup leading to relevant results is quite difficult to find. We discuss these issues in detail and suggest a general approach to such situations. A conservative analysis of the results supports the hypothesis that pattern-relevant maintenance tasks were completed faster or with fewer errors if redundant design pattern information was provided. The article provides the first controlled experiment results on design pattern usage and it presents a solution approach to an important class of experiment design problems for experiments regarding documentation.

Recovering software architecture from the names of source files

We discuss how to extract a useful set of subsystems from a set of existing source-code file names. This problem is challenging because many legacy systems use thousands of files names, including some that are very short and cryptic. At the same time the problem is important because software maintainers often find it difficult to understand such systems. We propose a general algorithm to cluster files based on their names, and a set of alternative methods for implementing the algorithm. One of the key tasks is picking candidate words to try to identify in file names. We do this by (a) iteratively decomposing file names, (b) finding common substrings, and (c) choosing words in routine names, in an English dictionary or in source-code comments. In addition, we investigate generating abbreviations from the candidate words in order to find matches in file names, as well as how to split file names into components given no word markers. To compare and evaluate our five approaches, we present two experiments. The first compares the ‘concepts’ found in each file name by each method with the results of manually decomposing file names. The second experiment compares automatically generated subsystems with subsystem examples proposed by experts. We conclude that two methods are most effective: extracting concepts using common substrings and extracting those concepts that relate to the names of routines in the files. Copyright © 1999 John Wiley & Sons, Ltd.