Pith. sign in

REVIEW 4 major objections 5 minor 52 references

EnseSmells: Deep ensemble and programming language models for automated code smells detection

T0 review · 4 major / 5 minor · reviewed 2026-08-08 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read EnseSmells claims that combining pre-trained code embeddings with software metrics improves code-smell detection beyond prior state of the art, with MCC gains of 5.98% to 28.26% on four common smells.

desk verdict Useful fusion architecture and solid empirical scope, but the reported superiority is undermined by unclear model-selection protocol, missing variance, and a loss-function typo. read the letter →

arxiv 2502.05012 v1 pith:SULTXECN submitted 2025-02-07 cs.SE

Anh Ho , Anh M. T. Bui , Phuong T. Nguyen , Amleto Di Salle , Bach Le This is my paper · ORCID
classification cs.SE
keywords codesmelldetectionsoftwaremetricspre-trainedmodelsdeepensembleimbalancedclassificationMLCQdatasetLongMethodFeatureEnvy
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Code smells are design flaws that do not crash a program but make it harder to understand and change. This paper tries to establish that detection improves when two very different views of a code snippet are combined: statistical semantics learned by pre-trained models for programming languages, and structural features from classic object-oriented software metrics. Its architecture, EnseSmells, runs each view through its own neural module and merges them before an imbalanced classifier. On the MLCQ benchmark, the paper reports that this fusion outperforms state-of-the-art baselines for Long Method, Feature Envy, Data Class, and God Class, with Matthews Correlation Coefficient improvements ranging from 5.98% to 28.26%. A sympathetic reading cares because prior deep-learning detectors treated code mostly as text, while metric-based detectors ignored learned context; this paper argues the two signal types are complementary.

What carries the argument

The central machinery is the ensemble itself: a statistical-semantic module that turns learned code embeddings into smell-specific feature vectors through a convolutional and bidirectional long short-term memory adapter, and a structural module that learns non-linear combinations of source-code metrics through a single adaptive-layer deep network. The two output vectors are concatenated and passed to an imbalanced deep classifier whose loss weights the minority (smelly) class by a sensitivity factor $\beta$. This design is what lets the paper attribute gains to the fusion: the semantic module alone is the earlier DeepSmells baseline, so adding the structural module isolates the contribution of design-related metrics.

What would settle it

A decisive check would rerun the same configuration search with a strict three-way split, choosing the best settings on validation data only and reporting test performance once, on held-out projects from the MLCQ dataset; if the fusion model no longer beats ML_CuBERT by the reported margins, the central claim is refuted.

Watch

Extended reading notes

Core claim

On the paper's own terms, the discovery is that a two-tier ensemble of code-representation features and metric features is a more powerful detector for four widely studied code smells than either feature family alone. The semantic tier encodes a snippet with one of several pre-trained models (token indexing, CodeBERT, CuBERT, or code2vec) and adapts the embedding with convolutional and bidirectional long short-term memory layers drawn from the earlier DeepSmells model; the structural tier feeds 44 class-level or 26 method-level metrics into a deep network with a single adaptive layer. Their concatenated output is classified by a deep network trained with a sensitivity-weighted binary cross-entropy loss to handle the severe class imbalance of smelly versus clean code. The paper reports that the full model beats the ML_CuBERT state of the art by 5.98% to 28.26% in MCC depending on the smell, and also surpasses the best autoencoder baselines and classical machine-learning classifiers trained on metrics alone.

Load-bearing premise

The load-bearing premise is that the per-smell hyperparameters (the sensitivity weight, kernel size, and classifier width) were selected on training and validation folds before the test set was used, so the reported margins over the baselines are honest estimates of generalization rather than optimistic in-sample tuning.

Editorial extensions

