Code Smells and Development Efficiency in Native and Cross-Platform Mobile Applications: A Study of Java, Kotlin, and Flutter

1. Introduction

Mobile application development has advanced significantly from early platforms to modern eco-systems like Android and iOS. Initially, Java was the dominant language for Android development, offering robustness and versatility. The introduction of Kotlin by JetBrains marked a pivotal change. With its concise syntax, enhanced safety features, and seamless interoperability with Java, Kotlin quickly gained popularity and was endorsed by Google as a preferred language for Android development [1]. Additionally, Google’s Flutter framework has revolutionized mobile application development by enabling developers to write code once and deploy it across multiple platforms. Flutter supports fast development, expressive user interfaces (UIs), and native performance, making it a popular choice for creating visually appealing and responsive applications.

Choosing between native development and cross-platform frameworks is strategic, impacting application performance, maintainability, and user experience. Native development offers optimized performance and better access to device-specific features, ensuring high user satisfaction. However, cross-platform development tools like Flutter enable developers to share a single codebase across multiple platforms (Android, iOS, Web), significantly reducing development time and costs. Java and Kotlin have been long-standing choices for native Android development, with Java being the traditional standard and Kotlin emerging as a modern alternative [2]. Flutter, utilizing Dart, offers cross-platform capabilities, simplifying development and reducing maintenance costs [3].

While native development often results in applications that have slightly better performance due to being optimized for specific platforms, Flutter’s cross-platform nature offers an impressive balance. It provides close-to-native performance by compiling into native machine code using the Dart VM and an extensive library of widgets that mimic native UIs. Furthermore, Flutter’s ability to maintain a consistent look and feel across platforms without needing multiple codebases makes it a viable alternative for developers targeting multiple platforms with minimal overhead. The trade-offs in performance and device-specific feature access are compensated by the ease of maintaining a single codebase, faster iterations with the “hot reload” feature, and cost efficiency in long-term application maintenance.

Comparative analysis of Java, Kotlin, and Flutter reveals distinct advantages and challenges. Java and Kotlin excel in native development, with Kotlin offering modern features and improved safety. Flutter enables developers to create applications for multiple platforms with a single codebase [4]. This cross-platform approach is particularly valuable for businesses seeking faster time to market or those requiring consistent platform experiences.

Despite the critical role of mobile applications and the rapid evolution of development technologies, empirical research on the comparative analysis of mobile development approaches, particularly regarding code quality, is lacking. Few comprehensively evaluate how different programming languages and frameworks—like Java, Kotlin, and Flutter—affect code quality, maintainability, and long-term development efficiency. Current literature discusses the features and benefits of Kotlin and Flutter, noting their potential to streamline development and enhance code safety and maintainability. However, more systematic empirical studies are needed to quantify the impact of these modern languages and frameworks on code quality in real-world development scenarios.

Tools like SonarQube and Code Climate offer complementary capabilities to assess and compare code quality and maintainability metrics across different environments, but their practical application in comparative studies remains underexplored in academic research. Studies that use these tools to gather and analyze data are needed to provide insights into how Java, Kotlin, and Flutter influence the development process’s maintainability, scalability, and efficiency. In addition to SonarQube, the study utilized Code Climate to evaluate application maintainability. Based on a standardized 10-point inspection, Code Climate assesses key factors like code duplication, cyclomatic and cognitive complexity, and structural issues. Code Climate estimates the remediation time for each technical debt issue identified, which provides insights into the effort required to resolve such issues. This metric enables comparative analysis across projects, helping to spot problematic coding patterns. Files are rated from A to F based on their remediation times, and at the repository level, a technical debt ratio is calculated by comparing estimated remediation time to total implementation time. This ratio, which seeks to minimize the influence of project size on scores, serves as a critical measure for developers to gauge and enhance the health of their codebases over time.

This research aims to fill these gaps by analyzing mobile applications developed in Java, Kotlin, and Flutter, and evaluating various code quality metrics. The code metrics encompass the code smells and overall complexity, to determine the tangible impacts of choosing one technology over another. This study will provide empirical evidence to guide developers in selecting the most suitable programming language or framework for their projects based on quantifiable code quality and maintainability measures.

