name: kotlin-development
description: Kotlin development guidelines with best practices for clean code, naming conventions, function design, and data handling

Kotlin Development Best Practices

General Principles

• Use English for all code and documentation
• Always declare the type of each variable and function
• Avoid the any type; create necessary types instead
• No blank lines within function bodies

Naming Conventions

Case Standards

• PascalCase: Classes, interfaces, enums
• camelCase: Variables, functions, methods, parameters
• UPPERCASE: Environment variables, constants
• underscores_case: Files and directories

Naming Guidelines

• Start each function with a verb (get, set, create, update, delete, etc.)
• Use complete words over abbreviations
• Allowed abbreviations: API, URL, i/j for loops, err, ctx, req/res/next
• Avoid magic numbers; define constants instead
• Boolean variables use prefixes: isLoading, hasError, canDelete

Function Design

Size and Responsibility

• Keep functions under 20 instructions
• Each function should have a single responsibility
• Extract logic into utility functions when complexity increases

Naming Functions

• Use verb-based naming that describes the action
• Prefix boolean-returning functions with is, has, or can
• Prefix void functions with action verbs like execute, save, send

Reducing Nesting

• Use early returns to handle edge cases first
• Extract nested logic into separate functions
• Employ higher-order functions (map, filter, reduce) to minimize loops
• Prefer arrow functions for simple operations; use named functions otherwise

Parameters

• Use default parameters instead of null checks
• When functions have multiple parameters, consolidate them into objects (RO-RO pattern)
• Keep parameter lists short (max 3-4 parameters)

Data Handling

Data Classes

• Use data classes for data structures
• Encapsulate primitive types in composite types when they represent domain concepts
• Validate data internally within data classes

Immutability

• Prefer immutability for data
• Use val for variables that don't change
• Use immutable collections when possible
• Create new instances instead of mutating existing ones

Classes and Objects

Size Guidelines

• Keep classes under 200 instructions
• Limit to fewer than 10 public methods
• Limit to fewer than 10 properties

Design Principles

• Follow SOLID principles
• Favor composition over inheritance
• Use interfaces for abstraction
• Keep classes focused on a single responsibility

Exception Handling

When to Use Exceptions

• Reserve exceptions for truly unexpected errors
• Don't use exceptions for control flow
• Catch exceptions only to:
• Fix an anticipated issue
• Add context before re-throwing

Best Practices

• Create custom exception types for domain-specific errors
• Include meaningful error messages
• Log exceptions at appropriate levels

Testing

Unit Tests

• Follow Arrange-Act-Assert convention
• Write unit tests for all public functions
• Use test doubles (mocks, stubs, fakes) for dependencies
• Name tests descriptively to document behavior

Acceptance Tests

• Follow Given-When-Then convention
• Test user-facing behavior and scenarios
• Keep tests independent and repeatable

Code Organization

• Group related functionality together
• Keep files focused and cohesive
• Use packages/modules to organize code by feature or layer
• Maintain consistent file structure across the project