A Systematic Literature Review of Code Smell Detection Tools for JavaScript Systems
DOI:
https://doi.org/10.5753/reviews.2026.6187Keywords:
JavaScript Source Code, Code Smell Detection, Systematic Literature Review, Maintainability, Software designAbstract
JavaScript is one of the most popular programming languages. As projects grow, their code can become complex which leads to code smells, signs that can indicate problems. Many tools are available to detect and fix these issues, but we need a comprehensive summary of their most important features. This paper provides a systematic literature review of JavaScript code smell detection tools. We searched four databases (Scopus, ACM Digital Library, IEEE Xplore, and Springer) using a specific search string to find relevant studies. To refine the results, we applied a four-step selection process, reducing 1002 initial studies to 18 by removing duplicates, filtering metadata, and reviewing their full texts. We then used backward and forward snowballing to find more relevant studies, increasing the total number to 27 primary studies. Finally, we examined these studies to analyze the code smell detection tools they described. We identified 22 tools, many published in top software engineering venues, such as ICSE, MSR and TSE. We found that most tools use rule-based linting (55%), which is efficient but struggles with complex architectural smells. Dynamic analysis (23%) is underused and AI-driven detection is completely missing, despite its relevance in modern software engineering research. Researchers are also developing framework-specific tools for modern JavaScript practices and focusing on the detection of test smells (22%). Most tools available to practitioners detect only basic smells and ignore deeper design issues. Tool builders can address these gaps by combining static and dynamic analysis and creating more adaptable tools. For researchers, the lack of AI-driven detection and modern benchmark datasets presents an opportunity for progress.
Downloads
References
Abbes, M., Khomh, F., Gueheneuc, Y.-G., and Antoniol, G. (2011). An empirical study of the impact of two antipatterns, blob and spaghetti code, on program comprehension. In 2011 15Th European Conference on Software Maintenance and Reengineering (CSMR), pages 181-190. IEEE, IEEE Computer Society. DOI: 10.1109/CSMR.2011.24.
Aghajani, E., Nagy, C., Linares-Vásquez, M., Moreno, L., Bavota, G., Lanza, M., and Shepherd, D. C. (2020). Software documentation: the practitioners' perspective. In International Conference on Software Engineering (ICSE), pages 590-601. DOI: 10.1145/3377811.3380405.
Almashfi, N. and Lu, L. (2020). Code smell detection tool for java script programs. In 2020 5th International Conference on Computer and Communication Systems (ICCCS), pages 172-176. IEEE. DOI: 10.1109/ICCCS49078.2020.9118465.
AlOmar, E. A., Venkatakrishnan, A., Mkaouer, M. W., Newman, C., and Ouni, A. (2024). How to refactor this code? an exploratory study on developer-chatgpt refactoring conversations. In Proceedings of the 21st International Conference on Mining Software Repositories (MSR), pages 202-206. DOI: 10.1145/3643991.3645081.
Amaral, G., Gomes, H., Figueiredo, E., Bezerra, C., and Rocha, L. (2025). Improving javascript test quality with large language models: Lessons from test smell refactoring. In Brazilian Symposium on Software Engineering (SBES), pages 776-782. SBC. DOI: 10.5753/sbes.2025.11568.
Amorim, L., Costa, I., Alves, L., and Figueiredo, E. (2025). Bad smell detection using google gemini. In Proceedings of the IEEE International Workshop on Advances in Artificial Intelligence and Machine Learning (AIML). DOI: 10.1109/compsac65507.2025.00221.
Andreasen, E., Gong, L., Møller, A., Pradel, M., Selakovic, M., Sen, K., and Staicu, C.-A. (2017). A survey of dynamic analysis and test generation for javascript. ACM Computing Surveys (CSUR), 50(5):1-36. DOI: 10.1145/3106739.
Arcelli Fontana, F., Mäntylä, M. V., Zanoni, M., and Marino, A. (2016). Comparing and experimenting machine learning techniques for code smell detection. Empirical Software Engineering (EMSE), 21:1143-1191. DOI: 10.1007/s10664-015-9378-4.
Azeem, M. I., Palomba, F., Shi, L., and Wang, Q. (2019). Machine learning techniques for code smell detection: A systematic literature review and meta-analysis. Information and Software Technology (IST), 108:115-138. DOI: 10.1016/j.infsof.2018.12.009.
Barros, A. and Adachi, E. (2021). Bad smells in JavaScript: A mapping study. In Proceedings of the 9th Workshop on Software Visualization, Evolution, and Maintenance (VEM), pages 1-5. SBC. DOI: 10.5753/vem.2021.17208.
Basili, V. and Rombach, H. (1988). The TAME project: Towards improvement-oriented software environments. IEEE Transactions on Software Engineering (TSE), 14(6):758-773. DOI: 10.1109/32.6156.
Bogner, J. and Merkel, M. (2022). To type or not to type? a systematic comparison of the software quality of javascript and typescript applications on github. In Proceedings of the 19th International Conference on Mining Software Repositories (MSR), pages 658-669. DOI: 10.1145/3524842.3528454.
Campos, U. F., Smethurst, G., Moraes, J. P., Bonifácio, R., and Pinto, G. (2019). Mining rule violations in javascript code snippets. In 2019 IEEE/ACM 16th International Conference on Mining Software Repositories (MSR), pages 195-199. IEEE. DOI: 10.1109/msr.2019.00039.
Di Nucci, D., Palomba, F., Tamburri, D. A., Serebrenik, A., and De Lucia, A. (2018). Detecting code smells using machine learning techniques: Are we there yet? In 2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER), pages 612-621. IEEE. DOI: 10.1109/saner.2018.8330266.
Du, X., Liu, M., Wang, K., Wang, H., Liu, J., Chen, Y., Feng, J., Sha, C., Peng, X., and Lou, Y. (2024). Evaluating large language models in class-level code generation. In International Conference on Software Engineering (ICSE), pages 1-13. DOI: 10.1145/3597503.3639219.
Fan, L., Liu, J., Liu, Z., Lo, D., Xia, X., and Li, S. (2025). Exploring the capabilities of llms for code-change-related tasks. ACM Transactions on Software Engineering and Methodology (TOSEM), 34(6):1-36. DOI: 10.1145/3709358.
Fard, A. M. and Mesbah, A. (2013). Jsnose: Detecting javascript code smells. In 2013 IEEE 13th International Working Conference on Source Code Analysis and Manipulation (SCAM), pages 116-125. IEEE. DOI: 10.1109/SCAM.2013.6648192.
Fernandes, E., Oliveira, J., Vale, G., Paiva, T., and Figueiredo, E. (2016). A review-based comparative study of bad smell detection tools. In Proceedings of the 20th International Conference on Evaluation and Assessment in Software Engineering (EASE), pages 18:1-18:12. Association for Computing Machinery. DOI: 10.1145/2915970.2915984.
Ferreira, F. and Valente, M. T. (2023). Detecting code smells in react-based web apps. Information and Software Technology (IST), 155:107111. DOI: 10.1016/j.infsof.2022.107111.
Fokaefs, M., Tsantalis, N., Stroulia, E., and Chatzigeorgiou, A. (2011). Jdeodorant: identification and application of extract class refactorings. In Proceedings of the 33rd International Conference on Software Engineering (ICSE), pages 1037-1039. DOI: 10.1145/1985793.1985989.
Fowler, M. (1999). Refactoring: improving the design of existing code. DOI: 10.1007/3-540-45672-4_31.
Fulcini, T., Garaccione, G., Coppola, R., Ardito, L., and Torchiano, M. (2022). Guidelines for gui testing maintenance: a linter for test smell detection. In Proceedings of the 13th International Workshop on Automating Test Case Design, Selection and Evaluation (A-TEST), pages 17-24. DOI: 10.1145/3548659.3561306.
Gallaba, K., Hanam, Q., Mesbah, A., and Beschastnikh, I. (2017). Refactoring asynchrony in javascript. In IEEE International Conference on Software Maintenance and Evolution (ICSME), pages 353-363. DOI: 10.1109/icsme.2017.83.
Gesi, J., Shen, X., Geng, Y., Chen, Q., and Ahmed, I. (2023). Leveraging feature bias for scalable misprediction explanation of machine learning models. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE), pages 1559-1570. IEEE. DOI: 10.1109/icse48619.2023.00135.
Ghaleb, T., Abduljalil, O., and Hassan, S. (2024). Ci/cd configuration practices in open-source android apps: An empirical study. ACM Transactions on Software Engineering and Methodology (TOSEM). DOI: 10.1145/3736758.
Gong, L., Pradel, M., Sridharan, M., and Sen, K. (2015). Dlint: Dynamically checking bad coding practices in javascript. In Proceedings of the 2015 International Symposium on Software Testing and Analysis (ISSTA). DOI: 10.1145/2771783.2771809.
Guarnieri, S. (2010). {GULFSTREAM}: Staged static analysis for streaming {JavaScript} applications. In USENIX Conference on Web Application Development (WebApps). Available at:[link].
Gyimesi, P., Vancsics, B., Stocco, A., Mazinanian, D., Beszédes, A., Ferenc, R., and Mesbah, A. (2019). Bugsjs: a benchmark of javascript bugs. In 2019 12th IEEE Conference on Software Testing, Validation and Verification (ICST), pages 90-101. IEEE. DOI: 10.1109/icst.2019.00019.
Han, X., Tahir, A., Liang, P., Counsell, S., Blincoe, K., Li, B., and Luo, Y. (2022). Code smells detection via modern code review: A study of the openstack and qt communities. Empirical Software Engineering, 27(6):127. DOI: 10.1007/s10664-022-10178-7.
Heričko, T. and Šumak, B. (2022). Analyzing linter usage and warnings through mining software repositories: A longitudinal case study of javascript packages. In 2022 45th Jubilee International Convention on Information, Communication and Electronic Technology (MIPRO), pages 1375-1380. IEEE. DOI: 10.23919/mipro55190.2022.9803554.
Hou, X., Zhao, Y., Liu, Y., Yang, Z., Wang, K., Li, L., Luo, X., Lo, D., Grundy, J., and Wang, H. (2024). Large language models for software engineering: A systematic literature review. Transactions on Software Engineering and Methodology (TOSEM), 33(8):1-79. DOI: 10.1145/3695988.
Hozano, M., Garcia, A., Fonseca, B., and Costa, E. (2018). Are you smelling it? investigating how similar developers detect code smells. Information and Software Technology (IST), 93:130-146. DOI: 10.1016/j.infsof.2017.09.002.
Jensen, S. H., Madsen, M., and Møller, A. (2011). Modeling the html dom and browser api in static analysis of javascript web applications. In 19th ACM SIGSOFT Symposium on Foundations of Software Engineering (FSE), page 59–69. DOI: 10.1145/2025113.2025125.
Jia, X. and Dittmer, H. (2017). Anomaly detection in dynamic programming languages through heuristics based type inference. In 2017 Computing Conference, pages 286-293. IEEE. DOI: 10.1109/sai.2017.8252116.
Johannes, D., Khomh, F., and Antoniol, G. (2019). A large-scale empirical study of code smells in javascript projects. Software Quality Journal (SQJ), 27:1271-1314. DOI: 10.1007/s11219-019-09442-9.
Jorge, D., Machado, P., and Andrade, W. (2021). Investigating test smells in javascript test code. In Proceedings of the 6th Brazilian Symposium on Systematic and Automated Software Testing (SAST), pages 36-45. DOI: 10.1145/3482909.3482915.
Khanve, V. (2019). Are existing code smells relevant in web games? an empirical study. In the 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE), pages 1241-1243. DOI: 10.1145/3338906.3342504.
Kitchenham, B. and Charters, S. (2007). Guidelines for performing systematic literature reviews in software engineering. Technical Report EBSE-2007-01, Keele University and University of Durham. Available at:[link].
Lanza, M. and Marinescu, R. (2007). Object-oriented metrics in practice: using software metrics to characterize, evaluate, and improve the design of object-oriented systems. DOI: 10.1007/3-540-39538-5.
Liu, Y. (2019). Jsoptimizer: an extensible framework for javascript program optimization. In 2019 IEEE/ACM 41st International Conference on Software Engineering: Companion Proceedings (ICSE-Companion), pages 168-170. IEEE. DOI: 10.1109/icse-companion.2019.00069.
Lopes, M. and Hora, A. (2022). How and why we end up with complex methods: a multi-language study. Empirical Software Engineering (EMSE), 27(5):115. DOI: 10.1007/s10664-022-10144-3.
Lu, J., Yu, L., Li, X., Yang, L., and Zuo, C. (2023). Llama-reviewer: Advancing code review automation with large language models through parameter-efficient fine-tuning. In 2023 IEEE 34th International Symposium on Software Reliability Engineering (ISSRE), pages 647-658. IEEE. DOI: 10.1109/issre59848.2023.00026.
Marinescu, R. (2004). Detection strategies: Metrics-based rules for detecting design flaws. In 2004 20th IEEE International Conference on Software Maintenance (ICSME), pages 350-359. IEEE. DOI: 10.1109/ICSM.2004.1357820.
Mitropoulos, D., Louridas, P., Salis, V., and Spinellis, D. (2019). Time present and time past: analyzing the evolution of javascript code in the wild. In 2019 IEEE/ACM 16th International Conference on Mining Software Repositories (MSR), pages 126-137. IEEE. DOI: 10.1109/msr.2019.00029.
Moreira, R., Fernandes, E., and Figueiredo, E. (2022). Review-based comparison of design pattern detection tools. In Proceedings of the 29th International Conference on Pattern Languages of Programs (PLoP), pages 17:1-17:16. The Hillside Group. DOI: https://dl.acm.org/10.5555/3631672.3631693.
Nam, D., Macvean, A., Hellendoorn, V., Vasilescu, B., and Myers, B. (2024). Using an llm to help with code understanding. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering (ICSE), pages 1-13. DOI: 10.1145/3597503.3639187.
Nunes, H., Figueiredo, E., Rocha, L., Nadi, S., Ferreira, F., and Esteves, G. (2025). Evaluating the effectiveness of llms in fixing maintainability issues in real-world projects. In 2025 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), pages 669-680. IEEE. DOI: 10.1109/saner64311.2025.00069.
Ocariza, F. S., Pattabiraman, K., and Mesbah, A. (2017). Detecting unknown inconsistencies in web applications. In 2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE), pages 566-577. IEEE. DOI: 10.1109/ase.2017.8115667.
Oliveira, F. L. and Mattos, J. C. (2022). Jsguide: A tool to improve javascript algorithms focusing on iot devices. In 2022 Symposium on Internet of Things (SIoT), pages 1-4. IEEE. DOI: 10.1109/siot56383.2022.10070155.
Paltoglou, A., Zafeiris, V. E., Giakoumakis, E. A., and Diamantidis, N. (2018). Automated refactoring of client-side javascript code to es6 modules. In 2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER), pages 402-412. IEEE. DOI: 10.1109/SANER.2018.8330227.
Paltoglou, K., Zafeiris, V. E., Diamantidis, N., and Giakoumakis, E. A. (2021). Automated refactoring of legacy javascript code to es6 modules. Journal of Systems and Software (JSS), 181:111049. DOI: 10.1016/j.jss.2021.111049.
Park, C. and Kim, R. Y. C. (2023). Detecting common weakness enumeration through training the core building blocks of similar languages based on the codebert model. In 2023 30th Asia-Pacific Software Engineering Conference (APSEC), pages 641-642. IEEE. DOI: 10.1109/apsec60848.2023.00088.
Park, J., Lim, I., and Ryu, S. (2016). Battles with false positives in static analysis of javascript web applications in the wild. In Proceedings of the 38th International Conference on Software Engineering Companion (ICSE-Companion), pages 61-70. DOI: 10.1145/2889160.2889227.
Pereira dos Reis, J., Brito e Abreu, F., de Figueiredo Carneiro, G., and Anslow, C. (2022). Code smells detection and visualization: a systematic literature review. Archives of Computational Methods in Engineering, 29(1):47-94. DOI: 10.1007/s11831-021-09566-x.
Pornprasit, C. and Tantithamthavorn, C. (2024). Fine-tuning and prompt engineering for large language models-based code review automation. Information and Software Technology (IST), 175:107523. DOI: 10.1016/j.infsof.2024.107523.
Rasool, G. and Arshad, Z. (2015). A review of code smell mining techniques. Journal of Software: Evolution and Process, 27(11):867-895. DOI: 10.1002/smr.1737.
Rastogi, A., Swamy, N., Fournet, C., Bierman, G., and Vekris, P. (2015). Safe & efficient gradual typing for typescript. In Proceedings of the 42Nd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL), pages 167-180. DOI: 10.1145/2676726.2676971.
Rio, A., Abreu, F. B. e., and Mendes, D. (2024). Causal inference of server-and client-side code smells in web apps evolution. Empirical Software Engineering (EMSE), 29(5):133. DOI: 10.1007/s10664-024-10478-0.
Rostami Mazrae, P., Mens, T., Golzadeh, M., and Decan, A. (2023). On the usage, co-usage and migration of ci/cd tools: A qualitative analysis. Empirical Software Engineering (EMSE), 28(2):52. DOI: 10.1007/s10664-022-10285-5.
Saboury, A., Musavi, P., Khomh, F., and Antoniol, G. (2017). An empirical study of code smells in javascript projects. In 2017 IEEE 24th International Conference on Software Analysis, Evolution and Reengineering (SANER), pages 294-305. IEEE. DOI: 10.1109/SANER.2017.7884630.
Santos, J. A. M., Rocha-Junior, J. B., Prates, L. C. L., Do Nascimento, R. S., Freitas, M. F., and De Mendonça, M. G. (2018). A systematic review on the code smell effect. Journal of Systems and Software (JSS), 144:450-477. DOI: 10.1016/j.jss.2018.07.035.
Scarsbrook, J. D., Utting, M., and Ko, R. K. (2023). Typescript’s evolution: An analysis of feature adoption over time. In 2023 IEEE/ACM 20th International Conference on Mining Software Repositories (MSR), pages 109-114. IEEE. DOI: 10.1109/msr59073.2023.00027.
Schumacher, J., Zazworka, N., Shull, F., Seaman, C., and Shaw, M. (2010). Building empirical support for automated code smell detection. In ACM-IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM), pages 1-10. DOI: 10.1145/1852786.1852797.
Sharma, T., Efstathiou, V., Louridas, P., and Spinellis, D. (2021). Code smell detection by deep direct-learning and transfer-learning. Journal of Systems and Software (JSS), 176:110936. DOI: 10.1016/j.jss.2021.110936.
Shoenberger, I., Mkaouer, M. W., and Kessentini, M. (2017). On the use of smelly examples to detect code smells in javascript. In Applications of Evolutionary Computation: 20th European Conference, EvoApplications, pages 20-34. DOI: 10.1007/978-3-319-55792-2_2.
Silva, L. H., Valente, M. T., and Bergel, A. (2017). Refactoring legacy javascript code to use classes: The good, the bad and the ugly. In International Conference on Software Reuse (ICSR), pages 155-171. Springer. DOI: 10.1007/978-3-319-56856-0_11.
Tamburri, D. A., Palomba, F., Serebrenik, A., and Zaidman, A. (2019). Discovering community patterns in open-source: a systematic approach and its evaluation. Empirical Software Engineering (EMSE), 24:1369-1417. DOI: 10.1007/s10664-018-9659-9.
Tang, W., Tang, M., Ban, M., Zhao, Z., and Feng, M. (2023). Csgvd: A deep learning approach combining sequence and graph embedding for source code vulnerability detection. Journal of Systems and Software (JSS), 199:111623. DOI: 10.1016/j.jss.2023.111623.
Thomas, S. W., Nagappan, M., Blostein, D., and Hassan, A. E. (2013). The impact of classifier configuration and classifier combination on bug localization. IEEE Transactions on Software Engineering (TSE), 39(10):1427-1443. DOI: 10.1109/tse.2013.27.
Tómasdóttir, K. F., Aniche, M., and Van Deursen, A. (2017). Why and how javascript developers use linters. In 2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE), pages 578-589. IEEE. DOI: 10.1109/ase.2017.8115668.
Tómasdóttir, K. F., Aniche, M., and Van Deursen, A. (2018). The adoption of javascript linters in practice: A case study on eslint. IEEE Transactions on Software Engineering (TSE), 46(8):863-891. DOI: 10.1109/TSE.2018.2871058.
Tsantalis, N., Chaikalis, T., and Chatzigeorgiou, A. (2008). Jdeodorant: Identification and removal of type-checking bad smells. In 2008 12th European Conference on Software Maintenance and Reengineering (CSMR), pages 329-331. IEEE. DOI: 10.1109/csmr.2008.4493342.
Turcotte, A., Shah, M. D., Aldrich, M. W., and Tip, F. (2022). Drasync: identifying and visualizing anti-patterns in asynchronous javascript. In Proceedings of the 44th International Conference on Software Engineering (ICSE), pages 774-785. DOI: 10.1145/3510003.3510097.
Van Emden, E. and Moonen, L. (2002). Java quality assurance by detecting code smells. In Ninth Working Conference on Reverse Engineering (WCRE), pages 97-106. IEEE. DOI: 10.1109/WCRE.2002.1173068.
Vatanapakorn, N., Soomlek, C., and Seresangtakul, P. (2022). Python code smell detection using machine learning. In 2022 26th International Computer Science and Engineering Conference (ICSEC), pages 128-133. IEEE. DOI: 10.1109/icsec56337.2022.10049330.
Vayadande, K., Mukhopadhyay, K., Chaudhari, V., Manwadkar, S., Mutalik, T., and Gawali, I. (2023). Let us lint: A tool for code formatting and code enhancing. In 2023 14th International Conference on Computing Communication and Networking Technologies (ICCCNT), pages 1-8. IEEE. DOI: 10.1109/icccnt56998.2023.10306770.
Vidal, S., Vazquez, H., Diaz-Pace, J. A., Marcos, C., Garcia, A., and Oizumi, W. (2015). Jspirit: a flexible tool for the analysis of code smells. In 2015 34th International Conference of the Chilean Computer Science Society (SCCC), pages 1-6. IEEE. DOI: 10.1109/sccc.2015.7416572.
Vo, Q.-H., Dao, H., and Fukuda, K. (2025). Harnessing the power of llms for code smell detection in terraform infrastructure as code. In 2025 IEEE 49th Annual Computers, Software, and Applications Conference (COMPSAC), pages 533-542. IEEE. DOI: 10.1109/compsac65507.2025.00075.
Wang, W., Li, G., Ma, B., Xia, X., and Jin, Z. (2020). Detecting code clones with graph neural network and flow-augmented abstract syntax tree. In 2020 IEEE 27th International Conference on Software Analysis, Evolution and Reengineering (SANER), pages 261-271. IEEE. DOI: 10.1109/saner48275.2020.9054857.
Wei, S. and Ryder, B. G. (2013). Practical blended taint analysis for javascript. In Proceedings of the 2013 International Symposium on Software Testing and Analysis (ISSTA), page 336–346, New York, NY, USA. Association for Computing Machinery. DOI: 10.1145/2483760.2483788.
Wohlin, C. (2014). Guidelines for snowballing in systematic literature studies and a replication in software engineering. In Proceedings of the 18th International Conference on Evaluation and Assessment in Software Engineering (EASE), pages 1-10. DOI: 10.1145/2601248.2601268.
Wohlin, C., Runeson, P., Höst, M., Ohlsson, M., Regnell, B., and Wesslén, A. (2012). Experimentation in software engineering (ese). DOI: 10.1007/978-3-642-29044-2.
Wu, D., Mu, F., Shi, L., Guo, Z., Liu, K., Zhuang, W., Zhong, Y., and Zhang, L. (2024). ismell: Assembling llms with expert toolsets for code smell detection and refactoring. In Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering (ASE), pages 1345-1357. DOI: 10.1145/3691620.3695508.
Zakas, N. C. (2016). Understanding ECMAScript 6: the definitive guide for JavaScript developers. No Starch Press. Book.
Downloads
Published
How to Cite
Issue
Section
License
Copyright (c) 2026 Saymon Souza, Felipe Ribeiro, Eduardo Fernandes, Eduardo Figueiredo
This work is licensed under a Creative Commons Attribution 4.0 International License.
