44 research outputs found
A systematic review on sustainability assessment of internal combustion engines
Internal combustion engines (ICEs) have served as the primary powertrain for mobile sources since the 1890s and also recognized as significant contributors to CO2 emissions in the transportation sector. In order to achieve "carbon neutrality" for transportation sectors, ICE vehicles (ICEVs) are facing substantial challenges in meeting CO2 regulations and intense competition from battery electric vehicles and fuel cell vehicles. Consequently, new technologies of ICEs are continually emerging to enhance competitiveness in reducing environmental impacts. However, the limited studies on the life cycle assessment (LCA) of ICEs make it difficult to evaluate the actual contributions of the emerging technologies from a life cycle perspective. Conducting a systematic review of ICEs LCA studies could identify weaknesses and gaps in these studies for new scenarios. Therefore, this article presents the first systematic review of the LCA of ICEs to provide an overview of the current state of knowledge. A total of 87 life cycle assessment studies between 2017 and 2023 using the Scopus database were identified after searching for the keywords "Sustainability assessment" OR "Life cycle assessment" AND "Internal combustion engine*" OR "ICE*" and carefully screening, and then classified and analyzed by six aspects including sustainability indicators, life cycle phases, life cycle inventories, ICE technologies (including alternative fuels), types of mobile sources and powertrain systems. It is concluded that there are quite limited studies solely focusing on LCA of ICEs, and the LCA assessment lacks consideration of: 1. environmental pollution, human health and socio-economic aspects, 2. fuel production process and maintenance & repair phase, 3. small and developing countries, 4. the emerging ICE technologies and zero carbon/carbon-neutral fuels, 5. large and high-power mobile sources and heavy-duty hybrid technologies
App Review Driven Collaborative Bug Finding
Software development teams generally welcome any effort to expose bugs in
their code base. In this work, we build on the hypothesis that mobile apps from
the same category (e.g., two web browser apps) may be affected by similar bugs
in their evolution process. It is therefore possible to transfer the experience
of one historical app to quickly find bugs in its new counterparts. This has
been referred to as collaborative bug finding in the literature. Our novelty is
that we guide the bug finding process by considering that existing bugs have
been hinted within app reviews. Concretely, we design the BugRMSys approach to
recommend bug reports for a target app by matching historical bug reports from
apps in the same category with user app reviews of the target app. We
experimentally show that this approach enables us to quickly expose and report
dozens of bugs for targeted apps such as Brave (web browser app). BugRMSys's
implementation relies on DistilBERT to produce natural language text
embeddings. Our pipeline considers similarities between bug reports and app
reviews to identify relevant bugs. We then focus on the app review as well as
potential reproduction steps in the historical bug report (from a same-category
app) to reproduce the bugs.
Overall, after applying BugRMSys to six popular apps, we were able to
identify, reproduce and report 20 new bugs: among these, 9 reports have been
already triaged, 6 were confirmed, and 4 have been fixed by official
development teams, respectively
Evaluating Representation Learning of Code Changes for Predicting Patch Correctness in Program Repair
A large body of the literature of automated program repair develops
approaches where patches are generated to be validated against an oracle (e.g.,
a test suite). Because such an oracle can be imperfect, the generated patches,
although validated by the oracle, may actually be incorrect. While the state of
the art explore research directions that require dynamic information or rely on
manually-crafted heuristics, we study the benefit of learning code
representations to learn deep features that may encode the properties of patch
correctness. Our work mainly investigates different representation learning
approaches for code changes to derive embeddings that are amenable to
similarity computations. We report on findings based on embeddings produced by
pre-trained and re-trained neural networks. Experimental results demonstrate
the potential of embeddings to empower learning algorithms in reasoning about
patch correctness: a machine learning predictor with BERT transformer-based
embeddings associated with logistic regression yielded an AUC value of about
0.8 in predicting patch correctness on a deduplicated dataset of 1000 labeled
patches. Our study shows that learned representations can lead to reasonable
performance when comparing against the state-of-the-art, PATCH-SIM, which
relies on dynamic information. These representations may further be
complementary to features that were carefully (manually) engineered in the
literature
Evaluating Representation Learning of Code Changes for Predicting Patch Correctness in Program Repair
A large body of the literature of automated program repair develops approaches where patches are generated to be validated against an oracle (e.g., a test suite). Because such an oracle can be imperfect, the generated patches, although validated by the oracle, may actually be incorrect. While the state of the art explore research directions that require dynamic information or rely on manually-crafted heuristics, we study the benefit of learning code representations to learn deep features that may encode the properties of patch correctness. Our work mainly investigates different representation learning approaches for code changes to derive embeddings that are amenable to similarity computations. We report on findings based on embeddings produced by pre-trained and re-trained neural networks. Experimental results demonstrate the potential of embeddings to empower learning algorithms in reasoning about patch correctness: a machine learning predictor with BERT transformer-based embeddings..
Predicting Patch Correctness Based on the Similarity of Failing Test Cases
Towards predicting patch correctness in APR, we propose a simple, but novel
hypothesis on how the link between the patch behaviour and failing test
specifications can be drawn: similar failing test cases should require similar
patches. We then propose BATS, an unsupervised learning-based system to predict
patch correctness by checking patch Behaviour Against failing Test
Specification. BATS exploits deep representation learning models for code and
patches: for a given failing test case, the yielded embedding is used to
compute similarity metrics in the search for historical similar test cases in
order to identify the associated applied patches, which are then used as a
proxy for assessing generated patch correctness. Experimentally, we first
validate our hypothesis by assessing whether ground-truth developer patches
cluster together in the same way that their associated failing test cases are
clustered. Then, after collecting a large dataset of 1278 plausible patches
(written by developers or generated by some 32 APR tools), we use BATS to
predict correctness: BATS achieves an AUC between 0.557 to 0.718 and a recall
between 0.562 and 0.854 in identifying correct patches. Compared against
previous work, we demonstrate that our approach outperforms state-of-the-art
performance in patch correctness prediction, without the need for large labeled
patch datasets in contrast with prior machine learning-based approaches. While
BATS is constrained by the availability of similar test cases, we show that it
can still be complementary to existing approaches: used in conjunction with a
recent approach implementing supervised learning, BATS improves the overall
recall in detecting correct patches. We finally show that BATS can be
complementary to the state-of-the-art PATCH-SIM dynamic approach of identifying
the correct patches for APR tools
Where were the repair ingredients for Defects4j bugs?
A significant body of automated program repair research has built approaches under the redundancy assumption. Patches are then heuristically generated by leveraging repair ingredients (change actions and donor code) that are found in code bases (either the buggy program itself or big code). For example, common change actions (i.e., fix patterns) are frequently mined offline and serve as an important ingredient for many patch generation engines. Although the repetitiveness of code changes has been studied in general, the literature provides little insight into the relationship between the performance of the repair system and the source code base where the change actions were mined. Similarly, donor code is another important repair ingredient to concretize patches guided by abstract patterns. Yet, little attention has been paid to where such ingredients can actually be found. Through a large scale empirical study on the execution results of 24 repair systems evaluated on realworld bugs from Defects4J, we provide a comprehensive view on the distribution of repair
ingredients that are relevant for these bugs. In particular, we show that (1) a half of bugs cannot be fixed simply because the relevant repair ingredient is not available in the search space of donor code; (2) bugs that are correctly fixed by literature tools are mostly addressed with shallow change actions; (3) programs with little history of changes can benefit from mining change actions in other programs; (4) parts of donor code to repair a given bug can be found separately at different search locations; (5) bug-triggering test cases are a rich source for donor code search
The Best of Both Worlds: Combining Learned Embeddings with Engineered Features for Accurate Prediction of Correct Patches
A large body of the literature on automated program repair develops
approaches where patches are automatically generated to be validated against an
oracle (e.g., a test suite). Because such an oracle can be imperfect, the
generated patches, although validated by the oracle, may actually be incorrect.
Our empirical work investigates different representation learning approaches
for code changes to derive embeddings that are amenable to similarity
computations of patch correctness identification, and assess the possibility of
accurate classification of correct patch by combining learned embeddings with
engineered features. Experimental results demonstrate the potential of learned
embeddings to empower Leopard (a patch correctness predicting framework
implemented in this work) with learning algorithms in reasoning about patch
correctness: a machine learning predictor with BERT transformer-based learned
embeddings associated with XGBoost achieves an AUC value of about 0.895 in the
prediction of patch correctness on a new dataset of 2,147 labeled patches that
we collected for the experiments. Our investigations show that deep learned
embeddings can lead to complementary/better performance when comparing against
the state-of-the-art, PATCH-SIM, which relies on dynamic information. By
combining deep learned embeddings and engineered features, Panther (the
upgraded version of Leopard implemented in this work) outperforms Leopard with
higher scores in terms of AUC, +Recall and -Recall, and can accurately identify
more (in)correct patches that cannot be predicted by the classifiers only with
learned embeddings or engineered features. Finally, we use an explainable ML
technique, SHAP, to empirically interpret how the learned embeddings and
engineered features are contributed to the patch correctness prediction.Comment: arXiv admin note: substantial text overlap with arXiv:2008.0294