Inline functions - Kotlin Vocabulary 

I understand there might be restrictions in your job, but why don't you guys start using it in your own projects? The earlier you start the better and, in my option, the transition is inevitable when java samples or resources start to be neglected by Google.

@@ArturStaniec well we're taking that into consideration as we realize Kotlin is getting more and more popular and pushed by Google, it's just a joke to make people like me who have not fully mastered the logic behind the language 😂

@@ArturStaniec Imagine companies transitioning fully to kotlin and then, Google comes and announces kotlin is out and dart/flutter is in!

@@nadeemshaikh7863 It may be that you're joking but that is actually impossible. Flutter and Dart are completely independent runtime and implementation of components where Kotlin is just a language which compiles down to Java Bytecode essentially making it same as Java and using the native platform APIs and components

@@areebjamaliam You didn't get my point. I'm saying Google could or won't (more likely) to make flutter as the preferred way to make Android apps which would technically be fuchsia apps if Google transitions to fuchsia OS.

Because inlining adds extra bytecodes to your apk (increase apk size). Some prefer smaller apk size because for them the runtime overhead isn't a problem. I think this is why they provided it as a keyword as an option.

We're glad you think so Davide. Thank you for the support!

I hope you found the answer. Still I’ll clarify, the inline functions show at 2:52 have lambdas as parameters which is just a fancy way of writing a function.

@@zeusalmighty6740 What do you mean? Those are very simple functions, and they could be auto-inlined anyway during runtime. What's so special about them?

@@LiranBarsisa If you pass in the lambda, each time a new function is created, this would make it so it only occupies memory once.

@@zeusalmighty6740 Please explain. She said to avoid this in these cases, and yet I see "inline" for them. Why is that? Also, explain how could this be better than not putting "inline"? Show a sample snippet in which it behaves differently (with "inline" vs without it).

@@LiranBarsisa Plain kotlin won’t be enough to explain this. These are optimisations at byte-code level. I recommend you to make two functions one inline and other not inline and both take a function as parameter. Check the decompiled byte-code and also you can check the memory it uses.

reified keyword use to find out class parameter type name in compile time

I only came across this when accepting a suspend lambda as an argument in an inline function. I suspect it would be preferred over noinline but I'm not sure. Explanation would be really helpful!

@@JolanRensen I did the same, then tried to decompile that piece of code. It took about 40 mins of 100% CPU usage. At the end, I got java class which weight about 320 MB while origin was 2 KB :D

@@JolanRensen short answer, you need `crossinline` if you are passing in a lambda that you are invoking inside another lambda

Thanks for the kind words, Diego. Be sure to check out even more Koltin vocabulary with this playlist: goo.gle/2wHr94N 😎

very true, Kotlin gives flexibility of the C++ like inline, coroutines and so on, next big step will be manual alloc/dealloc objects and reference counting - really dead end. Just my subjective opinion - Kotlin should be clear and easier to understand then Java but on practice - Java is much more readable and has less complicated constructions.

As a Kotlin GDE, can you tell me why the compiler itself doesn't take care of this itself? Can't it figure out when functions should be inlined to gain the performance benefit?

@@MerthanE That's a good question. To some extent, the tooling can give some hints as to whether or not a function being inlined will help. This comes in the form of lint warnings that can let you know if there will be a performance benefit or not from adding the inline modifier. Beyond that, in the realm of actually optimizing the code for us, I'm not sure. One challenge with this could be that the compiler doesn't know how a function will be used, and therefore can't necessarily make an educated decision about whether to modify the code for us. A large function, inlined once, might have minimal impact to performance and generated code size. Or, that same function might be used many times and greatly increase the amount of generated code. Because of that, perhaps that tradeoff is simply left to the developer?

@@goobar makes sense as developers know how functions will be used in the future, but at the same time... the compiler should know how functions are called while compiling so dynamically making them inline or not seems like it would be possible. But this is pretty specific, no idea how the compiler actually handles this, just thought that this might be one of the things that are possible improvements under the hood. I also don't know examples where the compiler couldn't figure it out (but a developer could) but there might be some

if there is a pole then we vote.

Stackoverflow

Reply on my Twitter question: twitter.com/FMuntenescu/status/1219222484542808065?s=20

@@bagadeshkumarr9502 How long is it?

I might be able to help answer that... When we create a higher order function, each function parameter is treated as an instance of a Function class in the underlying bytecode. This means, each time we invoke the higher order function, we are instantiating a new object. If we are operating on some large collection, this could means 100s or 1000s of allocations. By inlining the function, we avoid the need for this Function class allocation. So for non-higher-order classes, this performance increase doesn't apply. And for the regular execution of the code, the compiler already does a good job optimizing so the gains are minimal.

@@goobar Thank you for your answer! I thought I already knew the *inline* keyword from C++, and didn't even wanted to watch this video. 😀

short answer, you need `crossinline` if you are passing in a lambda that you are invoking inside another lambda

@@Zhuinden Thanks hope others will see your comment

Extension functions, functional types as part of the language (without being bound to minSdk 26), and maybe typed nullability

But for a more... contrived, but real? example, this one line of code (github.com/Zhuinden/livedata-combinetuple-kt/blob/master/livedata-combinetuple-kt/src/main/java/com/zhuinden/livedatacombinetuplekt/LiveDataCombineTuple.kt#L752 ) would be 16 lines of code EACH in a Java file. So I personally also really like tuple decomposition for data classes (where applicable).

It is an extension function on the SharedPreferences.Editor class that accepts no parameters and returns nothing. The implementation of this function will be passed as a parameter to the edit method.

search for lambda with receiver, & i prefer to read first about Extension functions.

Hey there! We'd love to lend a helping hand 😁 Have you checked out the Android Basics in Kotlin course? There are even earnable badges, so you can show off your Kotlin love 😍: goo.gle/3ekZInO

because if the inline method receives just one parameter, which needs an instance, this must be noinline. Therefore, an instance will always be created every time the inline method is called. Check the min 3:39 :)

No

@BattleNo0bFaiLTV It's look like you made it more complex

Huge company with multiple teams all working on different projects. I'm fairness too, Google didn't create Kotlin, they simply decided to make it a first party language for Android after the community decided they wanted it.

thank you Mr Goobar You are really fairness but as Mobil developer it is really difficult to decided which language I should master with all this Features in every language

Kotlin is not created by Google, it's created by JetBrains.

​@@hamzahalhajji7032 Uh, both are completely different things. Kotlin is for easing Native Android Development and uses the underlying platform and components and Flutter/Dart is for multiplatform development using their own rendering engine to show the UI. The choice is not between Kotlin and Dart at all. It is between Android Platform SDK or independent cross-platform rendering engine which completely ignores prior art and reimplements and mimics the underlying system. The choice is yours. One may lag behind and even get deprecated in future (flutter), where the other is literally the Android Platform itself. If in an impossible scenario, Kotlin gets deprecated, you can de-kotlinify it and convert it back to Java. Which you'll never be able to do in Flutter/Dart. Deprecation of the Platform SDK would mean the end of Android Platform itself, so it will never happen. And if it does, then Android will not be present itself, so Flutter v Native will be irrelevant

Then you get same performance overhead with higher order functions (anonymous classes) with no keyword like inline to optimize it and bail you out

Java would create the new object instance with no way out. Kotlin's solution is better in this case

@@Zhuinden xc. 🛁