If this is right

  • If the reported gains hold, code-smell detectors should treat learned code representations and software metrics as complementary inputs rather than competing approaches.
  • The per-smell best embedding pattern (token indexing for Long Method and God Class, CuBERT for Feature Envy, code2vec for Data Class) gives practitioners a concrete way to choose an encoder for a given smell.
  • The structural module alone outperformed seven classical machine-learning classifiers on metrics, so a metrics-only deep network may be a strong fallback when code-embedding models are too expensive.
  • The sensitivity-weighted loss offers a direct lever for trading precision against recall on highly imbalanced smell data, which matters for real codebases where smelly snippets are rare.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Extending beyond the paper, the per-smell dependence on embedding choice suggests that a single global encoder may be the wrong unit of design; a future model could learn to route or weight multiple embeddings per smell rather than selecting one.
  • The paper reports random 80/20 splits; a natural stronger test is a project-level split of the MLCQ data, keeping all snippets from the same repository on one side. If the fusion gains shrink when the model must generalize to unseen projects, the practical claim would need qualification.
  • The authors do not test whether the reported benefits extend to other smells or languages; a direct extension would apply the same two-module design to additional design smells such as refused parent request or to Python code, where pre-trained embeddings and metric tools differ.
  • The hyperparameter search (loss weight, kernel size, classifier width) is reported per smell; a reader who wants to use the model should verify that those settings were chosen on validation folds before the test evaluation, because the size of the claimed improvement depends on it.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper proposes EnseSmells, a two-tier deep learning architecture for automated code smell detection that concatenates statistical semantic features extracted from pre-trained code embedding models (code2vec, CodeBERT, CuBERT, and a token-indexing baseline processed by the DeepSmells CNN/LSTM adapter) with structural features learned from object-oriented software metrics via a single adaptive-layer DNN, and classifies the fused representation with an imbalanced deep neural network. The evaluation on the MLCQ dataset covers Feature Envy, Long Method, Data Class, and God Class, and the paper claims state-of-the-art performance with improvements over baselines ranging from 5.98% to 28.26%, depending on the smell. The manuscript also reports a per-smell comparison of embedding choices and a comparison against seven classical machine learning classifiers.

Significance. If the reported evaluation is valid, the paper makes a useful empirical contribution to code smell detection by showing that combining structural metrics with learned code embeddings can improve detection, and by providing a systematic comparison of embedding models across four smell types. The authors re-ran all baselines on the same dataset and provide a public repository, which supports reproducibility. However, the paper's central claim of state-of-the-art performance is currently not established because the evaluation protocol as described does not separate model selection from test evaluation, the printed loss function is not a valid cross-entropy loss, and several textual claims are inconsistent with the reported tables.

major comments (4)
  1. [§3.2, Eq. (1)] Equation (1) is not a valid binary cross-entropy loss. As printed, L(x_i) = β ŷ_i log(y_i) + (1 − ŷ_i) log(1 − y_i) has no leading minus sign, so minimizing it drives predictions toward the incorrect label. If this objective was actually used in training, the reported results would be impossible; if the code contains the standard negative log-likelihood, the manuscript misstates the training objective. Please correct the equation and state explicitly which loss was optimized, including the role of β.
  2. [§4 and Tables 6–9] The paper does not describe any train/validation/test separation. Section 4 reports an 80/20 split followed by stratified 5-fold cross-validation, but Tables 6 and 7 present per-smell 'optimal configurations' (with tuned β, kernel size k, classifier width, and distinct winning embeddings per smell) without stating that these choices were made on validation folds before test metrics were observed. If the configuration with the best test performance was selected after evaluation, the reported margins, especially the small GC gains over AE-CNN (F1 +0.76 pp, MCC +1.18 pp), are subject to winner's-curse bias and do not support the claimed superiority. Please specify the exact model-selection procedure, or better, use nested cross-validation or a separate validation split, and report the selection policy for hyperparameters and embedding variants.
  3. [§5.1, RQ1 and Table 8] The claim of 'approximately 40%' improvement for Data Class is not supported by the tables. Comparing DeepSmells and EnseSmells under their optimal configurations in Table 8, the F1 gain for DC is from 0.5839 to 0.6393 (about 5.5 percentage points, 9.5% relative), and the largest F1 gain visible in Table 6 vs. Table 7 is for token-indexing (0.2531 to 0.6203, an absolute 36.7 pp change), not 40% in both F1 and MCC. Please re-state the improvement using a consistent and clearly defined comparison base and reconcile the abstract's '5.98% to 28.26%' claim with the specific metrics in Tables 8 and 9.
  4. [§5.4, Table 9] The comparison with baselines lacks any measure of variance or statistical significance. Tables 6–9 report single point estimates even though the evaluation uses 5-fold cross-validation, and the FE and GC margins are small (e.g., 0.76 pp F1 and 1.18 pp MCC for GC over AE-CNN). Without standard deviations, confidence intervals, or significance tests (e.g., paired bootstrap or a signed test across folds), the statement that EnseSmells 'demonstrates superior prediction performance for all four types' is stronger than the evidence warrants. Please report per-fold results or dispersion measures and perform a significance test for the differences that drive the conclusions.
