CoChat
Sign Up
Cited by 9Software Engineering ResearchLogic, programming, and type systemsSoftware Engineering Techniques and Practices

The DOI matches its Crossref record; the references it cites are not checked yet.

Evaluation of Rust code verbosity, understandability and complexity

Open access
Ardito, Luca, Barbato, Luca, Coppola, Riccardo, Valsesia, Michele·2021·PeerJ Computer Science
DOI 10.7717/peerj-cs.406PMC PMC7959618
Open this paper in CoChat — free account

Abstract

Rust is an innovative programming language initially implemented by Mozilla, developed to ensure high performance, reliability, and productivity. The final purpose of this study consists of applying a set of common static software metrics to programs written in Rust to assess the verbosity, understandability, organization, complexity, and maintainability of the language. To that extent, nine different implementations of algorithms available in different languages were selected. We computed a set of metrics for Rust, comparing them with the ones obtained from C and a set of object-oriented languages: C++, Python, JavaScript, TypeScript. To parse the software artifacts and compute the metrics, it was leveraged a tool called rust-code-analysis that was extended with a software module, written in Python, with the aim of uniforming and comparing the results. The Rust code had an average verbosity in terms of the raw size of the code. It exposed the most structured source organization in terms of the number of methods. Rust code had a better Cyclomatic Complexity, Halstead Metrics, and Maintainability Indexes than C and C++ but performed worse than the other considered object-oriented languages. Lastly, the Rust code exhibited the lowest COGNITIVE complexity of all languages. The collected measures prove that the Rust language has average complexity and maintainability compared to a set of popular languages. It is more easily maintainable and less complex than the C and C++ languages, which can be considered syntactically similar. These results, paired with the memory safety and safe concurrency characteristics of the language, can encourage wider adoption of the language of Rust in substitution of the C language in both the open-source and industrial environments.

Overview

The claims and statistics of this paper haven’t been checked yet.

Run the check — free, no account needed. It reads the open-access text and checks the sources it cites.

A few free checks a day · papers already verified open instantly · results are public

Integrity signals

Registry

Crossref · 10.7717/peerj-cs.406

Cites

Statistics

Figures

Figure 1 Representation of the data flow of the framework.
Figure 1 Representation of the data flow of the framework.CC BY · PubMed Central
Figure 2 Representation of the process stack of the framework.
Figure 2 Representation of the process stack of the framework.CC BY · PubMed Central
Listing 1 Sample output of the rust-code-analysis tool for the Rust version of the binarytrees algorithm.
Listing 1 Sample output of the rust-code-analysis tool for the Rust version of the binarytrees algorithm.CC BY · PubMed Central
Listing 2 Sample output of the analyzer.py script for the Rust version of the binarytrees algorithm.
Listing 2 Sample output of the analyzer.py script for the Rust version of the binarytrees algorithm.CC BY · PubMed Central
Listing 3 Sample output of the compare.py script for the C++/Rust comparisons of the binarytrees algorithm. The _old label identifies C++ metric values, while new the Rust ones.
Listing 3 Sample output of the compare.py script for the C++/Rust comparisons of the binarytrees algorithm. The _old label identifies C++ metric values, while new the Rust ones.CC BY · PubMed Central
Figure 3 Distribution of the metrics about lines of code for all the considered programming languages.
Figure 3 Distribution of the metrics about lines of code for all the considered programming languages.CC BY · PubMed Central
Figure 4 Distribution of the metrics about organization of code for all the considered programming languages.
Figure 4 Distribution of the metrics about organization of code for all the considered programming languages.CC BY · PubMed Central
Figure 5 Distribution of complexity metrics for all the considered programming languages.
Figure 5 Distribution of complexity metrics for all the considered programming languages.CC BY · PubMed Central
Figure 6 Distribution of Halstead metrics ((A) Bugs; (B) Difficulty; (C) Effort; (D) Length; (E) Time and (F) Volume) for all the considered programming languages.
Figure 6 Distribution of Halstead metrics ((A) Bugs; (B) Difficulty; (C) Effort; (D) Length; (E) Time and (F) Volume) for all the considered programming languages.CC BY · PubMed Central
Figure 7 Distribution of maintainability indexes ((A) Original; (B) SEI and (C) Visual Studio) for all the considered programming languages.
Figure 7 Distribution of maintainability indexes ((A) Original; (B) SEI and (C) Visual Studio) for all the considered programming languages.CC BY · PubMed Central

Verification

Claims the paper makes

The claims and statistics of this paper haven’t been checked yet.

Run the check — free, no account needed. It reads the open-access text and checks the sources it cites.

A few free checks a day · papers already verified open instantly · results are public

Self-check

Percentages, sums and reported differences re-computed from the paper’s own numbers.

The self-check needs the paper’s full text.

Citations

The citation lists haven’t been fetched yet

References 47 · Cited by 9

