Effective Kotlin

Introduction: Be pragmatic

1. Who is this book for?
2. Code Sources

Part 1: Good code

Chapter 1: Safety

1. Item 1: Limit mutability
2. Item 2: Eliminate critical sections
3. Item 3: Eliminate platform types as soon as possible
4. Item 4: Minimize the scope of variables
5. Item 5: Specify your expectations for arguments and state
6. Item 6: Prefer standard errors to custom ones
7. Item 7: Prefer a nullable or Result result type when the lack of a result is possible
8. Item 8: Close resources with use
9. Item 9: Write unit tests

Chapter 2: Readability

1. Item 10: Design for readability
2. Item 11: An operator’s meaning should be consistent with its function name
3. Item 12: Use operators to increase readability
4. Item 13: Consider making types explicit
5. Item 14: Consider referencing receivers explicitly
6. Item 15: Properties should represent a state, not a behavior
7. Item 16: Avoid returning or operating on Unit?
8. Item 17: Consider naming arguments
9. Item 18: Respect coding conventions

Part 2: Code design

Chapter 3: Reusability

1. Item 19: Do not repeat knowledge
2. Item 20: Do not repeat common algorithms
3. Item 21: Use generics when implementing common algorithms
4. Item 22: Avoid shadowing type parameters
5. Item 23: Consider using variance modifiers for generic types
6. Item 24: Reuse between different platforms by extracting common modules

Chapter 4: Abstraction design

1. Item 25: Each function should be written in terms of a single level of abstraction
2. Item 26: Use abstraction to protect code against changes
3. Item 27: Specify API stability
4. Item 28: Consider wrapping external APIs
5. Item 29: Minimize elements’ visibility
6. Item 30: Define contracts with documentation
7. Item 31: Respect abstraction contracts

Chapter 5: Object creation

1. Item 32: Consider factory functions instead of constructors
2. Item 33: Consider a primary constructor with named optional arguments
3. Item 34: Consider defining a DSL for complex object creation
4. Item 35: Consider using dependency injection

Chapter 6: Class design

1. Item 36: Prefer composition over inheritance
2. Item 37: Use the data modifier to represent a bundle of data
3. Item 38: Use function types or functional interfaces to pass operations and actions
4. Item 39: Use sealed classes and interfaces to express restricted hierarchies
5. Item 40: Prefer class hierarchies instead of tagged classes
6. Item 41: Use enum to represent a list of values
7. Item 42: Respect the contract of equals
8. Item 43: Respect the contract of hashCode
9. Item 44: Respect the contract of compareTo
10. Item 45: Consider extracting non-essential parts of your API into extensions
11. Item 46: Avoid member extensions

Part 3: Efficiency

Chapter 7: Make it cheap

1. Item 47: Avoid unnecessary object creation
2. Item 48: Consider using object declarations
3. Item 49: Use caching when possible
4. Item 50: Extract objects that can be reused
5. Item 51: Use the inline modifier for functions with parameters of functional types
6. Item 52: Consider using inline value classes
7. Item 53: Eliminate obsolete object references

Chapter 8: Efficient collection processing

1. Item 54: Prefer Sequences for big collections with more than one processing step
2. Item 55: Consider associating elements to a map
3. Item 56: Consider using groupingBy instead of groupBy
4. Item 57: Limit the number of operations
5. Item 58: Consider Arrays with primitives for performance-critical processing
6. Item 59: Consider using mutable collections
7. Item 60: Use appropriate collection types

Dictionary