After a brief discussion of the first 3 trends, I will focus on the last 7. For each one, I will first show how it will affect Kotlin and then I will compare the change it will bring with a similar situation in Java.
Finally, at the end of this article, you should have a better picture of whether Kotlin is going to be relevant for another 5 years or not. Of course, if things go as planned (a big “if”, as usual), things might look different from what we can predict today.
Here is this Global Trend That Will Affect Kotlin Programming in 2023:
1. Hardware advancements in 2025
Your smartphone will feature a new technology called H-RAM, which basically consists of adding an extra layer on top of DRAM that would enable 1000 times more storage space than DRAM; instead of storing information into transistor cells, information is stored into molecules. Although nothing is certain yet about when this technology will be available to consumers, it should come around 2020-2021 if things go as planned.
In the Java world, this technology would have been very valuable for data centers as they’ll be able to upgrade hardware easily – instead of having to carefully choose what exact DRAM size each server should have, they could just let them use a much larger H-RAM device and save money on the hardware itself. The way cloud providers work nowadays makes that decision somewhat irrelevant anyway because you can always add more servers whenever you need.
On the consumer side, however, this technology won’t see a huge impact in 2025 since H-RAM devices are unlikely to replace normal storage devices anytime soon. In other words, even though your smartphone or laptop might have a 32TB H-RAM device inside, you’ll hardly be able to make use of it – most likely you’ll still buy external hard disks or SSDs for your data. You can take the assistance of the DBA administrator.
2. AI advancements in 2023
Today’s AI is mostly based on machine learning algorithms that are learning how to solve specific problems by themselves rather than being explicitly programmed to do so. Those algorithms are extremely good at what they were made for but only in the exact areas they were designed for i.e. they can’t really learn something else. As one example, if an image recognition algorithm is trained to recognize cats, it will most likely fail to recognize dogs because they are very different from each other both in terms of appearance and behavior.
As you can guess, this will change in the future. An AI will be able to learn things that it wasn’t directly taught before. As one example, if you’ll show an AI a few photos of cats and dogs and ask it what animal is like another one (e.g. “show me an animal that’s like a cat but isn’t a cat”), it should know how to answer such question which means it has learned something new on its own without explicit instructions .
In Java world, this would be somewhat similar to evolving APIs for libraries or frameworks – adding new functionality while keeping old stuff working (so there won’t be any backward compatibility problems). Of course, since we’re talking about software developed by different people here, sometimes minor changes will break a lot of things and it’s not going to be that easy.
In the Kotlin world, however, things are going to change much smoother because we’re talking about a programming language here which is much easier to evolve than software libraries. Also, since we’ll have real “smart” code (i.e. code that knows what it’s doing), you as a developer won’t need to manually specify everything – sometimes your IDE can make changes for you or even figure out how to solve problems itself (see my blog post about this )
3. Tooling advancements in 2023
Today’s IDEs cannot really think like their users and they struggle with generic tasks such as figuring out the best way to put some given code into a class or what objects to create etc. As one example, an IDE might not know that given code belongs in the same class and thus tell you to add a new member when it should rather extract that code into its own method.
As another example, since different users have different naming conventions, it’s hard for IDEs to figure out which naming convention was used in any given case. One solution would be for the IDE itself to ask the user about it but then again, this is just putting another human between you and your tool so ideally we’d like our tools to understand us better than that – something I’ve talked about before on my blog.
Conclusion:
To solve these types of problems, IDEs will need smarter internal models so that they know how to automatically react to various changes in codebase which, of course, requires some sort of AI or at least machine learning.