minor comments (5)
  1. [§5.4, Table 9] The text says EnseSmells 'outperforms' all baselines on all metrics, but for Long Method its recall (0.7873) is lower than every baseline (AE-LSTM 0.8480, AE-CNN 0.8315, AE-Dense 0.8274, ML_CuBERT 0.8142). The claim should be restricted to F1 and MCC or the trade-off should be discussed.
  2. [§5.4, Table 8] The prose states that for Data Class EnseSmells improves F1 by 7.22% and MCC by 5.5%, but Table 8 shows F1 0.5839→0.6393 (+5.54 pp) and MCC 0.5185→0.5907 (+7.22 pp). The two percentages appear to be swapped.
  3. [§3.2, Eq. (1)] The notation in Eq. (1) is confusing: ŷ_i is used for the actual label and y_i for the model prediction, the opposite of the conventional convention. Please define all symbols and use standard notation for observed labels and predictions.
  4. [Abstract and throughout] There are several typographical and consistency issues, including 'with with' in the abstract and Section 7 stating 'five research questions' although only four RQs (RQ1–RQ4) are defined in Section 4.1.
  5. [Table 1] The metric 'CisibleFieldsQty' appears to be a typo for 'VisibleFieldsQty', and the table caption states there are 44 class-level metrics but only 40 entries are listed; please verify the count and the Appendix.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: EnseSmells is an empirical fitting and evaluation study whose reported improvements are measured test-set comparisons, not quantities derived from its inputs by construction.

full rationale

EnseSmells is an empirical model-fitting and evaluation study. The central claims that adding the structural module improves detection and that EnseSmells outperforms baselines are supported by measured F1 and MCC values on the MLCQ dataset, not by a derivation that reduces to its inputs. The main self-citation, DeepSmells (Ho et al. 2023), serves as the semantic adapter and is also re-run and compared as a baseline in the same experimental protocol, so it is not a load-bearing circular citation. The paper never claims a uniqueness theorem or imports a forced choice from prior work. The possible concern that per-smell 'optimal configurations' in Tables 6-9 were selected after seeing test performance would be an evaluation-bias or winner's-curse issue rather than a definitional circularity, and the text does not state that test labels were used for selection. The missing minus sign in Eq. (1) is a correctness issue, not a circularity. No specific step can be quoted that reduces a prediction to a fit or to a self-citation chain.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

The central claim rests on the reliability of MLCQ labels, the sufficiency of the selected metrics, the validity of embedding aggregation, and the unspecified adaptive layer. These are domain assumptions rather than independently verified facts.

free parameters (3)
  • beta (sensitivity weight in loss) = one of 2, 4, 8, 12, 32, 84 (specific value per smell not reported)
    Tuned by comparing performance; the selected value is not reported per experiment, making reproduction difficult.
  • kernel size k in first conv block = one of 3,4,5,6,7 (selected value not reported)
    Tuned for each embedding and smell; actual choice not reported.
  • number of hidden nodes in classifier = not reported
    Paper only says 'determined empirically'.
assumptions (4)
  • domain assumption MLCQ majority-vote labels are accurate ground truth for the four code smells.
    Section 4.2: labels are assigned by majority vote across 26 developers, with ties removed; the paper acknowledges 'these labels may not be universally accepted' in Section 6.
  • domain assumption The CK tool metrics (44 class-level, 26 method-level) capture the design symptoms relevant to the four smells.
    Section 3.1.2: metrics are selected from prior work and used as structural features; no justification that this set is sufficient.
  • domain assumption Aggregated embeddings (sum or average of line/method vectors) preserve code-smell-relevant semantics.
    Section 3.1.1: CuBERT embeddings are summed over lines, code2vec class vectors are averages of method vectors; the paper relies on prior findings for this aggregation.
  • ad hoc to paper The 'single adaptive layer' can learn a useful mapping from metric vectors without additional tuning.
    Section 3.1.2: the paper introduces this component citing Xu et al. 2019, but provides no specification of how the number of hidden nodes is adjusted.