The study will compare the code quality of applications developed using Java, Kotlin, and Dart. Code quality and maintainability will be evaluated based on the prevalence of code smells, adherence to coding standards, the occurrence of bugs or issues during and after development, and the maintainability index generated by Code Climate. A robust methodology has been adopted, involving developing four applications using three distinct programming environments: Java, Kotlin, and Flutter. The subsequent analysis will employ SonarQube to assess metrics such as lines-of-code (LOC), code smells, and overall code quality. This method facilitates the collection of quantitative data on each language’s efficiency and maintainability and provides qualitative insights into the coding experience.

The insights from this research are expected to be valuable for developers and project managers, guiding the selection of development tools and practices based on empirical evidence. By delineating the strengths and weaknesses associated with Java, Kotlin, and Flutter, this study contributes to informed decision-making within the software development community. This knowledge is crucial for enhancing application quality and developer satisfaction, encouraging more efficient and effective development practices. The practical implications are significant, offering potential improvements in development processes, resource allocation, and project management in mobile application development.

This paper is organized as follows. Section 1 introduces the motivation for the study, identifies research gaps, and outlines the objectives. Section 2 presents a literature review, discussing theoretical frameworks and previous empirical studies relevant to mobile application development, focusing on Java, Kotlin, and Dart (Flutter). Section 3 details the methodologies employed, including the application development processes in each programming environment and the analytical tools used to evaluate code quality. Section 4 presents the results, providing a comparative analysis of code quality metrics across different programming environments. Section 5 interprets the results in the context of existing literature and discusses their implications for developers and the broader software development industry. Finally, Section 6 concludes the paper, summarizing the findings, discussing potential limitations, and offering recommendations for future research and practical applications in mobile application development.

2. Literature Review

The evolution of mobile application development, from early platforms to modern ecosystems like Android and iOS, has seen significant advancements. Initially, Java dominated Android development due to its portability and robust static typing, enhancing code reliability and maintainability. Java’s extensive standard library and platform independence allowed applications to run across diverse devices [5].

In 2011, JetBrains introduced Kotlin as a modern alternative to Java, offering concise syntax, null safety, and coroutines for asynchronous programming [6]. Its seamless Java interoperability and integration with Android Studio boosted developer productivity, leading to widespread adoption [7]. Kotlin’s design prioritizes readability and prevents code smells, improving maintainability [8].

Flutter, a versatile SDK developed by Google in 2017, enables high-performance cross-platform applications from a single codebase [9]. Using the Dart language and a reactive framework, Flutter provides consistent user experiences across platforms [10]. Its hot reload feature significantly reduces development time [11]. The transition from Java to Kotlin in Android development has been driven by Kotlin’s improved readability and maintainability, though challenges like migration and functional programming complexities remain [12].

Research shows that Kotlin’s rapid adoption is due to features like null safety and expressiveness, though interoperability with Java can introduce challenges, especially with legacy code [13]. Studies also emphasize managing technical debt and code smells with tools like SonarQube [14], though their effectiveness is sometimes limited [15]. Despite the importance of high-quality code, research by Corral and Fronza [16] suggests other factors like marketing and user experience play more significant roles in application success. In [17], the authors reveal that many code smells are introduced early, highlighting the need for advanced detection and refactoring tools [17]. Alkhaeir and Walter [18] show that code smells significantly increase defect likelihood in projects with design patterns, and manual code reviews remain crucial for identifying subtle issues [19].

Cross-platform tools like Flutter enhance maintainability and reduce code complexity, with studies showing significant code reduction and improved performance when transitioning from Java to Flutter [20]. A comparative analysis of Java, Kotlin, and Flutter reveals that each has distinct advantages, allowing developers to choose technologies based on project needs and team proficiency.

3. Methodology

This section outlines the methodology adopted to evaluate and compare the development efficiency and overall quality of mobile applications developed using Java, Kotlin, and Dart. The primary objective is to identify the language with the most code smells. To investigate the efficacy of Java, Kotlin, and Dart, identical mobile applications were developed using each language. Different applications from various categories were selected to ensure a comprehensive analysis, including Kanban Board (productivity), BMI Calculator (health), Quiz (education), Quotes (lifestyle), and 2048 Game (entertainment). Each application’s features were meticulously planned and designed using Figma to ensure consistency and clarity before development commenced. Firebase was selected for backend services because of its extensive range of pre-built features, its choice of Firestore for superior performance, and scalability.

