วีดีโอ

Thanks Dave, these videos are so good. I have been using Kotlin in old Java ways, not really using the language features.

Thanks Dave! Your Kotlin content is Gold.

All very interesting, but a double-edged sword. The usefulnes is limited and comments here prove that it is widely unknown. I understand that this may be a product out of genericity and completeness, but it in my book a language is a means of communication between developers. What I write, another needs to understand. If they have to ponder on a piece of code due rarely used idoms, it slows them down and they might miss crucial implications (here: return value logic.) Don't get me wrong, though, it sure is an interesting corner of the language to explore.

There's a nice rule of thumb for `return` statements for that case with the inline lambda returning the `main` function: a `return` statement always returns the closest `fun`; In the case of the return inside the inlined lambda call, that is the `main` function, and for the anonymous function, it has its own `fun` so it returns there.

Best Kotlin content! Thanks Dave

The state class implementations should have context. In this case User class as parameter. And you shouldn't call print in state class, but rather call user class methods. This is really misleading. Print is just inner implementation of user class. Thanks anyway for sharing your experience

I feel like the android-maps-compose library does a better job here. It keeps the slot APIs at it is, but introduces a new annotation (called @GoogleMapComposable) that restricts you to only use this library's composables. For example: ```kotlin @Composable fun MapPage() { GoogleMap { // I can use this since it's marked with @GoogleMapComposable AdvancedMarker() // I cannot use this since it's not marked with @GoogleMapComposable Box() } } ``` Using classes to depict views in my opinion breaks Compose's functional approach of depicting a view-tree and goes more into the old XML View's class based domain.

This is a little bit advanced for me

After watching your video, I feel my code was totally shit

not true but: - java is academic driven -> programmers are students -> dont trust students, you have to put them under tutelage - scala is community driven -> programmers are teenagers when parents are away over weekend -> house get destoryed but in a creative way - kotlin is company driven -> programmers are costumers that are served and gerrymandered (in a good way) -> if you care about customers, especially in mid life crisis, you dont show them everything you have, otherwise you lose them when they become teenagers without parents ----------- i like that kotlin released me from java imprisonment, but i fear that when you are free, you are free to make more mistakes. Strong antetypes are needed to replace java prohibition by natural kotlin authority in freedom. In this video are a lot of example where authority is needed to make people not to use them without really good reason. When java is right at one thing then it is worship of holy idiomaticism. The big scala mistake was already done, no need to repeat it. But still good to know all those things, there are valid corner cases for every feature.

A great video again. 10.3.3 Anonymous functions: Local returns by default (Kotlin in action 2nd ed) "A. f. mainly shorten code that has a lot of early return statements, which would need to be labeled when using the lambda syntax." and "despite the fact that an a. f. looks similar to a regular function declaration, it's another syntactic form of a lambda expression."

I've been writing kotlin since 2018 and never came across this syntax till today :O

Why does your every video makes me feel that I know nothing about Kotlin 😂

I thought I knew everything about Kotlin syntax, but every new video of yours shows me something new. This language is awesome!

Anonymous functions work great with currying: fun greet(greeting: String) = fun (name: String) { println("$greeting, $name") } greet("Hello")("Dave") -> Hello, Dave val goodbye = greet("Goodbye") goodbye("Dave") -> Goodbye, Dave Looks more natural than with lambdas: fun greet(greeting: String) = { name: String -> println("$greeting, $name") }

Great video, I hope someone comments with a use case that you didn't think of, but I'm guessing it's just a case of syntactic sugar. So many people used the lambda syntax that it got workarounds to make it work like an anonymous function, rather than leaving them distinct.

TIL... Continue with the awesome content

This video is incredible ! I love your way of explaining things, we really feel you have a passion for that. I wanted to know what do you think about uniform function call from some languages like Nim ?

Hey Dave! I just wanted to say thank you for your wonderful book and videos. It really helps!

Great video! Do you have any resources or plans on using Socket Servers within kotlin? After learning all these things i’m looking into sockets for sending “commands” between my projects to act upon!

Your videos are crazy, you are cazy! In a good way!

10:34 how did this convert happen?

3:47 What the heck happened? Can you explain how to do it

This is all cool and clever but if I ever saw this in a PR, I was kick it back.

Amazing video, thanks for sharing :) i have a question for the last example, using Lamdas with receivers u can pretty do everything extension function do ? If so what is the difference between them ?

why not you become kotlin team lead, senior manage CEO , CTO and all other position at jet brains

really interesting one. Some things are really ez in kotlin, but some things are blewing my mind still to this day. Thank you Dave. Really Gucci stuff.

Great video as usual! Looking back, I used the implicit switching between extension and non-extension functions many times before without even realizing it! Also didn't know you could take references to property setters/getters, that's pretty neat!

Thanks!

I just realized that I don't know shit about Kotlin functions...

Damn that’s neat! My mind was racing with practical applications to try out

I like that you use one line property delegation by: val length get() = text.length I switched to an even shorter form: val length by text::length Advantage is that it is still one liner for var properties.

Great stuff, as usual! Thank you so much, Dave!

thumb up

Every time I think I will know everything in the video, you surprise me! I've always wanted to know if using these types of references are we doing any kind of reflection or not, since the symbol is the same

Thank you

Wow thank you.

This is fun 😀

Just when I thought I knew everything about function types

you're good!!! 🤣

Thanks, from Vietnam😘

Great explanation ❤. You deserve more subscribers

37:58 I've actually set up my keyboard such that IJKL are my arrow keys system-wide when pressed with the right-side command key (would be Alt Gr/right-side alt on Windows). I got used to it really quickly and now I feel noticeably faster navigating anywhere on my computer.

best explanation

I don’t see any benefit here, slot pattern is make it more open but here we are restricted to only ToolbarButton. Why not just use toolbarText in Toolbar composable?

Nice. I hate documentations. Thats another way to rip off documentation and replace it by self explaining coded rules.

Didnt know that, Kotlin is awesome. IntelliJ is awesome. Jetbrains is awesome. Your videos are awesome.

There is an excellent book called "Secure by Design" I believe this approach reduces the number of bugs during development.

Hi Dave👋 Thank you for your efforts, thank you for your efforts