In the first 2 days, we cover general best practices and class design, and the 3rd day is dedicated to code efficiency.

The most important best practices we'll be covering are:

Safety

• Limit mutability
• Eliminate platform types as soon as possible
• Do not expose inferred types
• Prefer composition over inheritance
• Make it clear that top-level functions are not member functions

Readability

• Design for readability
• Use operator overloading methods as their names indicate
• Consider naming arguments
• Avoid returning or operating on Unit?
• Specify variable type when it is not clear
• Consider referencing receiver explicitly

Reusability

• Do not repeat knowledge
• Do not repeat common algorithms
• Reuse between different platforms by extracting common modules

Design abstractions

• Each function should be written in terms of a single level of abstraction
• Define abstractions
• Respect abstraction contract
• Restrict visibility
• Use abstraction to protect code against changes
• Consider wrapping external API

Objects creation

• Consider factory functions instead of constructors
• Consider primary constructor with named optional arguments
• Consider defining DSL for complex object creation

Class design

• Use data modifier to represent a bundle of data
• Use function types instead of interfaces to pass operations and actions
• Do not use properties to express behavior
• Respect contract of equals
• Respect contract of hashCode
• Respect contract of compareTo
• Respect contract of arithmetic operators

Make it cheap

• Avoid unnecessary object creation
• Consider inline modifier for higher-order functions
• Eliminate obsolete object references
• Use tail recursion to achieve efficient recurrence

Efficient collection processing

• Prefer Sequence for bigger collections with more than one processing step
• Consider Arrays with primitives for performance critical processing
• Consider using mutable collections

On this way, we'll also review more advanced topics including:

• Collections
• Delegates
• Platform types
• Interoperability with Java
• Typing system
• Generics
• Operator overloading
• DSL creation
• Functional programming

During the 3rd day we additionally cover:

• Inline classes
• Computational complexity