We will describe the development experience for one of these applications, the Kanban Board, across the three languages. Starting with Flutter, BLOC [21] was chosen for state management. The project was divided into directories: BLOC components for logic, constants, models, UI screens, repositories, services, and widgets. The architecture followed clean principles to enhance maintainability and scalability [22]. The project comprised 29 files and was completed in approximately 20 hours. Next, a Kotlin-based Kanban Board application was developed using the model-view-viewmodel (MVVM) architecture, facilitating a clear separation of concerns [23]. The project comprised 26 Kotlin sources and 30 XML files and took approximately 24 hours. The code was organized into intuitive packages, ensuring a modular and maintainable structure. Finally, a Java version of the Kanban Board was developed by decompiling the Kotlin code, maintaining a similar project structure and functionality. Compiling tools expedited the process, which took about four hours. The resulting Java project mirrored the Kotlin project in structure and organization, ensuring consistency and scalability.

SonarQube, an open-source platform for continuous code quality inspection, was used to analyze existing open-source projects written in Java, Kotlin, and Dart [23]. It reviews code to identify bugs, code smells, and security vulnerabilities, providing valuable insights into code quality [12]. SonarQube classifies issues into five severity levels—Blocker, Critical, Major, Minor, and Info [24]—guiding developers to prioritize the results. Docker was used to set up SonarQube to ensure a consistent environment. Since SonarQube does not natively support Dart, a plugin has been installed to enable Dart code analysis [25]. The SonarQube analysis was integrated into each application’s development process. For Kotlin, the project was set up with Docker and configured with the SonarQube Gradle plugin, with analysis triggered using the Gradle command. The Java project followed the setup and configuration similar to Kotlin. For Flutter, a Dart support plugin was installed and configured with the project properties file, and the analysis was initiated using the sonar-scanner.

SonarQube integrates 42 open-source projects from GitHub across various categories to extend the analysis. A Python script automated downloading projects, creating SonarQube projects, generating tokens, and saving configurations. Another script was used to collect statistics from SonarQube reports. Finally, the five developed applications (Kanban Board, BMI Calculator, Quiz, Quotes, and 2048 Game) were analyzed using the Code Climate platform to evaluate their maintainability. Code Climate provided detailed insights into code complexity, duplication, and other maintainability factors. This methodology aims to identify the programming language with the most code smells by combining hands-on development experiences with empirical data from broader project analyses.

4. Results

The following section presents the findings of a comparative analysis of mobile application development using Java, Kotlin, and Dart. The study primarily focuses on the SonarQube code quality assessments of the five developed applications in three languages. The severity of code smells and other metrics were analyzed in detail. Accompanying tables and severity graphs provide a quantified representation of these findings. Additionally, this section offers insights into the practical differences between the languages, considering the application size and pertinent notes on the development process. In addition to SonarQube, Code Climate was used to analyze the maintainability of these applications, providing further insights into code complexity, duplication, and maintainability.

Further, this section delves into the implementation of SonarQube across a selection of open-source projects developed in three languages. It discusses the code quality metrics from these projects. Finally, we synthesize the findings into a comprehensive graph highlighting the differences in code quality metrics between open-source projects across the three languages. The analysis presented in this section can offer a broad perspective on the generalizability of the initial findings.

4.1 Results from Identical Application Development

Investigating the development of a Kanban board application is an essential part of this research that provides insightful data on the coding efficiency, maintainability, and overall quality of the code produced under different programming languages. Specifically, the three languages—Java, Kotlin, and Dart (Flutter)—were utilized to generate identical applications, and the resultant findings provide valuable insights into each programming environment’s inherent strengths and weaknesses. Additionally, four more applications were developed using the same languages to expand the comparative analysis: BMI (body mass index) Calculator, Quiz, Quotes, and 2048 Game. The SonarQube analysis results of these applications are presented to offer a broader perspective on code quality across various types of applications.

4.1.1 Code quality analysis