how reviews work

0 comments
Cite this review

Pith. "Pith review of EnseSmells: Deep ensemble and programming language models for automated code smells detection." pith.science (2026). https://pith.science/paper/SULTXECN

@misc{pith2026250205012,
  author       = {Pith},
  title        = {Pith review of: EnseSmells: Deep ensemble and programming language models for automated code smells detection},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/SULTXECN}},
  note         = {Machine review of arXiv:2502.05012}
}
read the original abstract

A smell in software source code denotes an indication of suboptimal design and implementation decisions, potentially hindering the code understanding and, in turn, raising the likelihood of being prone to changes and faults. Identifying these code issues at an early stage in the software development process can mitigate these problems and enhance the overall quality of the software. Current research primarily focuses on the utilization of deep learning-based models to investigate the contextual information concealed within source code instructions to detect code smells, with limited attention given to the importance of structural and design-related features. This paper proposes a novel approach to code smell detection, constructing a deep learning architecture that places importance on the fusion of structural features and statistical semantics derived from pre-trained models for programming languages. We further provide a thorough analysis of how different source code embedding models affect the detection performance with respect to different code smell types. Using four widely-used code smells from well-designed datasets, our empirical study shows that incorporating design-related features significantly improves detection accuracy, outperforming state-of-the-art methods on the MLCQ dataset with with improvements ranging from 5.98% to 28.26%, depending on the type of code smell.

Figures

Figures reproduced from arXiv: 2502.05012 by the authors.

Figure 1
Figure 1. The overall architecture of EnseSmells. As illustrated in [PITH_FULL_IMAGE:figures/full_fig_p008_1.png] view at source ↗
Figure 2
Figure 2. Performance of EnseSmells and DeepSmells across different embedding techniques. Starting with method-level smells, the use of code2vec in both EnseSmells and DeepSmells exhibits the lowest performance compared to other techniques. In contrast, token indexing emerges as a highly recommended choice due to its consistently superior performance. Notably, in this context, the consideration of CuBERT may be considered, gi… view at source ↗
Figure 3
Figure 3. Performance of EnseSmells and DeepSmells in various embedding techniques. Answer to RQ2. Each pre-trained programming language model possesses a distinct architec￾ture, suitable for addressing specific code smells. Specifically, token-indexing is effective for Long Method and God Class, CuBERT is appropriate for Feature Envy, and code2vec is well-suited for Data Class, showcasing the suitability of each model for di… view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

