57,807 research outputs found
Software systems through complex networks science: Review, analysis and applications
Complex software systems are among most sophisticated human-made systems, yet
only little is known about the actual structure of 'good' software. We here
study different software systems developed in Java from the perspective of
network science. The study reveals that network theory can provide a prominent
set of techniques for the exploratory analysis of large complex software
system. We further identify several applications in software engineering, and
propose different network-based quality indicators that address software
design, efficiency, reusability, vulnerability, controllability and other. We
also highlight various interesting findings, e.g., software systems are highly
vulnerable to processes like bug propagation, however, they are not easily
controllable
Community structure of complex software systems: Analysis and applications
Due to notable discoveries in the fast evolving field of complex networks,
recent research in software engineering has also focused on representing
software systems with networks. Previous work has observed that these networks
follow scale-free degree distributions and reveal small-world phenomena, while
we here explore another property commonly found in different complex networks,
i.e. community structure. We adopt class dependency networks, where nodes
represent software classes and edges represent dependencies among them, and
show that these networks reveal a significant community structure,
characterized by similar properties as observed in other complex networks.
However, although intuitive and anticipated by different phenomena, identified
communities do not exactly correspond to software packages. We empirically
confirm our observations on several networks constructed from Java and various
third party libraries, and propose different applications of community
detection to software engineering
Identification-method research for open-source software ecosystems
In recent years, open-source software (OSS) development has grown, with many developers around the world working on different OSS projects. A variety of open-source software ecosystems have emerged, for instance, GitHub, StackOverflow, and SourceForge. One of the most typical social-programming and code-hosting sites, GitHub, has amassed numerous open-source-software projects and developers in the same virtual collaboration platform. Since GitHub itself is a large open-source community, it hosts a collection of software projects that are developed together and coevolve. The great challenge here is how to identify the relationship between these projects, i.e., project relevance. Software-ecosystem identification is the basis of other studies in the ecosystem. Therefore, how to extract useful information in GitHub and identify software ecosystems is particularly important, and it is also a research area in symmetry. In this paper, a Topic-based Project Knowledge Metrics Framework (TPKMF) is proposed. By collecting the multisource dataset of an open-source ecosystem, project-relevance analysis of the open-source software is carried out on the basis of software-ecosystem identification. Then, we used our Spectral Clustering algorithm based on Core Project (CP-SC) to identify software-ecosystem projects and further identify software ecosystems. We verified that most software ecosystems usually contain a core software project, and most other projects are associated with it. Furthermore, we analyzed the characteristics of the ecosystem, and we also found that interactive information has greater impact on project relevance. Finally, we summarize the Topic-based Project Knowledge Metrics Framework
On the Effect of Semantically Enriched Context Models on Software Modularization
Many of the existing approaches for program comprehension rely on the
linguistic information found in source code, such as identifier names and
comments. Semantic clustering is one such technique for modularization of the
system that relies on the informal semantics of the program, encoded in the
vocabulary used in the source code. Treating the source code as a collection of
tokens loses the semantic information embedded within the identifiers. We try
to overcome this problem by introducing context models for source code
identifiers to obtain a semantic kernel, which can be used for both deriving
the topics that run through the system as well as their clustering. In the
first model, we abstract an identifier to its type representation and build on
this notion of context to construct contextual vector representation of the
source code. The second notion of context is defined based on the flow of data
between identifiers to represent a module as a dependency graph where the nodes
correspond to identifiers and the edges represent the data dependencies between
pairs of identifiers. We have applied our approach to 10 medium-sized open
source Java projects, and show that by introducing contexts for identifiers,
the quality of the modularization of the software systems is improved. Both of
the context models give results that are superior to the plain vector
representation of documents. In some cases, the authoritativeness of
decompositions is improved by 67%. Furthermore, a more detailed evaluation of
our approach on JEdit, an open source editor, demonstrates that inferred topics
through performing topic analysis on the contextual representations are more
meaningful compared to the plain representation of the documents. The proposed
approach in introducing a context model for source code identifiers paves the
way for building tools that support developers in program comprehension tasks
such as application and domain concept location, software modularization and
topic analysis
- …