ASCE1885 is the author of advanced Android.
- Wechat official account: ASCE1885
- Small tight circle: Android advanced advanced, see this article.
- Github, Jianshu, Weibo, CSDN Zhihu
Original link: antonioleiva.com/google-kotl… Due to Markdown’s restriction on the typesetting of pictures, in order to ensure the aesthetics of typesetting, screenshots of the author’s introduction are taken in this paper instead of additional translation.
Google has repeatedly stated that they are not opposed to Kotlin’s use, and as long as the Kotlin compiler still generates valid bytecode, Google will not prevent anyone from using it.
But many are still waiting for official support, something that may never happen.
While we’ve waited for this moment, I thought it would be nice to know what Google’s Android development experts think of Kotlin.
If you haven’t, Google Development Experts (GDEs) [1] is a program that honors outstanding developers for their contributions to their field.
I contacted some of these Android experts (the list is long!). I got responses from 17 people. Thank you very much for taking the time to answer.
I just asked them to tell us a little bit about Kotlin[2], and the answers were obviously unmodified, so you can find voices for and against (or less so).
I hope this helps you understand how Kotlin is a game changer, and if you’re an Android developer, I hope Kotlin will be a language you’ll consider using.
Without further ado, let’s take a look at what the GDEs have to say, in no particular order:
1. Annyce Davis
I have previously developed Grails applications using the Groovy programming language, and for me Groovy is a great improvement over Java. It was lean and helped avoid much of the boilerplate code you had to encounter when coding with the Java 6 language at the time. When Kotlin showed up, I was immediately attracted to it because many of its syntactic features reminded me of Groovy. It’s neat and refined.
I am an avid learner, so I am eager to learn Kotlin and start my learning path based on Kotlin Koans. I also ordered an early access version of Kotlin in Action. After listening to Hadi’s Kotlin podcast, I was pushed to the edge of looking at Kotlin. When Kotlin 1.1 was released, I finally decided to take Kotlin seriously and introduce it into my online app.
Kotlin has many advantages for Android developers. The most obvious is its type system and handling of null types, which forces you to specify which variables can be null when you code and follow this convention when you use them, after which the compiler steps in to make sure that all assignments to variables are valid. Null-pointer exceptions [3] are the most common type of exception I work with in Android applications. Kotlin helps level the playing field.
Another notable benefit of Kotlin is the ability to extend functions [4], which made my code much cleaner and easier to read by adding extension functions to the Context, Activity, and Date classes.
By using Kotlin, my code gets better.
2. Sebastiano Poggi
I really, really love this language. I personally think it makes coding more enjoyable in many cases than it used to be in the same way that coding in The Java language would be painful and tedious. I’m by no means a Kotlin expert, as I haven’t used it in my daily work yet, but I use it every time I work on a small project. Do you know the legendary 10x developer? Kotlin sometimes makes me feel like a 10X developer (I don’t think anyone can be called a 10x developer, so that’s a good start for me).
The concise syntax is one of the most obvious benefits of the language, and beyond that, I really appreciate all the additional apis it provides and the ecosystem built around it. For example, immutable sets are something THAT I often need but cannot use in the Java language without (partially) introducing the Guava library in my application, but Kotlin provides a level 1 implementation of immutable sets, along with a bunch of other features. Oh, did I mention how excited I was to see LLVM support as a goal in Kotlin’s release?
However, as I mentioned earlier, I don’t use Kotlin in my daily work. While it was reasonable to believe that the introduction of Kotlin would have benefited the project, it was difficult to introduce Kotlin because of the size of the team, and I was distressed to find Kotlin’s main problems: a lack of static code analysis tools and a lack of mature design patterns.
The latter is a relatively minor issue if your project is small and uncomplicated, but if you have ten developers working together in a vast repository of code that is nearly ten years old, having a good design pattern is much more reassuring. Of course, you can use Java design patterns, but not all of them make sense in Kotlin because some design patterns are designed specifically around the Java language and have limitations. This is a long discussion, and I will stop it here, otherwise the whole article will become this discussion 😀.
For me, the first question mentioned above is the most critical, and the one that really determines whether OR not I adopt Kotlin in my project. The fact that you can’t use PMD, Checkstyle, Findbugs, and other static code checking tools in your project practice (you haven’t tried Errorprone yet) puts your project in a very dangerous position. First, if you have more than three or four developers working on a project, you can’t expect strict oversight of code style; More importantly, you’re missing many of the in-depth bug-checking features you get from the above tools. Raise your hand if you’ve never (correctly) used a static code inspection tool, I certainly don’t believe you! I know there are IDE checks now, but those features are nowhere near powerful enough; There are a few projects that bring Kotlin static code analysis capabilities, but they’re not worth relying on. I’m really looking forward to seeing them mature enough that we can finally use them safely.
During this time, I used Kotlin on small code repositories and I like it 🙂.
3. Jorge Barroso
Kotlin is a big step forward in Android development. Before that, Android lacked the features Kotlin brought to the platform. Java development on Android was somewhat outdated compared to other Java platforms, and even with the current push for Java 8, But it still won’t become the modern programming language we love.
One of the biggest problems I see right now is its promotion, and it’s hard to convince companies to transition to Kotlin and demonstrate its value. It’s relatively easy for tech companies because it’s an incentive and a challenge for developers, but it’s more difficult for small companies. In addition, many companies worry that Kotlin won’t be widely used without Google behind it.
I love the language and its contribution to the ecosystem, and I wish I could use it more in my daily life, but the nature of the project I’m working on doesn’t allow for that. I encourage everyone to take a look at, but not just Kotlin, maybe another language, because it opens up a new perspective for them, and it’s very useful to learn when you’re writing software.
4. Donn Felker
Kotlin is fantastic, I love it, and it’s a breath of fresh air in the Android world.
5. Mark Allison
As much as I like Kotlin, I don’t think it’s mature enough to be used in online products. The lack of mature patterns and best practices makes the code Kotlin writes potentially difficult to maintain.
This is evident in Kotlin’s lack of static code analysis tools. While Java’s static code analysis tools aren’t perfect, they can be a good indicator of technical debt. Java tools cannot be used for Kotlin because they parse exclusively the Java language source code.
6. Huyen Tue Dao
I’m totally obsessed with Kotlin. We coded 100% of our work using Kotlin, including code for online products. In fact, I code with Kotlin wherever and whenever I can, and thanks to the interoperability of Kotlin and Java [5], I can use Kotlin almost anywhere. I can access system platform apis and other existing code and function libraries while enjoying and taking advantage of all the features of modern programming languages that Kotlin brings to the table.
Since Kotlin is a new language and we are all discovering and defining best practices, I had to scrutinize the impact of each line of code at both the high-level and low-level levels. It was fun and forced me to be more careful and serious about making certain decisions.
The simplicity of the language is breathtaking. I love Android, but we deal with a lot of boilerplate code, and Kotlin helps reduce some of that boilerplate writing. While too much streamlining can lead to code readability issues, I think most of the time Kotlin actually improves code readability, as long as we don’t get too crazy and remember what best practices we want.
7. Dmytro Danylyk
For developers stuck in the Android world, Kotlin is a real rule changer, with many of my favorite features: null type safety, data classes[6], properties and lazy-loaded properties, extension functions, coroutines, immutability, and more.
I enjoy using Koltin to code because I didn’t have to introduce too many third party libraries into the project, and Kotlin has provided most of the support nicely.
Thanks to JetBrains, Kotlin has great IDE support and lots of learning materials, even an online REPL[7].
8. Anup Cowkur
I used to code in languages like Haskell and Elixir, so when I was developing for Android I often thought, “Why can’t Android have features like this?” .
Now with Kotlin, we can do it.
Optional types are built into Kotlin’s type system, functions are first-class citizens, and features like type matching (sort of) and immutable types finally allow me to use true functional programming in Android development.
9. David Vávra
I used Kotlin in production for my main application (Settle Up[8]), which is mature enough and has many advantages over Java (any version) [9]. Kotlin is fully compatible with existing Java tools and libraries, and works well with Android Studio.
If I were creating an APP now [10], I would definitely choose Kotlin. The most common counter-argument is: “But colleagues who are not familiar with Kotlin will complain and reduce development efficiency”. I disagree. Switching from Java to Kotlin really doesn’t take much effort, and the benefits come quickly. By contrast, starting with RxJava will feel much more difficult.
Whether or not to use Kotlin for porting an existing APP is a case by case decision. For example, you can only use Kotlin on one page, but if you want to get 100% of the benefits of the language, it’s best to switch to Kotlin in full. Of course this is very difficult to prove to the project leader.
All Kotlin needs now is official approval from Google. Google doesn’t need to do anything but add snippets of Kotlin’s version to the official documentation (as they did with Swift/ObjectiveC). If Kotlin is officially recognized, we’ll see Koltin become a major choice for most people, hopefully at Google I/O this year.
10. César Valiente
I think Kotlin is a great modern programming language.
It has a very flat learning curve, and you can probably write some code in Kotlin and do something with it after just one day of learning the syntax. Kotlin is really fun to write, it’s fun, it’s concise, it has features of other modern languages, it’s under continuous development by a very professional team like JetBrains, and it’s always supported by the community because it’s open source!
I don’t want to spend time on Kotlin’s developer-liberating features here, as they are well documented, Koans[11] can be used for practice in ides and Web pages, and the Kotlin community is constantly releasing new and exciting content.
On Android, Kotlin has given us Android developers a clean SLATE, giving us a new reason to enjoy writing apps. With Kotlin, you can write less code, and most importantly, at the end of the day, your code is more readable, less boilerplate code, And since it takes less time to write the same code, you’ll be more productive and, as I said earlier, you’ll have fun with Kotlin!
In the Android community at least, one question hangs in the air: Is Kotlin ready to apply the online product? My answer is yes, JetBrains released a stable version 1.0 last year.
Do you think the smart guys at JetBrains would have released it if it wasn’t ready for an online product? Of course not. Kotlin has been used in some of JetBrains’ products, and other recognized great companies have used Kotlin in their online products.
Ok, everything sounds good, but there are some downsides, right? Yes, one of the things the Kotlin community is waiting for is tool support. Static code analysis tools are very important when you are working on a team. We’re still lacking in Kotlin. Of course you can build Kotlin projects, run tests, and so on. The basics are there, but tools like CheckStyle, PMD, And FindBugs that support the Java language are very important. It’s not yet supported in Kotlin (ok, code analysis is built into IntelliJ, but that’s not enough).
So if you work in a large team, static analysis tools are important in your day to day work (as they should be), and you need to think about that. If you work in a small team, you can control everything that happens.
Overall, Kotlin is great, you’ll have a lot more fun with Kotlin, and you’ll be much more productive (at least than developing Android in Java). There are still issues with static code analysis tools, but if you can get away with them, try Kotlin. You’ll love it! 😉
11. Nelson Glauber
Kotlin is an impressive language, and the features of the language are amazing: it removes a lot of boilerplate code that the Java language requires. Not to mention the fact that the vast majority of functional libraries on the market (written in the Java language) are fully Kotlin compatible. Another thing that makes the language easy to adopt is its perfect and stable compatibility with Android Studio.
For Java/Android developers (this may not be true for newcomers), the learning curve is gentle. I started learning Kotlin last year by reading Antonio’s book [12] (which is great, by the way), and since then I’ve been using the language in my personal projects and presentations.
Unfortunately, I haven’t had the opportunity to use it in an online production, but I have no doubt that Kotlin is mature enough to use it effectively in large projects.
In my opinion, the only reason not to use Kotlin is that once you start coding in Kotlin, you will no longer want to code in Java 🙂.
12. Ryan Harter
About a year ago, I started writing all my new code in Kotlin, and after some experimentation, I found that it was stable, and that the benefits of several features offered by the language were worth the switch. Thanks to the interoperability of Kotlin and Java, I can fall back to using Java for anything I don’t already know how to do with Kotlin.
Kotlin’s extended function language feature simplifies my workflow the most, even if it’s simple. In my graphics work, I do a lot of math and matrix manipulation, which means I use a lot of tool classes. Extension functions [13] greatly simplify code writing and make the code more refined. On the basis of the original object-oriented programming, mixed with the support of functional programming, make the work more pleasant.
My biggest tip for developers considering switching to Kotlin is to remember that Kotlin and Java are not either-or. Instead, Kotlin works well with existing Java code, so you can start experimenting with Kotlin step by step.
13. Ubiratan Soares
From a developer’s experience, Kotlin is the future of Android app development.
Kotlin’s impact on Android development is very similar to Grade’s impact on Android three years ago. As the Android developer community, we should embrace Kotlin, spread the word about Kotlin, and get a lot of developers to use Kotlin, because we deserve a better way to develop apps that meet the needs of our users and get good results in our work.
14. Philippe Breault
Kotlin is a clean SLATE for Android developers.
I like what it does with lambda expressions, allowing the compiler to inline lambda, when it works, allowing us Android developers to use it in tight loops, which generally avoids instantiating new objects.
Simple features, such as not needing a semicolon at the end of an expression, are also important. If assigning a value to a variable on the same line does not require typing the variable’s type twice; Use properties instead of getters/setters methods and so on. These features make code easier to read.
The only feature I would like to see improved is the interoperability between the Android Gradle plugin and the Kotlin plugin. Mixed use of the two is often problematic at this stage.
That being said, every Android developer should keep an eye on the language and try to use it.
15. Iñaki Villar
Kotlin brings new cool concepts to the Android platform, rather than just writing classes and activities in another language.
We are currently porting the automation framework to Kotlin, and we are enjoying how to define our OWN DSLS declaratively and allow developers and testers to program test code more smoothly [14].
16. Dan Lew
Kotlin is able to write more concise and understandable code than Java without sacrificing performance or security. Kotlin eventually compiles to bytecode and thus performs just as well as Java, with the same compile-time checks as Java (and built-in null-type checks that Java doesn’t have). More importantly, Kotlin’s language features and standard library functions make it possible to write concise and efficient code.
In addition, Kotlin has a strong ecosystem. Of course, native tool support from JetBrains is good, but beyond that, the language is being actively supported and improved, and JetBrains has not made incompatible changes with each Kotlin upgrade. And Kotlin works well with Java, making the transition from Java to Kotlin easy.
Finally, as an Android developer, I like Kotlin for another important reason: Kotlin’s ability to upgrade independently of Android versions. Because the Java language’s capabilities are bundled with the Android operating system, developers often miss out on language features and standard library apis in newer versions of Java. By contrast, when a new version of Kotlin is released, you can start using the language features of the new version.
17. Enrique López Mañas
I made the transition to Android development naturally as a Java developer, and since both languages are universal, I decided to give it a try. It was a meaningful choice, for me personally, in 2009. Java was born in 1995, and since then, several new versions have been released that add to and improve on the features of the original language. The current version is Java 8. Java was designed 22 years ago, and given the speed of technological change, Java is an immortal language, but it also has some serious downsides. As a developer, I often try out other languages. The language that most obviously addresses some of Java’s shortcomings is Scala. The turning point was when I saw languages like Swift in practice. I’ve also been writing code for iOS, and have noticed how Swift overcomes language features with obvious drawbacks like null types, opening up a lot of issues THAT I’ve been ignoring in the Java language.
The Android platform natively supports all Java 7 language features and some Java 8 language features due to the nature of the original design. The Android platform lags far behind other platforms that use the Java language. Kotlin stepped in to fill the void.
Kotlin is a modern programming language (version 1.0 was released in February 2016). It was originally intended to compensate for Java’s shortcomings, as the Scala language does, but solved some of the problems (for example, compile time).
JetBrains has done a great job optimizing Kotlin, and in its most recent release, Kotlin’s compile time has improved significantly. As a Kotlin newbie, here are the answers to some of the initial questions THAT came to my mind:
- Interoperability with Java: Kotlin can interact directly with Java classes, as well as in other ways. The most basic point: I do want to reuse the old code repository and introduce Kotlin.
- Conversion tools: While you can’t blindly trust the automatic java-to-Kotlin conversion, it’s a great feature. When I convert a Java class to a Kotlin class, I can easily reuse 60 to 70 percent of the resulting code. Instead of converting the entire code base from Java to Kotlin at once, I follow small iterations. It also takes less time to review the transformed code.
Going back to Kotlin itself, after years of development in Java, it feels great to try something new with Kotlin. If you’re a Java developer, Kotlin’s syntax is very natural to you. If you’re a Swift developer, you’ll feel the same way, and you’ll easily understand some of Kotlin’s key concepts like null types. Other features of Kotlin that caught my attention:
- Empty types: It’s tempting to tell your business people that you can avoid two-thirds of the anomalies in your product. Until you start using Kotlin, you don’t realize how bad it is to have no null types in Java.
- Functional programming: Yes, Kotlin supports functional programming, just as Scala does.
- Default and named parameters: Again, if you haven’t tried this feature before, you’ll never know how valuable it is. In Kotlin, you can set default values for a function’s parameters and give each parameter a name. This exponentially increases the readability and readability of the code.
- Smart cast: tired of using
instanceofDo a type check and then do a cast? It always seems like a very redundant step that could have been easily prevented. Kotlin automatically implements these steps for you.
Koltin also has a bunch of features that could take several articles to list and cover in depth. To sum up: Koltin is a language designed to complement and perfect Java. The learning curve for Java developers is very flat. It’s not an either-or issue, because you can use both Java and Kotlin in your Java repository. Kotlin will improve your productivity, and in the medium to long term, it will make you a better programmer.
[1] : developers.google.com/experts/all… ↩
[2] : antonioleiva.com/kotlin ↩
[3] : antonioleiva.com/nullity-kot… ↩
[4] : antonioleiva.com/kotlin-andr… ↩
[5] : antonioleiva.com/kotlin-inte… ↩
[6] : antonioleiva.com/data-classe… ↩
[7] : try.kotlinlang.org/ ↩
↩ [8] : www.settleup.info/
[9] : antonioleiva.com/classes-kot… ↩
[10] : antonioleiva.com/create-firs… ↩
[11] : kotlinlang.org/docs/tutori… ↩
[12] : antonioleiva.com/google-kotl… ↩
[13] : antonioleiva.com/kotlin-andr… ↩
[14] : antonioleiva.com/unit-tests-… ↩