software-architecture-monolith

# Monolithic Architecture archetypes: tactical, educational anti_triggers: microservices response_profile: verbosity: medium directive_strength: high abstraction_level: tactical Guides the design and implementation of monolithic architecture, focusing on best practices and pitfalls in monolithic systems. ## When to Use ### Key Takeaways - Use this skill when building applications that require fast development cycles. - Suitable for applications that are less complex and easier to manage with traditional patterns. ### Archetypes - **Tactical**: Helps guide application developers in making choices around monolithic designs. - **Educational**: Offers insights into best practices for building in a monolithic style. ### Anti-Triggers - **Microservices**: Avoid contexts that suggest migration to services without clear benefits. ### Response Profile - **Verbosity**: Medium - **Directive Strength**: High - **Abstraction Level**: Tactical - When building small to medium-sized applications. - For applications that require a quick go-to-market strategy. - When simplicity is prioritized over scalability. ## Core Workflow 1. **Model the Application** – Design the complete application in a single repository. 2. **Define Interfaces** – Create clear dependencies within the app. 3. **Optimize as Necessary** – Profile and refactor for performance improvements. ## Implementation Patterns ### Additional Examples of Monolithic Architecture 1. **Order Management Example** – Here’s an example of managing orders within a monolithic architecture: ```python class OrderService: def __init__(self): self.orders = [] def add_order(self, order): self.orders.append(order) # Logic to persist order in a database print(f'Added order: {order}') # Example of Order and OrderService classes usage: order_service = OrderService() order_service.add_order({"item": "Laptop", "quantity": 1}) ``` 2. **Product Catalog Example** – A common approach for managing product catalogs: ```python class Product: def __init__(self, name, price): self.name = name self.price = price class ProductService: def __init__(self): self.products = [] def add_product(self, product): self.products.append(product) # Logic to save product to the database print(f'Added product: {product.name}') # Example usage: product_service = ProductService() product_service.add_product(Product('Smartphone', 599.99)) ``` 3. **Performance Optimization Example** – Using efficient memory management and caching strategies: ```python class Cache: def __init__(self): self.data = {} def get(self, key): return self.data.get(key) def set(self, key, value): self.data[key] = value # Logic for caching results ``` 4. **Best Practices** – A guide for scalability and maintainability of the monolith: - Implement logging and tracing strategies to detect bottlenecks. - Define clear module boundaries and document architectural decisions. - Ensure that performance is regularly reviewed and optimized as the application grows. ### Enhanced Examples of Monolithic Architecture 1. **Order Management Example** – Here’s an example of managing orders within a monolithic architecture: ```python class OrderService: def __init__(self): self.orders = [] def add_order(self, order): self.orders.append(order) # Logic to persist order in a database print(f'Added order: {order}') # Example of Order and OrderService classes usage: order_service = OrderService() order_service.add_order({"item": "Laptop", "quantity": 1}) ``` This shows how orders can be added and managed directly within a single application flow. 2. **Product Catalog Example** – A common approach for managing product catalogs: ```python class Product: def __init__(self, name, price): self.name = name self.price = price class ProductService: def __init__(self): self.products = [] def add_product(self, product): self.products.append(product) # Logic to save product to the database print(f'Added product: {product.name}') # Example usage: product_service = ProductService() product_service.add_product(Product('Smartphone', 599.99)) ``` 3. **Performance Optimization Example** – Using efficient memory management and caching strategies: ```python class Cache: def __init__(self): self.data = {} def get(self, key): return self.data.get(key) def set(self, key, value): self.data[key] = value # Logic for caching results ``` 4. **Best Practices** – A guide for scalability and maintainability of the monolith: - Implement logging and tracing strategies to detect bottlenecks. - Define clear module boundaries and document architectural decisions. - Ensure that performance is regularly reviewed and optimized as the application grows. ### Pattern 1: Modular Monolith ```python class Order: def __init__(self, item, quantity): self.item = item self.quantity = quantity class OrderService: def __init__(self): self.orders = [] def add_order(self, order): self.orders.append(order) # Persist order in a monolithic database ``` ## Constraints ### MUST DO - Keep architecture well-documented. - Separate concerns via modules within the monolith.