Research works printed but not linked: 18

  1. Amara, 2017, Towards a new framework of software reliability measurement based on software metrics, Procedia Computer Science, 109, 725, 10.1016/j.procs.2017.05.428 · DOI
  2. Ardito, 2020a, rust-code-analysis: a rust library to analyze and extract maintainability information from source codes, SoftwareX, 12, 100635, 10.1016/j.softx.2020.100635 · DOI
  3. Ardito, 2020b, A tool-based perspective on software code maintainability metrics: a systematic literature review, Scientific Programming, 2020, 8840389, 10.1155/2020/8840389 · DOI
  4. Astrauskas, 2019, Leveraging rust types for modular specification and verification, Proceedings of the ACM on Programming Languages, 3, 1, 10.1145/3360573 · DOI
  5. Ferreira, 2006, On the Benjamini–Hochberg method, Annals of Statistics, 34, 1827, 10.1214/009053606000000425 · DOI
  6. Frantz, 2019, Ranking open source application integration frameworks based on maintainability metrics: a review of five-year evolution, Software: Practice and Experience, 49, 1531, 10.1002/spe.2733 · DOI
  7. Gill, 1991, Cyclomatic complexity density and software maintenance productivity, IEEE Transactions on Software Engineering, 17, 1284, 10.1109/32.106988 · DOI
  8. Halstead, 1977, Elements of software science, 7
  9. Jingqiu, 2003, A new measure of software complexity based on cognitive weights, Canadian Journal of Electrical and Computer Engineering, 28, 69, 10.1109/CJECE.2003.1532511 · DOI
  10. Kaur, 2011, Determination of maintainability index for object oriented systems, ACM SIGSOFT Software Engineering Notes, 36, 1, 10.1145/1943371.1943383 · DOI
  11. Köster, 2016, Rust-bio: a fast and safe bioinformatics library, Bioinformatics, 32, 444, 10.1093/bioinformatics/btv573 · DOI
  12. Matsakis, 2014, The rust language, ACM SIGAda Ada Letters, 34, 103, 10.1145/2692956.2663188 · DOI
  13. Nguyen, 2007, A SLOC counting standard, Cocomo ii forum, 1
  14. Nuñez-Varela, 2017, Source code metrics: a systematic mapping study, Journal of Systems and Software, 128, 164, 10.1016/j.jss.2017.03.044 · DOI
  15. Robson, 2016, Real world research
  16. Saifan, 2018, Evaluating the understandability of android applications, International Journal of Software Innovation, 6, 44, 10.4018/IJSI.2018010104 · DOI
  17. Welker, 2001, The software maintainability index revisited, CrossTalk, 14, 18
  18. Zhou, 2007, Predicting object-oriented software maintainability using multivariate adaptive regression splines, Journal of systems and software, 80, 1349, 10.1016/j.jss.2006.10.049 · DOI

Metadata

Authors
Ardito, L., Barbato, L., Coppola, R., & Valsesia, M.
Affiliations
  • Politecnico di Torino (IT)
  • Luminem, Torino, Piemonte, Italia
Corresponding author
Ardito, Luca
ORCID
Venue
PeerJ Computer Science
Publisher
PeerJ
Published
2021-02-26
Volume
7
Pages
e406
ISSN
2376-5992 (ISSN-L)
DOI
10.7717/peerj-cs.406
PMC
PMC7959618
OpenAlex
W3134923652
Cited by
9
References
47
Citations by year
2026: 1 · 2025: 3 · 2024: 5
FWCI
1.04
Type
journal article
Language
en
Open access
Licence
Locations
  • PeerJ Computer Science (publishedVersion, cc-by)
  • PubMed Central (publishedVersion, cc-by)
  • PubMed (publishedVersion)
  • PORTO@Iris (submittedVersion, cc-by)
  • DOAJ (DOAJ: Directory of Open Access Journals) (submittedVersion, cc-by-sa)
Funders
Mozilla Research Fund (2018 H2)
Topics
  • Physical Sciences › Computer Science › Information Systems › Software Engineering Research
  • Physical Sciences › Computer Science › Software › Logic, programming, and type systems
  • Physical Sciences › Computer Science › Information Systems › Software Engineering Techniques and Practices
Keywords
Rust, code complexity, maintainability, cyclomatic complexity, Halstead metrics, maintainability index, cognitive complexity, algorithm implementation

About these checks

Registry, retraction, Cites and statistics results are computed, not judged, with one exception: a printed reference that no index lists is read once by a model before it counts as a citation error. Claims are extracted by a model and kept only when their quote appears verbatim in the text; each cited source is then checked, with a model’s help, for whether it says what the claim relies on. Those verdicts can be wrong — read the claim’s quote and the cited source before relying on one.

Statistics and arithmetic are recomputed, not judged.

Confidence bands are shown only for fields calibrated on our annotated test set. None is calibrated yet, so no band is shown.

What counts as a claim ›How we measure confidence ›How we check this ›

Are you an author, or do you see a problem with this page? Request a review

How to cite

Cite CoChat for the checks on this page, and the paper for its own findings.

This page
CoChat. (2026). Citation check: Evaluation of Rust code verbosity, understandability and complexity. https://app.cochat.ai/papers/10.7717/peerj-cs.406
The paper
Ardito, L., Barbato, L., Coppola, R., & Valsesia, M. (2021). Evaluation of Rust code verbosity, understandability and complexity. PeerJ Computer Science. https://doi.org/10.7717/peerj-cs.406