The results of a detailed SonarQube analysis have brought to light significant disparities in the quality and efficiency of code amongst the three languages under scrutiny. As delineated in Table 1, Kotlin and Dart have demonstrated superior efficiency in coding practices compared to Java. Specifically, Kotlin has been found to require 1,467 LOC for the Kanban Board application, while Dart has slightly more, at 1,515 LOC. In contrast, Java has the highest LOC count at 1,748, indicating a higher level of complexity and potentially lower maintainability in its implementation. This pattern was also observed in the BMI Calculator, Quiz, and Quotes applications. These additional applications further illustrate the trend of Kotlin and Dart generally producing more concise and maintainable code than Java.

Regarding code smells in the Kanban Board source codes, Kotlin and Dart have exhibited a similar count of 24 and 22, respectively, signifying a comparable level of code quality between the two. Notably, Dart’s codebase has shown no critical issues, implying robustness in security and stability. In contrast, Java’s codebase has displayed many code smells, with 16 Critical, 22 Major, and 35 Minor issues, indicating significant quality concerns and the need for more stringent quality control measures. Dart demonstrated 10 code smells for the BMI Calculator application, with 2 Critical and 8 Minor. Java had 6 code smells, including 3 Critical, 1 Major, and 2 Minor. Kotlin showed the least code smells, with a total of 3, all Critical. In the Quiz application, Dart had 9 code smells, with 1 Critical and 8 Minor. Java had 29 code smells, with 2 Critical, 25 Info, and 2 Major. Kotlin had 22 code smells, with 1 Critical, 3 Major, 16 Minor, and 2 Info issues. Dart had 3 Minor code smells for the Quotes application. Java had 5 Major code smells, while Kotlin had no code smells detected. In the 2048 Game, Java had 7 Critical code smells, 4 Major, and 95 Minor code smells. Kotlin had 1 Critical, 2 Major, and 2 Minor code smells, while Dart showed no Critical code smells, with five Minor code smells.

As evaluated using Code Climate, the Kanban Board developed in Dart scored an A, while Kotlin received a D, and Java a C. Similarly, the BMI Calculator and Quiz applications developed in Dart also received an A in maintainability. In contrast, Java and Kotlin applications received lower scores. The 2048 Game scored A for Dart, D for Kotlin, and C for Java, further reinforcing the efficiency and maintainability benefits observed with Dart.

4.1.2 Application size and performance

The compiled application APKs for both Java and Kotlin were found to be 11.5 MB, while the Flutter application size was 21.2 MB. This size difference can be attributed to the Flutter engine, which is essential for the cross-platform capabilities of Flutter applications. However, the performance testing across the three platforms showed minimal differences, suggesting that the Flutter application’s increased size does not adversely affect its performance. This trend continues with the BMI Calculator, where the Flutter application was 18 MB, compared to 5.5 MB for both Java and Kotlin. The Quiz application showed Flutter at 21.2 MB, with Java and Kotlin at 7.7 MB. Lastly, the Quotes application had a Flutter size of 18.2 MB, while Java and Kotlin were at 5.7 MB. These observations confirm that while Flutter applications tend to have larger sizes due to the inclusion of the Flutter engine, this does not necessarily translate to performance drawbacks.

4.2 SonarQube Implementation in Open-Source Projects

This section presents an in-depth analysis of the results obtained from the SonarQube analysis of various open-source projects developed using Java, Kotlin, and Dart. A comparative examination is then conducted to identify and highlight the differences in code quality metrics across these languages. The findings reveal each language’s specific performance in handling code smells, which are presented with accompanying graphs to directly compare their efficacy in maintaining code quality in larger codebases. This academic approach enables readers to understand better the nuances and intricacies associated with each language’s code quality and performance.

Java projects demonstrated a total LOC of 52,901, with 3,590 code smells identified. The distribution of these smells indicates a predominance of Minor code smells, accounting for 65%, as depicted in Fig. 1. Major issues comprised 23.3% of the smells, pointing to significant areas that could be optimized for better application stability and security. Critical issues were 9.5%, suggesting crucial vulnerabilities that need immediate attention. Informational and blocker issues were relatively low, at 1.6% and 0.7%, respectively.

Kotlin projects showed a slightly lower total LOC at 48,865 but had a significantly lower total of 647 code smells. This reflects a more efficient codebase overall. However, the proportion of Critical issues was higher at 18.9%, as shown in Fig. 1, indicating that while the codebases are generally efficient, critical areas require mitigation to avoid potential vulnerabilities. Minor issues were 50.2%, major issues were 27%, and info issues were 3.9%, with no blocker issues recorded.

