Modern Android Development in 2023
Tags: android, androiddev, androiddevelopment, jetpackcompose
Published: 2023-01-23 23:35:35

Hello everyone 👋🏻, I’d like to share with you how to build Android apps with the latest trends for the year 2023.
<br />


## Disclaimer

This is an article from my opinion and professional experience, taking into account different opinions among the Android developer community, also constantly reviewing the guides provided by Google for Android.

I have to make it clear that there are very interesting tools, patterns and architectures that I may not mention but it does not mean that they cannot be other interesting alternatives to develop Android applications.
<br /><br /><br />



## What is android?

Android is an open-source operating system based on the Linux kernel and developed by Google. It’s used in a wide variety of devices, including smartphones, tablets, TVs, and smartwatches.

Currently, Android is the operating system most used in the world for mobile devices; according to a report by [**statcounter**](https://gs.statcounter.com/os-market-share/mobile/worldwide/#monthly-202112-202212) with a sample of the last 12 months, Android has a market share of **71.96%.**

Next, I will mention a list of tools, libraries, architectures, guides, and other utilities that I consider important to building modern applications on Android.
<br /><br />



## Kotlin ❤️

![Image by [https://talently.tech/](https://talently.tech/)](https://cdn-images-1.medium.com/max/5120/0*piQN_I004o_ugTCN.jpg)

Kotlin is a programming language developed by [JetBrains](https://www.jetbrains.com/). Recommended by Google who officially announced it in May 2017 (see publication [here](https://android-developers.googleblog.com/2017/05/android-announces-support-for-kotlin.html)). It is a modern programming language that has compatibility with Java and can run on the JVM, which has made its adoption in the development of Android applications very fast.

Whether you are new to Android or not, you should consider Kotlin as your first choice, don’t swim against the tide 🏊🏻 😎, Google [announced](https://developer.android.com/kotlin/first) this approach at Google I/O 2019. With Kotlin, you will be able to use all the features of a modern language, including the power of Coroutines and the use of modern libraries developed for the Android ecosystem.

Official kotlin documentation [here](https://kotlinlang.org/docs/home.html)
<br /><br />



## Jetpack Compose 😍

![Image by [blogger.googleusercontent.com](https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiv3CjuEunEpPuvrsKEV0f7R_OSPonuZnDUi97Hrz68T9xKpsUHRoFaivipPxNQ6QT3BIHVxtSH85xurEqxSnC1S7rQklKL8vKj40E2xgFWE9ylhjZDHbWoie3Evgl_WjnG2nQ1UxFVs9lg3IAMIv_CHCsuesUuCW_BMddUXU4JErFXLn9Twcy2tKKfHA/s1600/Android-JetpackCompose1.2-Header.png)](https://cdn-images-1.medium.com/max/3200/0*kG-9BQIyUm8MblpZ.png)
>  Jetpack Compose is Android’s recommended modern toolkit for building native UI. It simplifies and accelerates UI development on Android.
>  _ [Jetpack Compose documentation](https://developer.android.com/jetpack/compose)

Jetpack Compose is part of the Android Jetpack library and uses the Kotlin programming language to easily create a native user interface. Also, it integrates with other Android Jetpack libraries, such as LiveData and ViewModel, to make it easier to build reactive and maintainable Android applications.

Some key features of Jetpack Compose include:

 1. Declarative UI.

 2. Customizable widgets.

 3. Easy integration with existing code.

 4. Live preview.

 5. Improved performance.
<br />

**Resources:**

* [Official documentation.](https://developer.android.com/jetpack/compose)

* [Compose to Kotlin Compatibility Map](https://developer.android.com/jetpack/androidx/releases/compose-kotlin)

* [Jetpack Compose Roadmap](https://developer.android.com/jetpack/androidx/compose-roadmap)

* [Course.](https://developer.android.com/courses/jetpack-compose/course)

[Jetpack Compose documentation](https://developer.android.com/jetpack/compose)
<br /><br />



## Android Jetpack

![Image by [Florina Muntenescu](https://medium.com/@florina.muntenescu) on [medium](https://medium.com/androiddevelopers/whats-new-in-jetpack-1891d205e136)](https://cdn-images-1.medium.com/max/2400/0*3LHozcwxQYiKVhPG.png)
>  Jetpack is a suite of libraries to help developers follow best practices, reduce boilerplate code, and write code that works consistently across Android versions and devices so that developers can focus on the code they care about.
>  _ [Android Jetpack documentation](https://developer.android.com/jetpack)

Some of its most common tools are:

* [ViewModel](https://developer.android.com/topic/libraries/architecture/viewmodel)

* [Room](https://developer.android.com/training/data-storage/room)

* [DataStore](https://developer.android.com/topic/libraries/architecture/datastore)

* [WorkManager](https://developer.android.com/topic/libraries/architecture/workmanager)

* [Navigation](https://developer.android.com/guide/navigation)

* [CameraX](https://developer.android.com/training/camerax)

* [Compose](#af4e)
<br /><br />



## Material Design

![Illustration by Reed Hollett](https://cdn-images-1.medium.com/max/2800/1*D3MK4AocfnktSnVGe4rg0g.png)
>  Material Design is an adaptable system of guidelines, components, and tools that support the best practices of user interface design. Backed by open-source code, Material Design streamlines collaboration between designers and developers, and helps teams quickly build beautiful products.
>  _ [Material Design Site](https://m3.material.io/)

Material Design is backed by designers and developers from Google and will allow us to have a guide to work on our UI/UX for Android, Flutter and Web.

Currently, the last version for Material Design is 3, you can see more [here](https://m3.material.io/)
<br /><br />



## Clean Architecture

![Cover image for Clean Architecture](https://cdn-images-1.medium.com/max/2000/0*KgFh38gn_lDEuoB9.jpg)

The concept of "**Clean Architecture"** was introduced by [Robert C. Martin](https://en.wikipedia.org/wiki/Robert_C._Martin). It is based on the separation of responsibilities through the division of software into layers.

**Characteristics**

 1. Independent of Frameworks.

 2. Testable.

 3. Independent of UI.

 4. Independent of Database.

 5. Independent of any external agency.

**The Dependency Rule**

The dependency rule is described very well by the author in his piece, [The Clean Code Blog](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html)
>  The overriding rule that makes this architecture work is *The Dependency Rule*. This rule says that *source code dependencies* can only point *inwards*. Nothing in an inner circle can know anything at all about something in an outer circle. In particular, the name of something declared in an outer circle must not be mentioned by the code in the an inner circle. That includes, functions, classes. variables, or any other named software entity.

[The Clean Code Blog](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html)

**Clean Architecture in Android**

* **Presentation**: Activities, Fragments, View Models, others view components.

* **Domain**: Use Cases, Entities, Repositories, others domain components.

* **Data**: Repository implementations, Mappers, DTO’s, etc.
<br /><br />




## Architecture Patterns for Presentation Layer

![Cover image for Architecture Patterns for Presentation Layer](https://cdn-images-1.medium.com/max/2000/1*1NXA5z7ca8NBpPG9-S42sA.png)

An architecture pattern is a higher-level strategy that aims to help design a software architecture and is characterized by being a solution within a reusable framework for common architectural problems. Architectural patterns are similar to design patterns, but they are larger in scale and address more global issues such as the overall structure of the system, the relationships between components, and the way that data is managed.

Within the Presentation layer, we have some architecture patterns, of which I would like to highlight the following:

* **MVVM**

* **MVI**

I do not want to go into explaining each one because on the internet you find too much information about this. 😅

In addition, you can also see the [**guide to app architecture**](https://developer.android.com/topic/architecture)

![Image by [developer.android.com](https://developer.android.com/static/topic/libraries/architecture/images/mad-arch-overview-ui.png)](https://cdn-images-1.medium.com/max/3394/0*QJ56TjhdXPcQweAk.png)
<br /><br />



## Dependency Injection

![Cover image for Dependency Injection](https://cdn-images-1.medium.com/max/2000/1*1NXA5z7ca8NBpPG9-S42sA.png)

Dependency injection is a software design pattern that allows a client to obtain its dependencies from an external source rather than creating them itself. It is a technique for achieving Inversion of Control (IoC) between objects and their dependencies.

* [Hilt](https://developer.android.com/training/dependency-injection/hilt-android) ❤️

* [Dagger](https://dagger.dev/)

* [Koin](https://insert-koin.io/)
<br /><br />




## Modularization

![Cover image for Modularization](https://cdn-images-1.medium.com/max/2000/1*1NXA5z7ca8NBpPG9-S42sA.png)

Modularization is a software design technique that allows you to divide an application into independent modules, each with its own functionality and responsibility.

![Image by [developer.android.com](https://developer.android.com/static/topic/modularization/images/1_sample_dep_graph.png)](https://cdn-images-1.medium.com/max/2000/0*NNUw83lZ228t5yLD.png)
<br />

### Benefits of modularization

**Reusability**: By having independent modules, they can be reused in different parts of the application or even in other applications.

**Strict visibility control**: Modules enable you to easily control what you expose to other parts of your codebase.

**Customizable delivery**: [Play Feature Delivery](#b84c) uses the advanced capabilities of app bundles, allowing you to deliver certain features of your app conditionally or on demand.

**Scalability**: By having independent modules, functionalities can be added or removed without affecting other parts of the application.

**Ease of maintenance**: By dividing the application into independent modules, each with its own functionality and responsibility, it is easier to understand and maintain the code.

**Ease of testing**: By having independent modules, they can be tested in isolation, which makes it easy to detect and fix errors.

**Architecture improvement**: Modularizing helps to improve the architecture of the application, allowing a better organization and structure of the code.

**Improve collaboration**: By having independent modules, developers can work on different parts of the application simultaneously and without interference.

**Build Time**: Some Gradle functionalities such as incremental build, build cache or parallel build, can leverage modularity to improve build performance.

See more in the [official documentation](https://developer.android.com/topic/modularization).
<br /><br />




## Network

![Cover image for Network](https://cdn-images-1.medium.com/max/2000/1*1NXA5z7ca8NBpPG9-S42sA.png)

* [OkHttp](https://square.github.io/okhttp/)

* [Retrofit](https://square.github.io/retrofit/)
<br /><br />




## Serialization

![Cover image for Serialization](https://cdn-images-1.medium.com/max/2000/1*1NXA5z7ca8NBpPG9-S42sA.png)

In this section I would like to mention two important tools in my opinion: **Moshi** widely used in conjunction with Retrofit and **Kotlin Serialization**, the bet of the Kotlin team at Jetbrain.

* [Moshi](https://github.com/square/moshi)

* [Kotlin Serialization](https://github.com/Kotlin/kotlinx.serialization)

**Moshi** and **Kotlin Serialization** are two serialization/deserialization libraries for Kotlin and Java that allow you to convert objects to JSON or another serialization format and vice versa. Both provide a user-friendly interface optimized for use in mobile and desktop applications. Moshi primarily focuses on JSON serialization, while Kotlin Serialization has support for various serialization formats, including JSON.
<br /><br />




## Image Loading

![Cover image for Image Loading](https://cdn-images-1.medium.com/max/2000/1*1NXA5z7ca8NBpPG9-S42sA.png)
>  To load an image from the internet, there are several third-party libraries available to help you handle the process. Image loading libraries do a lot of the heavy lifting for you; they handle both caching (so you don’t download the image multiple times) and networking logic to download the image and display it on screen.
>  _ [Official Android Documentation](https://developer.android.com/jetpack/compose/graphics/images/loading)

* [Coil](https://github.com/coil-kt/coil#jetpack-compose)

* [Glide](https://bumptech.github.io/glide/int/compose.html)
<br /><br />




## Reactivity / Thread Management

![Cover image for Reactivity / Thread Management](https://cdn-images-1.medium.com/max/3120/1*jm3wnFbTBvURFtLlcQAYRg.png)

When we talk about reactive programming and asynchronous processes, our first option is Kotlin Coroutines; thanks to the Suspension Functions and Flow we can cover all these needs. However, I believe that in this section it is worth highlighting the importance of RxJava even within the development of Android applications. For those of us who have been working with Android for a couple of years, we know that RxJava is a very powerful tool with a very large set of functions for working with data streams. I still consider RxJava to be an interesting alternative to consider today.

* [Kotlin Coroutines](https://github.com/Kotlin/kotlinx.coroutines/blob/master/README.md#using-in-your-projects): [suspend functions / Flow Api ] (Nice to have ❤️)

* [RxJava](https://github.com/ReactiveX/RxJava)
<br /><br />




## Local Store

An important point when building mobile applications is having the ability to persist data locally, such as some session data or cache data, among others. It is important to choose the right storage option based on the needs of your application. We could store unstructured data like key-value or structured data like a database. Keep in mind that this point does not mention all the types of local storage that we have available (such as file storage), only the tools that allow us to save data.

![Cover image for Local Store](https://cdn-images-1.medium.com/max/4376/1*rILOhf6I_dtR-ircBkKvtQ.png)

**Suggestions**:

* ~~S̶h̶a̶r̶e̶d̶P̶r̶e̶f̶e̶r̶e̶n̶c̶e̶s̶~~

* [DataStore](https://developer.android.com/topic/libraries/architecture/datastore)

* [EncryptedSharedPreferences](https://developer.android.com/reference/androidx/security/crypto/EncryptedSharedPreferences)
<br /><br />




## Testing

![Cover image for Testing](https://cdn-images-1.medium.com/max/2000/1*1NXA5z7ca8NBpPG9-S42sA.png)

* [JUnit 5](https://junit.org/junit5/)

* [Mockk](https://mockk.io/ANDROID.html)

* [Espresso](https://developer.android.com/training/testing/espresso)

* [Robolectric](https://robolectric.org/)
<br /><br />




## R8 optimizations

R8 is the default compiler that converts your project’s Java bytecode into the DEX format that runs on the Android platform. It is a tool that helps us to obfuscate and reduce the code of our application by shortening the names of the classes and their properties, eliminating unused code and resources within the project. To see more, check the Android documentation about [Shrink, obfuscate, and optimize your app](https://developer.android.com/studio/build/shrink-code).


![Image cover for R8 optimizations](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pmagdhgimq7m7f8mmzqa.png)
Image by [androidtopics.dipien.com](https://androidtopics.dipien.com/r8-proguard-all-official-development-resources-864e471f6d42)



* Code shrinking

* Resource shrinking

* Obfuscation

* Optimization
<br /><br />




## Play Feature Delivery

![Cover image for Play Feature Delivery](https://cdn-images-1.medium.com/max/2000/1*1NXA5z7ca8NBpPG9-S42sA.png)
>  Google Play’s app serving model, called Dynamic Delivery, uses Android App Bundles to generate and serve optimized APKs for each user’s device configuration, so users download only the code and resources they need to run your app.
>  _ [Android Documentation](https://developer.android.com/guide/playcore/feature-delivery)

![Image by [miro.medium.com](https://miro.medium.com/max/1400/1*rD_O9Ru8WJJMm1TeIy-6lw.png)](https://cdn-images-1.medium.com/max/2800/0*FitxQQeB7XC7MVUq.png)
<br /><br />




## Adaptive layouts

![Image by [android-developers.googleblog.com](https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjg5R2hd0VZp__xKUUgs6-tfKHEoabMPqo2aY6uoGvzre-9E4gUlz6RbGsrE-Txszbrc3OaNL9r2TshsZmzGhEiM3M-_eO8M39K6ljm9NrX2BMHRLHM3HeF04YgJf8l4Z1-kNaP9YV8BCRe3n2zTUTSx3FOvA5IRc4PCjVPiJ7CEw7M7Y7uAJLVd7WQ/s1600/Android-GoogleIO3thingstoknowaboutFormFactors_4209x1253.png)](https://cdn-images-1.medium.com/max/3200/0*MHJwbEuvl8cXDjeq.png)

With the growth in the use of mobile devices with different form factors, we need to have tools that allow us to work with our Android applications adapted to different types of screens. That is why Android provides us with **Window Size Classes**, which, in a simple way, are three large groups of screen formats that mark critical points for us to develop our designs. With this we avoid the complexity of thinking about many screen designs to reduce our possibilities to 3 groups which are: **Compat**, **Medium** and **Expanded.**

**Window Size Classes**

![Image by [developer.android.com](https://developer.android.com/static/images/guide/topics/large-screens/window_size_classes_width.png)](https://cdn-images-1.medium.com/max/3820/1*5Tm17OKlC5n0oy6L641A5g.png)

![Image by [developer.android.com](https://developer.android.com/static/images/guide/topics/large-screens/window_size_classes_height.png)](https://cdn-images-1.medium.com/max/3784/1*Qv1nt0JJzQPzFfr2G78ulg.png)

[Support different screen sizes](https://developer.android.com/guide/topics/large-screens/support-different-screen-sizes)

Another important resource that we have are the [**Canonical Layouts**](https://m3.material.io/foundations/adaptive-design/canonical-layouts), which are predefined screen designs that can be used for most scenarios in our Android applications and also show us a guide on how to adapt them to large screens.

![Window Size Classes](https://cdn-images-1.medium.com/max/2000/1*XASUz4kVTK4I0dH8F5slYQ.gif)
<br />

### **Other related resources**

* [3 things to know about Form Factors at Google I/O 2022](https://android-developers.googleblog.com/2022/05/form-factors-google-io-22.html)

* [Playlist: Form Factors at Google I/O](https://www.youtube.com/playlist?list=PLWz5rJ2EKKc_seN7mrwgU7mDYKA0hq_ib)

[Form-Factor Training](https://developer.android.com/courses/pathways/jetpack-compose-for-android-developers-5)

[Form Factors at Google I/O 2022](https://www.youtube.com/playlist?list=PLWz5rJ2EKKc_seN7mrwgU7mDYKA0hq_ib) (2)
<br /><br />




## Performance

![Image by [android-developers.googleblog.com](https://android-developers.googleblog.com/2021/09/app-performance-to-drive-app-excellence.html)](https://cdn-images-1.medium.com/max/4096/0*QcvMmljmmcvCuqfN.png)

While we develop applications for Android, we must ensure that the user experience is better, not only at the beginning of the application but also throughout its execution. For this reason, it is important to have tools that allow us to carry out a preventive analysis and constant monitoring of cases that may affect the performance of the application, so here is a list of tools that will help you with this purpose:

* [Benchmark](https://developer.android.com/topic/performance/benchmarking/benchmarking-overview)

* [Baseline Profiles](https://developer.android.com/topic/performance/baselineprofiles/overview)

* [App Startup](https://developer.android.com/topic/libraries/app-startup)

* [Firebase Performance Monitoring](https://firebase.google.com/docs/perf-mon)

* [JankStats library](https://developer.android.com/topic/performance/jankstats)
<br /><br />




## **In-App Updates**
>  When your users keep your app up to date on their devices, they can try new features, as well as benefit from performance improvements and bug fixes. Although some users enable background updates when their device is connected to an unmetered connection, other users might need to be reminded to install updates. In-app updates is a Google Play Core libraries feature that prompts active users to update your app.
>  The in-app updates feature is supported on devices running Android 5.0 (API level 21) or higher. Additionally, in-app updates are only supported for Android mobile devices, Android tablets, and Chrome OS devices.
>  _ [In-App Updates documentation](https://developer.android.com/guide/playcore/in-app-updates)

![Image by [developer.android.com](https://developer.android.com/static/images/app-bundle/flexible_flow.png)](https://cdn-images-1.medium.com/max/2000/0*m8wEQzEW1M1fwwKC.png)
<br /><br />



## In-App Reviews
>  The Google Play In-App Review API lets you prompt users to submit Play Store ratings and reviews without the inconvenience of leaving your app or game.
>  Generally, the in-app review flow can be triggered at any time throughout the user journey of your app. During the flow, the user has the ability to rate your app using the 1 to 5 star system and to add an optional comment. Once submitted, the review is sent to the Play Store and eventually displayed.
>  To protect user privacy and avoid API misuse, there are strict guidelines that your app should follow about [when to request in-app reviews](https://developer.android.com/guide/playcore/in-app-review#when-to-request) and the [design of the review prompt](https://developer.android.com/guide/playcore/in-app-review#design-guidelines).
>  _ [In-App Reviews documentation](https://developer.android.com/guide/playcore/in-app-review)

![Cover image for In-App Review](https://cdn-images-1.medium.com/max/3200/0*--T1rkTL7DEGJT9B.jpg)
<br /><br />




## Accessibility

![Image by [fscl01.fonpit.de](https://fscl01.fonpit.de/userfiles/7613938/image/AccessibilityAndroid-w1400h788.png)](https://cdn-images-1.medium.com/max/2000/0*fO3BnqLh8b-H_zLo.png)

Accessibility is an important feature in the design and construction of software that provides the ability for people with accessibility needs to use the application, in addition to improving their user experience. Some disabilities that this concept aims to improve are: people with vision problems, color blindness, hearing problems, dexterity problems, and cognitive disabilities, among others.

Considerations:

* Increase text visibility (Color contrast, Resizable Text)

* Use large, simple controls

* Describe each UI element

Check [Accessibility — Android doc.](https://developer.android.com/guide/topics/ui/accessibility)
<br /><br />




## Security

![Image by [android.com](https://lh3.googleusercontent.com/zSpjW3Lox9DytJ8nrmuWEZgsbmFlkBkemjZc_60vWk3QCN1jTkp5SQk78qfr7TTAM5BsG4HEvmWDnzA6xO6d4srbpTUKCD40eUlO=w1034-rw-e365-v1)](https://cdn-images-1.medium.com/max/2068/0*Fk42FqLrujNE0O1Z)

Security is one, if not the most important aspect, that we must take into account when developing applications that protect the integrity of the device, the security of the data, and the trust of the user, which is why I list below a series of tips that will help you with this purpose.

* Encrypt sensitive data and files: Use [EncryptedSharedPreferences](https://developer.android.com/reference/androidx/security/crypto/EncryptedSharedPreferences) and [EncryptedFile](https://developer.android.com/reference/androidx/security/crypto/EncryptedFile).

* Apply signature-based permissions:

* Use **signature-based permissions** when sharing data between apps you have control over.

    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="com.example.myapp">
        <permission android:name="my_custom_permission_name"
                    android:protectionLevel="signature" />

* Do not put keys, tokens, or sensitive data required for your application’s configuration directly inside files or classes that are inside the project repository. Use **local.properties** instead.
<br /><br />




## Version Catalogs

![Cover image for Version Catalogs](https://cdn-images-1.medium.com/max/2000/1*1NXA5z7ca8NBpPG9-S42sA.png)

Gradle provides a standard way to centrally manage project dependencies called the version catalog; it was experimentally introduced in version 7.0 and officially released in version 7.4.

Advantage:

* For each catalog, Gradle generates *type-safe accessors* so that you can easily add dependencies with autocompletion in the IDE.

* Each catalog is visible to all projects of a build. It is a central place to declare a version of a dependency and to make sure that a change to that version applies to every subproject.

* Catalogs can declare [dependency bundles](https://docs.gradle.org/current/userguide/platforms.html#sec:dependency-bundles), which are “groups of dependencies” that are commonly used together.

* Catalogs can separate the group and name of a dependency from its actual version and use [version references](https://docs.gradle.org/current/userguide/platforms.html#sec:common-version-numbers) instead, making it possible to share a version declaration between multiple dependencies.

[see more](https://docs.gradle.org/current/userguide/platforms.html)
<br /><br />




## Logger

![Cover image for Logger](https://cdn-images-1.medium.com/max/2000/1*1NXA5z7ca8NBpPG9-S42sA.png)

A logger is a software tool used to register information about the execution of a program; important events, errors debug messages and other information that may be useful in diagnosing problems or understanding how a program is working. Loggers can be configured to write messages to different locations, such as a log file, to the console, to a database, or by sending the messages to a logging server.

* [Timber](https://github.com/JakeWharton/timber)

![Cover image for Logger](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/v308f71t2v2or43s7f9x.png)<br />




## Linter

![Image taken from [https://miro.medium.com/](https://miro.medium.com/max/1400/1*gdHPyd_S5UgCiFKnetAHvA.webp)](https://cdn-images-1.medium.com/max/2800/0*T3lk9cUYryUAo6G1.png)

Linter is a programming tool that is used to analyze the program source code to find potential problems or bugs in the code. These issues can be syntactic, inappropriate code style, lack of documentation, security issues, and so on, and they can have an impact on the quality and maintainability of the code.

* [Android Lint](https://medium.com/swlh/what-is-android-lint-17fa0d87abb2)

* [Detekt](https://detekt.dev/)

* [Ktlint](https://pinterest.github.io/ktlint/)

![Divider](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/j39v0shfjc2gmtxaew0j.png)<br />




If you like my content and want to support my work, you can give me a cup of coffee ☕️ 🥰

[![Ko-fi](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/j18vjijbegi1dhp83ozv.png)](https://ko-fi.com/devjorgecastro)

[![Buy me a coffee](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jdz714gpdbxv6ve001hf.png)](https://www.buymeacoffee.com/jorgecastro)


## Follow me in

* **Twitter:** [@devjcastro](https://twitter.com/devjcastro)

* Linkedin: [dev-jorgecastro](https://www.linkedin.com/in/dev-jorgecastro/)