The overarching design in Kiit involves an emphasis on simplicity, reasonably light-weight and modular components that can be used both on the Server Side, and on the Client ( Android ). This is also designed to be much more of a collection of libraries than a full-fledged framework, in order to keep components decoupled and support using as little or as much of the code as possible. With regard to programming style, there is also a strong preference towards pragmatic functional programming, immutability, and use of higher-order functions.
Standard Kotlin endorsed coding standards are applied via IntelliJ, Ktlint, and editorconfigs.
| 1 | Git | One flow is used as the branching model |
| 2 | Lint | Ktlint is currently used to format the code in projects. However, this is not currently automated and/or part of gradle. The linting process is done manually periodically as of now, but will later be aautomated. |
| 3 | Settings | An .editorconfig is placed in all projects to enforce certain settings. |
Philosophy, design goals, approaches and standards
| Tech | Built in Kotlin, for the JVM ( multi-platform coming later), and designed to be reusable for both Client ( Android ) and Server (Backend/APIs/Services). |
| Design | Library based approach instead of a "Framework". Structured into several modules so you can pick as little or as much as you want. |
| Standards | Check our coding standards |
| Approach | Simplicity and Practicality above all else |
| Components | Composable, single-purpose components as building blocks. Organized into various projects. |
| Portable | Designed for reasonably low vendor lock-in via a "library" based approach. |
| Minimal | Dependencies on external, 3rd-party libraries are kept to a minimum. Json Simple, OkHttp( for Http client ), Logback( Optional ), Micrometer ( Optional ) |
| License | See license. This is a Dual license, with support for Apache 2.0 for majority of users. |
| Style | Emphasis on immutability
and pragmatic functional programming as much as possible.
However, this is NOT a 100% purely functional code base, and there is NO category theory. |
There are thin abstractions over some infrastructure services such as Files, queues, docs. Currently, only AWS implementations are available for the infrastructure abstractions. However, in the future, support for Google and Azure cloud services may be implemented. Other services are using directly.
Refer to infrastructure
There is an emphasis towards pragmatic functional programming, without going towards a pure functional programming style. A heavy emphasis towards simplicity and readability over conciseness and cleverness. Generally speaking the following approaches are followed:
| 1 | Immutablity | Use val over var |
| 2 | Nulls | Avoid using !! on nullable types |
| 3 | Errors | Prefer functional error-handling via the results type and its aliases Outcome, Try, Notice, Validated over exceptions. |
| 4 | Types | Prefer strong types/enums over “string” types |
| 5 | ADT | Use Algebraic Data Types by leveraging sealed classes in conjuction with pattern-matching |
| 6 | Pattern Match | Use Kotlin when for pattern matching where applicable |
| 7 | Concurrency | Use Kotlin Coroutines where applicable |