Flutter projects, using Dart for business logic and UI instead of XML as in Kotlin/Java, exhibited a significantly larger total LOC at 174,044 but managed a relatively modest total of 1,303 code smells. The distribution favors Minor code smells at 58.8% and Major issues at 34.8%, underscoring Flutter’s ability to manage larger codebases effectively. Critical issues were notably lower at 6.1%, and Info issues were minimal at 0.2%, as illustrated in Fig. 1. This distribution highlights Flutter’s capability to handle complex application development with fewer critical issues.

The comparative analysis, depicted in Fig. 1, combines the data from Java, Kotlin, and Flutter projects, clearly visualizing how each language manages code quality across different severity levels. These graphs show direct comparison and offer insights into the overall efficiency and security posture of applications developed under these languages. The analysis shows that while Java has the highest number of code smells, it also has a significant foundation that may contribute to higher Minor and Major issues. Kotlin, with its efficient but critical-prone codebase, offers a middle ground. In contrast, Dart maintains a large codebase with a lower incidence of critical issues, proving its robustness in handling complex applications. This comprehensive view helps underline the strengths and weaknesses of each language, guiding developers in choosing the most suitable one based on the specific needs of their projects.

5. Discussion

This section explores the implications of the comparative analysis of mobile application development using Java, Kotlin, and Dart. The findings highlight significant disparities in development practices, code quality, and maintainability across these languages and suggest strategic enhancements for future research and application development.

Embracing new programming languages, including Java, Kotlin, or Dart, presents unique learning curves and transitional obstacles. Java boasts an extensive legacy and robust features, yet navigating its verbose syntax and complex structures can be daunting for those accustomed to more concise modern languages. Kotlin introduces advanced features like null safety and coroutines, offering a smoother transition from Java owing to its interoperability but still demanding a shift towards functional programming paradigms. Flutter, leveraging Dart, significantly diverges from teams experienced in native development by integrating UI and logic within a single framework, necessitating an understanding of new concepts like reactive programming and effective state management, which can steepen the initial learning phase. However, the cross-platform efficiencies gained post-adaptation often justify the initial effort. Managing these learning curves effectively can be facilitated through proactive training and strategic use of tools like Kotlin’s converter and Flutter’s comprehensive community resources.

While robust and widely used, Java exhibited the highest number of code smells and LOC, complicating maintenance and scalability. Kotlin and Dart demonstrated more efficient coding practices, requiring fewer LOC and presenting fewer critical issues, enhancing maintainability. The analysis of open-source projects further supported these findings, with Java showing a substantial prevalence of Minor and Major issues, while Kotlin had a higher percentage of critical issues despite lower LOC. Dart managed a larger codebase with a relatively balanced distribution of code smells, maintaining fewer critical issues. It is recommended that development teams consider adopting newer languages like Kotlin and Dart for complex, scalable applications. These languages offer syntactical efficiencies and advanced features that can significantly reduce the occurrence of code smells and other quality issues. The study also highlights the need for more efficient code quality assessment and development methodologies. Incorporating machine learning models to predict potential code smells and automate code reviews could enhance the development process, ensuring higher code quality standards.

Future research should expand the analysis to include emerging languages and frameworks, incorporate metrics such as runtime efficiency, user experience, and energy consumption, and analyze various projects from diverse repositories. This could help validate current findings across different contexts and reveal new insights into best practices in mobile application development. The methodological approach of using SonarQube for individual and open-source projects has proven effective in highlighting differences in code quality across languages. However, analysis tools must be continuously updated and customized to keep pace with evolving language features. The community-developed SonarQube plugin [26] for Flutter was crucial in adapting the analysis tool to new technologies, underscoring the importance of community involvement in research methodologies.

6. Conclusion

This study has provided a detailed analysis of mobile application development using Java, Kotlin, and Dart. Examining each language’s performance in developing five applications — Kanban Board, BMI Calculator, Quiz, Quotes, and 2048 Game — and analyzing open-source projects with SonarQube has revealed significant insights into coding efficiencies, code smells, and overall code quality. The findings highlight each language’s strengths and weaknesses, offering a nuanced understanding of their suitability for various development contexts.