52 extracted references · 43 canonical work pages

  1. [1]

    U. Alon, M. Zilberstein, O. Levy, and E. Yahav. code2vec: Learning distributed representations of code. Proceedings of the ACM on Programming Languages, 3 0 (POPL): 0 1--29, 2019. doi:10.1145/3290353. URL https://doi.org/10.1145/3290353

    doi:10.1145/3290353 2019

  2. [2]

    a ntyl \

    F. Arcelli Fontana, M. V. M \"a ntyl \"a , M. Zanoni, and A. Marino. Comparing and experimenting machine learning techniques for code smell detection. Empirical Software Engineering, 21: 0 1143--1191, 2016. doi:10.1007/S10664-015-9378-4. URL https://doi.org/10.1007/s10664-015-9378-4

    work page doi:10.1007/s10664-015-9378-4 2016

  3. [3]

    Azadi, F

    U. Azadi, F. A. Fontana, and M. Zanoni. Machine learning based code smell detection through wekanose. In Proceedings of the 40th International Conference on Software Engineering: Companion Proceedings, ICSE 2018, Gothenburg, Sweden, May 27 - June 03, 2018 , pages 288--289. ACM , 2018. doi:10.1145/3183440.3194974. URL https://doi.org/10.1145/3183440.3194974

    work page arXiv 2018

  4. [4]

    M. I. Azeem, F. Palomba, L. Shi, and Q. Wang. Machine learning techniques for code smell detection: A systematic literature review and meta-analysis. Information and Software Technology, 108: 0 115--138, 2019. doi:10.1016/J.INFSOF.2018.12.009. URL https://doi.org/10.1016/j.infsof.2018.12.009

    doi:10.1016/j.infsof.2018.12.009 2019

  5. [5]

    D. A. Bennett. How can i deal with missing data in my study? Australian and New Zealand journal of public health, 25 0 (5): 0 464--469, 2001. doi:https://doi.org/10.1111/j.1467-842X.2001.tb00294.x. URL https://www.sciencedirect.com/science/article/pii/S1326020023036488

    work page doi:10.1111/j.1467-842x.2001.tb00294.x 2001

  6. [6]

    Compton, E

    R. Compton, E. Frank, P. Patros, and A. M. Y. Koay. Embedding java classes with code2vec: Improvements from variable obfuscation. In MSR '20: 17th International Conference on Mining Software Repositories, Seoul, Republic of Korea, 29-30 June, 2020 , pages 243--253. ACM , 2020. doi:10.1145/3379597.3387445. URL https://doi.org/10.1145/3379597.3387445

    work page arXiv 2020

  7. [7]

    Curtis, S

    B. Curtis, S. B. Sheppard, P. Milliman, M. A. Borst, and T. Love. Measuring the psychological complexity of software maintenance tasks with the halstead and mccabe metrics. IEEE Trans. Software Eng. , 5 0 (2): 0 96--104, 1979. doi:10.1109/TSE.1979.234165. URL https://doi.org/10.1109/TSE.1979.234165

    work page arXiv 1979

  8. [8]

    A. K. Das, S. Yadav, and S. Dhal. Detecting code smells using deep learning. In TENCON 2019-2019 IEEE Region 10 Conference (TENCON), pages 2081--2086. IEEE, 2019. doi:10.1109/TENCON.2019.8929628. URL https://doi.org/10.1109/TENCON.2019.8929628

    work page arXiv 2019

