Keyword programming is a novel technique for reducing the need to remember details of programming language syntax and APIs, by translating a small number of keywords provided by the user into a valid expression. Prior work has demonstrated the feasibility and merit of this approach in limited domains. This paper presents a new algorithm that scales to the much larger domain of general-purpose Java programming. We tested the algorithm by extracting keywords from method calls in open source projects, and found that it could accurately reconstruct over 90 % of the original expressions. We also conducted a study using keywords generated by users, whose results suggest that users can obtain correct Java code using keyword queries as accurately as they can write the correct Java code themselves.

Abstract—Applications built on reusable component frameworks are subject to two independent, and potentially conflicting, evolution processes. The application evolves in response to the specific requirements and desired qualities of the application’s stakeholders. On the other hand, the evolution of the component framework is driven by the need to improve the framework functionality and quality while maintaining its generality. Thus, changes to the component framework frequently change its API on which its client applications rely and, as a result, these applications break. To date, there has been some work aimed at supporting the migration of client applications to newer versions of their underlying frameworks, but it usually requires that the framework developers do additional work for that purpose or that the application developers use the same tools as the framework developers. In this paper, we discuss our approach to tackle the API-evolution problem in the context of reuse-based software development, which automatically recognizes the API changes of the reused framework and proposes plausible replacements to the “obsolete ” API based on working examples of the framework code base. This approach has been implemented in the Diff-CatchUp tool. We report on two case studies that we have conducted to evaluate the effectiveness of our approach with its Diff-CatchUp prototype. Index Terms—Software reuse, API evolution, model differencing, software migration. 1

It is common practice for software developers to use examples to guide development efforts. This largely unwritten, yet standard, practice of “develop by example ” is often supported by examples bundled with library or framework packages, provided in textbooks, and made available for download on both official and unofficial web sites. However, the vast number of examples that are embedded in the billions of lines of already developed library and framework code are largely untapped. We have developed XSnippet, a contextsensitive code assistant framework that allows developers to query a sample repository for code snippets that are relevant to the programming task at hand. In particular, our work makes three primary contributions. First, a range of queries is provided to allows developers to switch between a context-independent retrieval of code snippets to various degrees of context-sensitive retrieval. Second, a novel graph-based code mining algorithm is provided to support the range of queries and enable mining within and across method boundaries. Third, an innovative context-sensitive ranking heuristic is provided that has been experimentally proven to provide better ranking for best-fit code snippets than context-independent heuristics such as shortest path and frequency. Our experimental evaluation has shown that XSnippet has significant potential to assist developers, and provides better coverage of tasks and better rankings for best-fit snippets than other code assistant systems.

Open source projects are typically organized in a distributed and decentralized manner. These factors strongly determine the processes followed and constrain the types of tools that can be utilized. This paper explores how distribution and decentralization have affected processes and tools in existing open source projects with the goals of summarizing the lessons learned and identifying opportunities for improving both. Issues considered include decision-making, accountability, communication, awareness, rationale, managing source code, testing, and release management.

Developers need to evaluate reusable components before they decide to adopt them. When a developer evaluates a component they need to understand how that component can be used, and the behaviour that the component will exhibit. Existing evaluation techniques use formal analysis, sophisticated classification/search functionality, or rely on the presence of extensive component documentation or evaluation component versions.

The existence of large API libraries contributes significantly to the programming productivity and quality of Java programmers. The vast number of available library APIs, however, presents a learning challenge for Java programmers. Most Java programmers do not know all the APIs. Whenever their programming task requires API methods they do not yet know, they have to be able to find what they need and learn how to use them on demand. This paper describes a tool called STeP_IN_Java (a Socio-Technical Platform for In situ Networking of Java programmers) that helps Java programmers find APIs, and learn from both examples and experts how to use them on demand. STeP_IN_Java features a sophisticated yet easy-to-use search interface that enables programmers to conduct a personalized search and to progressively refine their search by limiting search scopes. Example programs are provided and embedded to assist programmers in using APIs. Furthermore, if a programmer still has questions about a particular API method, he or she can ask peer programmers. The STeP_IN_Java system automatically routes the question to a group of experts who are chosen based on two criteria: they have high expertise on the particular API method and they have a good social relationship with the programmer who is requesting the information.

Software maintenance tasks typically involve an important amount of program investigation effort on the part of software developers. To what extent can we benefit from prior program investigation activities to decrease this effort? To investigate this question, we studied the revision history of two systems to determine how knowledge derived from prior investigation activities could have been reused to support other change tasks. Our initial investigation used a tool, ConcernDetector, that can recommend sets of program elements associated with a high-level concern when elements in the set overlap with elements currently being modified. We discovered that simple overlap-based techniques for retrieving prior investigation knowledge have important limitations, and that effective reuse of prior program investigation knowledge requires analyses that can partially infer the nature and intent of a task. 1.

Abstract — The introduction of Semantic Web techniques in Service-oriented Architectures enables explicit representation and reasoning about semantically rich descriptions of service operations. Those techniques hold promise for the automated discovery, selection, composition and binding of services. This paper describes an approach to derive formal specifications of Web Service compositions on the basis of the interpretation of informal user requests expressed in restricted Natural Language. Our approach leverages the semantic and ontological description of a portfolio of known service operations (called the Semantic Service Catalog). Each user request is processed against a Natural Language vocabulary that includes lexical constructs designed to convey the operations ' semantics, in order to recognize and extract fundamental functional requirements implied by the request, and associate them to entries in the Catalog. In addition, the request interpreter extracts from the request the overall service logic, expressed in terms of a set of modular templates describing control and data flow among the selected operations. The result is a composition specification that associates on demand each user request to a new composed service. That specification is formal and can thus be transformed in an executable flow document for a target service composition engine.

Deployable components are software components that can easily be installed and uninstalled. This usually means that they are compiled and do not consist of source code. Composition environments enable the use of deployable components by making it possible to compose applications out of deployable components and to execute those applications.

Abstract—Software projects often rely on third-party libraries made accessible through Application Programming Interfaces (APIs). We have observed many cases where APIs are used in ways that are not the most effective. We developed a technique and tool support to automatically detect such patterns of API usage in software projects. The main hypothesis underlying our technique is that client code imitating the behavior of an API method without calling it may not be using the API effectively because it could instead call the method it imitates. Our technique involves analyzing software systems to detect cases of API method imitations. In addition to warning developers of potentially reimplemented API methods, we also indicate how to improve the use of the API. Applying our approach on 10 Java systems revealed over 400 actual cases of potentially suboptimal API usage, leading to many improvements to the quality of the code we studied. Index Terms—API usage; code quality; code analysis; recommendation system I.