The Kanban Board application development analysis and SonarQube assessments of open-source projects showed that Kotlin and Dart exhibited fewer code smells than Java. Kotlin had significantly lower LOC at 1,467 for the Kanban board and 48,865 for open-source projects, with fewer code smells (24 in the Kanban board and 647 in open-source projects) but a higher proportion of critical issues. Dart managed larger codebases effectively, with 1,515 LOC for the Kanban Board, 174,044 LOC for open-source projects, and a lower proportion of critical code smells (22 in the Kanban Board and 1,303 in open-source projects). Despite its robustness, Java showed the highest number of code smells, 62 code smells in the Kanban board, and 3,590 code smells in open-source projects.

The analysis of other applications (BMI Calculator, Quiz, Quotes, and 2048 Game) reinforced these findings. The BMI Calculator showed 10 code smells in Flutter (418 LOC), 6 in Java (254 LOC), and 3 in Kotlin (269 LOC). The Quiz application had 9 code smells in Flutter (722 LOC), 29 in Java (768 LOC), and 22 in Kotlin (550 LOC). The Quotes application showed 3 code smells in Flutter (224 LOC), 5 in Java (95 LOC), and 0 in Kotlin (65 LOC). In the 2048 Game, Java displayed a higher complexity with 7 critical code smells, 4 major, and 95 minor code smells, emphasizing potential maintenance challenges. Conversely, Kotlin maintained a cleaner codebase with only 1 critical, 2 major, and 2 minor code smells. Dart excelled with no critical code smells, and just 5 minor code smells, highlighting its effectiveness in code maintenance.

In addition to SonarQube, Code Climate was used to evaluate the maintainability of these applications, where Dart consistently outperformed Java and Kotlin, receiving an A for maintainability across all applications, while Java and Kotlin received lower grades. For specific applications (Quotes and 2048 Game), Kotlin hits an A for maintainability, the same grade as Dart. For Quotes, particularly, the source codes in all languages get the A grade; considering the size of them this result can be natural since the small code is much maintainable.

The privileges of using cross-platform development with Flutter were also evident. Dart’s ability to maintain a single codebase across multiple platforms (iOS, Android, and Web) reduces development time. It streamlines the maintenance process, making it a more efficient choice for projects aiming for fast deployment and long-term maintenance efficiency.

Selecting a programming language requires considering project requirements, timeline, and developer experience. The choice should be based on the project’s specific needs, such as the intended platform, complexity, and feature requirements. Languages that allow fast development and deployment might be preferable in time-sensitive projects. Additionally, the development team’s experience with a particular language can significantly impact the development process’s efficiency and quality. The findings suggest that adopting newer programming languages like Kotlin and Dart can enhance coding practices, increase efficiency, and reduce code complexity. Advanced tools for code analysis and quality assurance, such as SonarQube and Code Climate, are used to identify and address code smells and other quality issues regularly. Continuous learning and training are also essential for developers to stay updated with the latest programming languages and framework developments, improving application maintainability.

Future research should explore integrating additional programming languages and newer frameworks to update best practices in application development. Adopting more comprehensive metrics could provide a broader perspective on the performance of different languages. Extending the analysis to a larger dataset of open-source projects could also enhance the generalizability of the findings. This study highlights the importance of carefully selecting the development language. While newer languages like Kotlin and frameworks like Flutter offer substantial benefits in terms of code smell and overall quality, the choice of technology should always be tailored to the project’s specific needs and the development team’s capabilities. Thoughtful selection and implementation of development languages can optimize processes, enhance application quality, and contribute to advancing mobile technology. This research advocates for a balanced approach to framework selection, emphasizing continuous quality assurance and adopting best practices as pivotal to the long-term success of mobile application development projects.

Conflict of Interest

The authors declare that they have no competing interests.

Funding

This work was supported by the National Research Foundation of Korea grant funded by the Korea government (MSIT) (No. RS-2023-00242528).

Acknowledgments

This paper is the extended version of “Comparative Analysis of Cross-Platform and Native Mobile App Development Approaches,” in the 2024 Annual Symposium of KIPS (ASK 2024) held in PyeongChang, Republic of Korea, dated May 23-25, 2024.