Show all 52 references
  1. [9]

    Devlin, M

    J. Devlin, M. Chang, K. Lee, and K. Toutanova. BERT: pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, N...

    2019 doi

  2. [10]

    Z. Feng, D. Guo, D. Tang, N. Duan, X. Feng, M. Gong, L. Shou, B. Qin, T. Liu, D. Jiang, and M. Zhou. Codebert: A pre-trained model for programming and natural languages. In Findings of the Association for Computational Linguistics: EMNLP 2020, Online Event, 16-20 November 2020...

    2020 doi

  3. [11]

    F. A. Fontana and M. Zanoni. Code smell severity classification using machine learning techniques. Knowledge-Based Systems, 128: 0 43--58, 2017. doi:10.1016/J.KNOSYS.2017.04.014. URL https://doi.org/10.1016/j.knosys.2017.04.014

    2017 doi

  4. [12]

    M. Fowler. Refactoring: Improving the Design of Existing Code. Addison-Wesley Longman Publishing Co., Inc., USA, 1999. ISBN 0201485672. URL http://martinfowler.com/books/refactoring.html

    1999

  5. [13]

    Garcia, D

    J. Garcia, D. Popescu, G. Edwards, and N. Medvidovic. Identifying architectural bad smells. In 13th European Conference on Software Maintenance and Reengineering, CSMR 2009, Architecture-Centric Maintenance of Large-SCale Software Systems, Kaiserslautern, Germany, 24-27 March ...

    2009 doi

  6. [14]

    Hadj - Kacem and N

    M. Hadj - Kacem and N. Bouassida. A hybrid approach to detect code smells using deep learning. In Proceedings of the 13th International Conference on Evaluation of Novel Approaches to Software Engineering, ENASE 2018, Funchal, Madeira, Portugal, March 23-24, 2018 , pages 137--...

    2018 doi

  7. [15]

    K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2016, Las Vegas, NV, USA, June 27-30, 2016 , pages 770--778. IEEE Computer Society, 2016. doi:10.1109/CVPR.2016.90. URL h...

    2016 doi

  8. [16]

    A. Ho, N. N. Hai, and B. T. M. Anh. Combining deep learning and kernel PCA for software defect prediction. In The 11th International Symposium on Information and Communication Technology, SoICT 2022, Hanoi, Vietnam, December 1-3, 2022, pages 360--367. ACM , 2022. doi:10.1145/3...

    2022

  9. [17]

    A. Ho, A. M. T. Bui, P. T. Nguyen, and A. Di Salle . Fusion of deep convolutional and LSTM recurrent neural networks for automated detection of code smells. In Proceedings of the 27th International Conference on Evaluation and Assessment in Software Engineering, EASE 2023, Oul...

    2023

  10. [18]

    Ioffe and C

    S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In F. R. Bach and D. M. Blei, editors, Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015 , volume...

    2015

  11. [19]

    Kamiya, S

    T. Kamiya, S. Kusumoto, and K. Inoue. Ccfinder: A multilinguistic token-based code clone detection system for large scale source code. IEEE Trans. Software Eng. , 28 0 (7): 0 654--670, 2002. doi:10.1109/TSE.2002.1019480. URL https://doi.org/10.1109/TSE.2002.1019480

    2002 arXiv

  12. [20]

    Kanade, P

    A. Kanade, P. Maniatis, G. Balakrishnan, and K. Shi. Learning and evaluating contextual embedding of source code. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event , volume 119 of Proceedings of Machine Learning ...

    2020

  13. [21]

    Khomh, S

    F. Khomh, S. Vaucher, Y. Gu \' e h \' e neuc, and H. A. Sahraoui. BDTEX: A gqm-based bayesian approach for the detection of antipatterns. J. Syst. Softw., 84 0 (4): 0 559--572, 2011. doi:10.1016/J.JSS.2010.11.921. URL https://doi.org/10.1016/j.jss.2010.11.921

    2011 doi

  14. [22]

    Kova c evi \'c , J

    A. Kova c evi \'c , J. Slivka, D. Vidakovi \'c , K.-G. Gruji \'c , N. Luburi \'c , S. Proki \'c , and G. Sladi \'c . Automatic detection of long method and god class code smells through neural source code embeddings. Expert Systems with Applications, 204: 0 117607, 2022. doi:1...

    2022

  15. [23]

    Lanza and R

    M. Lanza and R. Marinescu. Object-Oriented Metrics in Practice - Using Software Metrics to Characterize, Evaluate, and Improve the Design of Object-Oriented Systems. Springer, 2006. ISBN 978-3-540-24429-5. doi:10.1007/3-540-39538-5. URL https://doi.org/10.1007/3-540-39538-5

    2006 doi

  16. [24]

    H. Liu, Q. Liu, Z. Niu, and Y. Liu. Dynamic and automatic feedback-based threshold adaptation for code smell detection. IEEE Trans. Software Eng. , 42 0 (6): 0 544--558, 2016. doi:10.1109/TSE.2015.2503740. URL https://doi.org/10.1109/TSE.2015.2503740

    2016

  17. [25]

    H. Liu, J. Jin, Z. Xu, Y. Zou, Y. Bu, and L. Zhang. Deep learning based code smell detection. IEEE Trans. Software Eng. , 47 0 (9): 0 1811--1837, 2021. doi:10.1109/TSE.2019.2936376. URL https://doi.org/10.1109/TSE.2019.2936376

    2021

  18. [26]

    Y. Liu, M. Ott, N. Goyal, J. Du, M. Joshi, D. Chen, O. Levy, M. Lewis, L. Zettlemoyer, and V. Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019. URL http://arxiv.org/abs/1907.11692

    1907 arXiv

  19. [28]

    Macia, A

    I. Macia, A. Garcia, and A. von Staa. Defining and applying detection strategies for aspect-oriented code smells. In 2010 Brazilian Symposium on Software Engineering, pages 60--69. IEEE, 2010. doi:10.1109/SBES.2010.14. URL https://doi.org/10.1109/SBES.2010.14

    2010 doi

  20. [29]

    Madeyski and T

    L. Madeyski and T. Lewowski. MLCQ: industry-relevant code smell data set. In EASE '20: Evaluation and Assessment in Software Engineering, Trondheim, Norway, April 15-17, 2020 , pages 342--347. ACM , 2020. doi:10.1145/3383219.3383264. URL https://doi.org/10.1145/3383219.3383264

    2020

  21. [30]

    Madeyski and T

    L. Madeyski and T. Lewowski. Detecting code smells using industry-relevant data. Information and Software Technology, 155: 0 107112, 2023. doi:10.1016/J.INFSOF.2022.107112. URL https://doi.org/10.1016/j.infsof.2022.107112

    2023

  22. [31]

    Maiga, N

    A. Maiga, N. Ali, N. Bhattacharya, A. Sabane, Y. Gu \' e h \' e neuc, and E. A \" meur. SMURF: A svm-based incremental anti-pattern detection approach. In 19th Working Conference on Reverse Engineering, WCRE 2012, Kingston, ON, Canada, October 15-18, 2012 , pages 466--475. IEE...

    2012 doi

  23. [32]

    Maiga, N

    A. Maiga, N. Ali, N. Bhattacharya, A. Sabane, Y. Gu \' e h \' e neuc, G. Antoniol, and E. A \" meur. Support vector machines for anti-pattern detection. In IEEE/ACM International Conference on Automated Software Engineering, ASE'12, Essen, Germany, September 3-7, 2012 , pages ...

    2012

  24. [33]

    Marinescu

    R. Marinescu. Detection strategies: Metrics-based rules for detecting design flaws. In 20th International Conference on Software Maintenance (ICSM 2004), 11-17 September 2004, Chicago, IL, USA , pages 350--359. IEEE Computer Society, 2004. doi:10.1109/ICSM.2004.1357820. URL ht...

    2004 arXiv

  25. [34]

    Marinescu

    R. Marinescu. Measurement and quality in object-oriented design. In 21st IEEE International Conference on Software Maintenance (ICSM 2005), 25-30 September 2005, Budapest, Hungary , pages 701--704. IEEE Computer Society, 2005. doi:10.1109/ICSM.2005.63. URL https://doi.org/10.1...

    2005 doi

  26. [35]

    Marinescu, G

    R. Marinescu, G. Ganea, and I. Verebi. Incode: Continuous quality assessment and improvement. In 14th European Conference on Software Maintenance and Reengineering, CSMR 2010, 15-18 March 2010, Madrid, Spain , pages 274--275. IEEE Computer Society, 2010. doi:10.1109/CSMR.2010....

    2010 doi

  27. [36]

    T. J. McCabe. A complexity measure. IEEE Transactions on software Engineering, 0 (4): 0 308--320, 1976. doi:10.1109/TSE.1976.233837. URL https://doi.org/10.1109/TSE.1976.233837

    1976

  28. [37]

    Moha, Y.-G

    N. Moha, Y.-G. Gu \'e h \'e neuc, L. Duchien, and A.-F. Le Meur. Decor: A method for the specification and detection of code and design smells. IEEE Transactions on Software Engineering, 36 0 (1): 0 20--36, 2009. doi:10.1109/TSE.2009.50. URL https://doi.org/10.1109/TSE.2009.50

    2009 doi

  29. [38]

    bad smell

    M. J. Munro. Product metrics for automatic identification of "bad smell" design problems in java source-code. In 11th IEEE International Symposium on Software Metrics (METRICS 2005), 19-22 September 2005, Como Italy , page 15. IEEE Computer Society, 2005. doi:10.1109/METRICS.2...

    2005 doi

  30. [39]

    Nair and G

    V. Nair and G. E. Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th International Conference on Machine Learning (ICML-10), June 21-24, 2010, Haifa, Israel, pages 807--814. Omnipress, 2010. URL https://icml.cc/Conferences/2010/pap...

    2010

  31. [40]

    Nguyen, C

    H. Nguyen, C. Treude, and P. Thongtanunam. Encoding version history context for better code representation. In Proceedings of the 21st International Conference on Mining Software Repositories, pages 631--636, 2024

    2024

  32. [41]

    Sales, R

    V. Sales, R. Terra, L. F. Miranda, and M. T. Valente. Recommending move method refactorings using dependency sets. In 20th Working Conference on Reverse Engineering, WCRE 2013, Koblenz, Germany, October 14-17, 2013 , pages 232--241. IEEE Computer Society, 2013. doi:10.1109/WCR...

    2013

  33. [42]

    J. L. Schafer. Analysis of incomplete multivariate data. Chapman &Hall/CRC, 1997. URL https://doi.org/10.1201/9780367803025

    1997 doi

  34. [43]

    Sharma and D

    T. Sharma and D. Spinellis. A survey on software smells. Journal of Systems and Software, 138: 0 158--173, 2018. doi:10.1016/J.JSS.2017.12.034. URL https://doi.org/10.1016/j.jss.2017.12.034

    2018 doi

  35. [44]

    Sharma, P

    T. Sharma, P. Mishra, and R. Tiwari. Designite: a software design quality assessment tool. In Proceedings of the 1st International Workshop on Bringing Architectural Design Thinking into Developers' Daily Activities, BRIDGE@ICSE 2016, Austin, Texas, USA, May 17, 2016, pages 1-...

    2016

  36. [45]

    Sharma, V

    T. Sharma, V. Efstathiou, P. Louridas, and D. Spinellis. Code smell detection by deep direct-learning and transfer-learning. Journal of Systems and Software, 176: 0 110936, 2021. doi:https://doi.org/10.1016/j.jss.2021.110936. URL https://www.sciencedirect.com/science/article/p...

    2021

  37. [46]

    Sikstr \"o m and D

    S. Sikstr \"o m and D. Garcia. Statistical semantics. Methods and Applications, Cham: Springer, 2020. doi:10.1145/3664606

    2020 doi

  38. [48]

    Suryanarayana, G

    G. Suryanarayana, G. Samarthyam, and T. Sharma. Refactoring for software design smells: managing technical debt. Morgan Kaufmann, 2014. doi:https://doi.org/10.1016/j.asej.2017.03.002. URL https://www.sciencedirect.com/science/article/pii/S2090447917300412

    2014 doi

  39. [49]

    Van Rompaey, B

    B. Van Rompaey, B. Du Bois, S. Demeyer, and M. Rieger. On the detection of test smells: A metrics-based approach for general fixture and eager test. IEEE Transactions on Software Engineering, 33 0 (12): 0 800--817, 2007. doi:10.1109/TSE.2007.70745. URL https://doi.org/10.1109/...

    2007

  40. [50]

    S. A. Vidal, H. C. V \' a zquez, J. A. D. Pace, C. A. Marcos, A. F. Garcia, and W. N. Oizumi. Jspirit: a flexible tool for the analysis of code smells. In 34th International Conference of the Chilean Computer Science Society, SCCC 2015, Santiago, Chile, November 9-13, 2015 , p...

    2015

  41. [51]

    Von der Mosel, A

    J. Von der Mosel, A. Trautsch, and S. Herbold. On the validity of pre-trained transformers for natural language processing in the software engineering domain. IEEE Transactions on Software Engineering, 49 0 (4): 0 1487--1507, 2022. doi:10.1109/TSE.2022.3178469. URL https://doi...

    2022

  42. [52]

    Z. Xu, J. Liu, X. Luo, Z. Yang, Y. Zhang, P. Yuan, Y. Tang, and T. Zhang. Software defect prediction based on kernel pca and weighted extreme learning machine. Information and Software Technology, 106: 0 182--200, 2019. doi:10.1016/j.infsof.2018.10.004. URL https://doi.org/10....

    2019 doi

  43. [53]

    Zhang, T

    M. Zhang, T. Hall, and N. Baddoo. Code bad smells: a review of current knowledge. Journal of Software Maintenance and Evolution: research and practice, 23 0 (3): 0 179--202, 2011. doi:10.1002/SMR.521. URL https://doi.org/10.1002/smr.521

    2011 doi

  44. [54]

    Zhang, C

    Y. Zhang, C. Ge, S. Hong, R. Tian, C. Dong, and J. Liu. Delesmell: Code smell detection based on deep learning and latent semantic analysis. Knowledge-Based Systems, 255: 0 109737, 2022. doi:10.1016/J.KNOSYS.2022.109737. URL https://doi.org/10.1016/j.knosys.2022.109737

    2022

Pith tools

Reviewed August 8, 2026 · model on record in the stance chip above.