3 research outputs found
A Quantitative Study of Java Software Buildability
Researchers, students and practitioners often encounter a situation when the
build process of a third-party software system fails. In this paper, we aim to
confirm this observation present mainly as anecdotal evidence so far. Using a
virtual environment simulating a programmer's one, we try to fully
automatically build target archives from the source code of over 7,200 open
source Java projects. We found that more than 38% of builds ended in failure.
Build log analysis reveals the largest portion of errors are
dependency-related. We also conduct an association study of factors affecting
build success
Are Multi-language Design Smells Fault-prone? An Empirical Study
Nowadays, modern applications are developed using components written in
different programming languages. These systems introduce several advantages.
However, as the number of languages increases, so does the challenges related
to the development and maintenance of these systems. In such situations,
developers may introduce design smells (i.e., anti-patterns and code smells)
which are symptoms of poor design and implementation choices. Design smells are
defined as poor design and coding choices that can negatively impact the
quality of a software program despite satisfying functional requirements.
Studies on mono-language systems suggest that the presence of design smells
affects code comprehension, thus making systems harder to maintain. However,
these studies target only mono-language systems and do not consider the
interaction between different programming languages. In this paper, we present
an approach to detect multi-language design smells in the context of JNI
systems. We then investigate the prevalence of those design smells.
Specifically, we detect 15 design smells in 98 releases of nine open-source JNI
projects. Our results show that the design smells are prevalent in the selected
projects and persist throughout the releases of the systems. We observe that in
the analyzed systems, 33.95% of the files involving communications between Java
and C/C++ contains occurrences of multi-language design smells. Some kinds of
smells are more prevalent than others, e.g., Unused Parameters, Too Much
Scattering, Unused Method Declaration. Our results suggest that files with
multi-language design smells can often be more associated with bugs than files
without these smells, and that specific smells are more correlated to
fault-proneness than others
Build System Issues in Multilanguage Software
Abstract—Building software from source is often viewed as a “solved problem ” by software engineers, as there are many mature, well-known tools and techniques. However, anecdotal evidence suggests that these tools often do not effectively address the complexities of building multilanguage software. To investigate this apparent problem, we have performed a qualitative study on a set of five multilanguage open source software packages. Surprisingly, we found build system problems that prevented us from building many of these packages out-of-thebox. Our key finding is that there are commonalities among build problems that can be systematically addressed. In this paper, we describe the results of this exploratory study, identify a set of common build patterns and anti-patterns, and outline research directions for improving the build process. One such finding is that multilanguage packages avoid certain build problems by supporting compilation-free extension. As well, we find evidence that concerns from the application and implementation domains may “leak ” into the build model, with both positive and negative effects on the resulting build systems. Keywords—build systems, multilanguage software, programming languages I