Update best-practices.md

documentation/best-practices.md

@@ -6,26 +6,55 @@ This guide provides best practices to help you use AppState efficiently and effe
 
 AppState is versatile and suitable for both shared and localized state management. It's ideal for data that needs to be shared across multiple components, persist across views or user sessions, or be managed at the component level. However, overuse can lead to unnecessary complexity.
 
+### Recommendation:
+- Use AppState for critical application-wide data and shared state, but avoid using it for small, localized data that doesn't need to persist or be accessed across different components.
+
 ## 2. Maintain a Clean AppState
 
 As your application expands, your AppState might grow in complexity. Regularly review and refactor your AppState to remove unused states and dependencies. Keeping your AppState clean makes it simpler to understand, maintain, and test.
 
+### Recommendation:
+- Periodically audit your AppState for unused or redundant states and dependencies.
+- Refactor large AppState structures to keep them clean and manageable.
+
 ## 3. Test Your AppState
 
 Like other aspects of your application, ensure that your AppState is thoroughly tested. Use mock dependencies to isolate your AppState from external dependencies during testing, and confirm that each part of your application behaves as expected.
 
+### Recommendation:
+- Use XCTest or similar frameworks to test AppState behavior and interactions.
+- Mock or stub dependencies to ensure AppState tests are isolated and reliable.
+
 ## 4. Use the Slice Feature Wisely
 
 The `Slice` feature allows you to access specific parts of an AppState’s state, which is useful for handling large and complex state structures. However, use this feature wisely to maintain a clean and well-organized AppState, avoiding unnecessary slices that fragment state handling.
 
+### Recommendation:
+- Only use `Slice` for large or nested states where accessing individual components is necessary.
+- Avoid over-slicing state, which can lead to confusion and fragmented state management.
+
 ## 5. Use Constants for Static Values
 
 The `@Constant` feature lets you define read-only constants that can be shared across your application. It’s useful for values that remain unchanged throughout your app’s lifecycle, like configuration settings or predefined data. Constants ensure that these values are not modified unintentionally.
 
+### Recommendation:
+- Use `@Constant` for values that remain unchanged, such as app configurations, environment variables, or static references.
+
 ## 6. Modularize Your AppState
 
 For larger applications, consider breaking your AppState into smaller, more manageable modules. Each module can have its own state and dependencies, which are then composed into the overall AppState. This can make your AppState easier to understand, test, and maintain.
 
+### Recommendation:
+- Divide AppState into logical modules to manage state and dependencies at a more granular level.
+- Compose modules into the main AppState to maintain modularity and separation of concerns.
+
+## 7. Leverage Just-In-Time Creation
+
+AppState values are created just in time, meaning they are instantiated only when accessed. This optimizes memory usage and ensures that AppState values are only created when necessary.
+
+### Recommendation:
+- Allow AppState values to be created just-in-time rather than preloading all states and dependencies unnecessarily.
+
 ## Conclusion
 
 Every application is unique, so these best practices may not fit every situation. Always consider your application's specific requirements when deciding how to use AppState, and strive to keep your state management clean, efficient, and well-tested.