Oreilly – Kotlin in Action, Second Edition, Video Edition 2024-5

Published on: 2024-08-06 15:53:13

Categories: 28

Description

Kotlin in Action Second Edition Video Edition course. This video tutorial presents the book “Kotlin in Action, 2nd Edition” in visual form. In this course, the speaker reads the text of the book and at the same time, the content, images, codes, diagrams and text are displayed on the screen. This course is like an audio book that you can also watch as a video. Kotlin is a low-effort and highly productive programming language that is flexible enough to handle any web, mobile, cloud, and enterprise application. Java developers will appreciate the simple syntax, intuitive typing system, great tools, and support for functional style programming. Additionally, because Kotlin runs on the JVM, it integrates seamlessly with existing Java code, libraries, and frameworks, including Spring and Android.

What you will learn

Expressions, functions, classes and data types in Kotlin
Functional programming in JVM
Kotlin standard library and default features
Writing clean and basic code
Kotlin expressions and functions, and classes and data types
Functional programming on the JVM
Kotlin standard library and out-of-the-box features
Write clean and original code
Combination of Kotlin and Java
Improve code reliability with null safety
Domain-specific languages
Coroutines and streams in Kotlin
Mastering the kotlinx.coroutines library
Combination of Kotlin and Java
Improve code reliability with null safety
Domain-specific languages
Coroutines and Streams in Kotlin
Mastering the kotlinx.coroutines library

This course is suitable for people who

They are familiar with Java programming language or other object oriented languages.

Kotlin in Action Second Edition Video Edition course specifications

Publisher: Oreilly
Source: Roman Elizarov , Svetlana Isakova , Sebastian Aigner
Training level: beginner to advanced
Training duration: 15 hours and 59 minutes

Course headings

Part 1. Introducing Kotlin
Chapter 1. Kotlin: What and why
Chapter 1. Kotlin’s primary traits
Chapter 1. Areas in which Kotlin is often used
Chapter 1. The philosophy of Kotlin
Chapter 1. Using the Kotlin tools
Chapter 1. Summary
Chapter 2. Kotlin basics
Chapter 2. Encapsulating behavior and data: Classes and properties
Chapter 2. Representing and handling choices: Enums and when
Chapter 2. Iterating over things: while and for loops
Chapter 2. Throwing and catching exceptions in Kotlin
Chapter 2. Summary
Chapter 3. Defining and calling functions
Chapter 3. Making functions easier to call
Chapter 3. Adding methods to other people’s classes: Extension functions and properties
Chapter 3. Working with collections: varargs, infix calls, and library support
Chapter 3. Working with strings and regular expressions
Chapter 3. Making your code tidy: Local functions and extensions
Chapter 3. Summary
Chapter 4. Classes, objects, and interfaces
Chapter 4. Declaring a class with nontrivial constructors or properties
Chapter 4. Compiler-generated methods: Data classes and class delegation
Chapter 4. The object keyword: Declaring a class and creating an instance, combined
Chapter 4. Extra type safety without overhead: Inline classes
Chapter 4. Summary
Chapter 5. Programming with lambdas
Chapter 5. Using Java functional interfaces: Single abstract methods
Chapter 5. Defining SAM interfaces in Kotlin: fun interfaces
Chapter 5. Lambdas with receivers: with, apply, and also
Chapter 5. Summary
Chapter 6. Working with collections and sequences
Chapter 6. Lazy collection operations: Sequences
Chapter 6. Summary
Chapter 7. Working with nullable values
Chapter 7. Making possibly null variables explicit with nullable types
Chapter 7. Taking a closer look at the meaning of types
Chapter 7. Combining null checks and method calls with the safe call operator: ?.
Chapter 7. Providing default values in null cases with the Elvis operator: ?:
Chapter 7. Safely casting values without throwing exceptions: as?
Chapter 7. Making promises to the compiler with the non-null assertion operator: !!
Chapter 7. Dealing with nullable expressions: The let function
Chapter 7. Non-null types without immediate initialization: Late-initialized properties
Chapter 7. Extending types without the safe-call operator: Extensions for nullable types
Chapter 7. Nullability of type parameters
Chapter 7. Nullability and Java
Chapter 7. Summary
Chapter 8. Basic types, collections, and arrays
Chapter 8. Collections and arrays
Chapter 8. Summary
Part 2. Embracing Kotlin
Chapter 9. Operator overloading and other conventions
Chapter 9. Overloading comparison operators makes it easy to check relationships between objects
Chapter 9. Conventions used for collections and ranges
Chapter 9. Making destructuring declarations possible with component functions
Chapter 9. Reusing property accessor logic: Delegated properties
Chapter 9. Summary
Chapter 10. Higher-order functions:Lambdas as parameters and return values
Chapter 10. Removing the overhead of lambdas with inline functions
Chapter 10. Returning from lambdas: Control flow in higher-order functions
Chapter 10. Summary
Chapter 11. Generics
Chapter 11. Generics at run time: Erased and reified type parameters
Chapter 11. Variance describes the subtyping relationship between generic arguments
Chapter 11. Summary
Chapter 12. Annotations and reflection
Chapter 12. Reflection: Introspecting Kotlin objects at run time
Chapter 12. Summary
Chapter 13. DSL construction
Chapter 13. Building structured APIs: Lambdas with receivers in DSLs
Chapter 13. More flexible block nesting with the invoke convention
Chapter 13. Kotlin DSLs in practice
Chapter 13. Summary
Part 3. Concurrent programming with coroutines and flows
Chapter 14. Coroutines
Chapter 14. Concurrency the Kotlin way: Suspending functions and coroutines
Chapter 14. Comparing threads and coroutines
Chapter 14. Functions that can pause: Suspending functions
Chapter 14. Comparing coroutines to other approaches
Chapter 14. Entering the world of coroutines: Coroutine builders
Chapter 14. Deciding where your code should run: Dispatchers
Chapter 14. Coroutines carry additional information in their coroutine context
Chapter 14. Summary
Chapter 15. Structured concurrency
Chapter 15. Cancellation
Chapter 15. Summary
Chapter 16. Flows
Chapter 16. Cold flows
Chapter 16. Hot flows
Chapter 16. Summary
Chapter 17. Flow operators
Chapter 17. Intermediate operators are applied to an upstream flow and return a downstream flow
Chapter 17. Creating custom intermediate operators
Chapter 17. Terminal operators execute the upstream flow and may compute a value
Chapter 17. Summary
Chapter 18. Error handling and testing
Chapter 18. Error propagation in Kotlin coroutines
Chapter 18. CoroutineExceptionHandler: The last resort for processing exceptions
Chapter 18. Handling errors in flows
Chapter 18. Testing coroutines and flows
Chapter 18. Summary
Appendix A. Building Kotlin projects
Appendix B. Documenting Kotlin code
Appendix C. The Kotlin ecosystem