Kotlin Design Patterns and Best Practices: Build scalable applications using traditional, reactive, and concurrent design patterns in Kotlin, 2nd Edition Book Price in India, Specifications, Reviews & Offers. Buy online at Amazon.

A neats!
This guy is comparing optional with builder pattern??
what was he trying to say ,from the 13:45 to 13:55
Why on earth do people insist of keeping Singleton around as a proper design pattern? Yes, it's a pattern, but a very bad one. If you need a single instance of something in your app, create in main() and pass it around, or use some kind of registry to look it up ... :)
@18:30 Optionals are not self explanatory but Dagger is OK?
at 10:09 the function can be an expression one -> less lines
Should be called „convert java antipatterns to kotlin“ (and explain the result incorrect)
A question mark isn't the Elvis operator.
Talk starts at 05:26
I guess he doesnt even know what he's talking about at all...
Thanks for the informative session. Could you share the whole presentation in github for future reference please?
0:49 Singleton 2:46 Factory 5:04 Builder 8:31 Facade 9:44 Dependency Injection 12:30 Adapter
I'd like to express to some of the less experienced viewers why one of your comments on builder patterns in Kotlin is a bit inaccurate. Not wrong though. I'm referring to using named args to simulate a builder pattern. While this can be very useful and is likely a good idea in some builders. The builder pattern is used to create complex objects. The point of it is that you don't always have everything you need at the time you call a constructor. With your way the developer has to make sure all required dependencies are before calling the constructor as the object is meant to be immutable (or very close to it) once created. This is why a builder object is made. The values can change and be set after the builder objects creation. This builder can be passed around to configuration classes. That or the creation of a dependency can happen, then the builder set function is called, then you create the next dependency and so on. One other benefit to the builder object is that it can throw an error for objects that aren't configured correctly. Usually the Builder constructor has the minimum requirements for the .build() function to work but this isn't always true. The androidx biometric library has a good example of the builder throwing an exception for improperly configured builders. If you try to set the prompt cancellation button text while also trying to set device credential as an option for the prompt then these two states can't exist at the same time as they occupy the same space on the biometric prompt. So an error is thrown. In my eyes this is poor design so that leads into my next paragraph. Where I agree with your approach is that the builder to me (purely opinion at this point) is a bit of an anti pattern. It lets you get away with bad design. If you can't create the dependencies before calling the constructor then maybe you need to refactor some stuff or maybe the object is a bit too complex and doing too much. As with everything in programming it is knowing your requirements and which tool (pattern in this case) to get a job done. There is no one solution and that is why I am not saying you are wrong for your Kotlin approach to builders. Just wanted newer devs to understand the use of the Builder object.
Nice
Thank you for so much information)
can you create a video for "keyboard productive hacks in android sudio"? i know few of them I like: 1. ctrl + Alt + Shift + up/down to go the edited location in the same page 2. double shift to search anything.
Loved it! I like how easy is to understand from what you explain.
Is Observer one of them and very used in Android too? Or im wrong?
So a note about the Kotlin way of doing builder, it isn't actually the builder pattern, b/c it doesn't hide the concrete implementation details from the end user. A proper builder pattern can have constructor parameters of the built class change name/order/etc. and not be visible to the end user. However, in the kotlin methodology, you are directly exposing the constructor to the end user. Even with parameter naming, you have an easier chance of making compile breaking changes if you do this vs hiding the details inside the builder.
Thank you bro.
great information it's help full for me great effort bro
stupid question In frontend web dev why we need to learn design patterns because I am learning react and never saw this things....
U are awesome bro.. please grow your beard.. you look damn handsome in that look. Apart from this, your biggest fan. You teach and explain things in different level. Love it bro . 😊
Can you please show some examples of adapter pattern other than recycler view adapter. Literally i couldn't adapt the adapter pattern :P
😃
Just give me my freakin hamburgers! Thank you
perfact
Great video!! Can you create a video about how we can organize a Gradle in a big app o maybe how use tasks. For example a Jacoco task to use in sonar
Hey Philipp, thank you for the excellent video - your explanations are really nice to watch and I like that small errors are left in (such as in the return statement in the 'factory' example), however I really, really, REALLY struggle with dependency injection. I just can't understand how I would implement it or how I would change my app to use this pattern.. I hope I am not alone! I would therefore really appreciate it if you would do a video where you start with a simple existing design that you convert to use dependency injection to show the benefits of this methodology.. thank you!! (you did ask for suggestions!). Oh and I work in Kotlin so I'm happy I can avoid the builder pattern!!
it's awesome, thank you so much
Thank you so much bro! I recently discovered your channel and it's super helpful! Great content!