Skip to content

Latest commit

 

History

History
185 lines (133 loc) · 9.88 KB

Tagging.md

File metadata and controls

185 lines (133 loc) · 9.88 KB

Tagging of Levels

Highest Level (System/Application)

At the highest level of the system or application, the following information should be tracked and distilled into concise tags or notes:

  1. Application Domain:

    • Tag the overall domain or industry the application belongs to.
    • Example tags: finance_application, healthcare_system, gaming_platform

  2. Application Type:

    • Tag the type of application, such as web, desktop, mobile, or embedded.
    • Example tags: web_application, desktop_application, mobile_app

  3. System Architecture:

    • Tag the overall system architecture or high-level design.
    • Example tags: client-server_architecture, service-oriented_architecture, event-driven_architecture

  4. Entry Points:

    • Tag the primary entry points or starting points of the application.
    • Example tags: main_function, startup_script, command_line_interface

  5. External Dependencies:

    • Tag the major external dependencies, libraries, frameworks, or third-party components used.
    • Example tags: uses_framework_xyz, depends_on_library_abc, integrates_with_system_def

  6. Deployment and Infrastructure:

    • Tag the deployment environment and infrastructure details.
    • Example tags: cloud_hosted, on-premises, containerized_deployment

  7. Scalability and Reliability:

    • Tag any high-level scalability or reliability concerns or strategies.
    • Example tags: horizontal_scaling, load_balancing, failover_mechanisms

  8. Security and Compliance:

    • Tag any security or compliance requirements or concerns at the system level.
    • Example tags: data_protection_compliance, secure_communication, access_control

  9. Monitoring and Logging:

    • Tag the overall monitoring and logging strategies employed.
    • Example tags: centralized_logging, distributed_tracing, performance_monitoring

  10. System Evolution:

    • Tag any information related to the system's evolution or future roadmap.
    • Example tags: legacy_system_migration, planned_features, technical_debt

These tags or notes should capture the highest-level information about the application or system, such as its domain, type, architecture, dependencies, deployment, scalability, security, monitoring, and evolution. They provide an overall context and understanding of the system's purpose, structure, and potential areas of concern or future development, which can inform the comprehension of the entire codebase.

High Level (Modules/Components)

At the high level of modules or components, the following information should be tracked and distilled into concise tags or notes:

  1. Architectural Patterns:

    • Tag the overall architectural pattern or style used in the codebase.
    • Example tags: monolithic_architecture, microservices_architecture, layered_architecture

  2. Component Interactions:

    • Tag the communication and interaction patterns between high-level components.
    • Example tags: event-driven_communication, request-response_pattern, publish-subscribe_pattern

  3. Data Flow:

    • Tag the overall data flow and transformation patterns between components.
    • Example tags: data_pipeline, streaming_data, batch_processing

  4. Scalability and Reliability:

    • Tag components or areas with potential scalability or reliability concerns.
    • Example tags: single_point_of_failure, horizontal_scaling, load_balancing

  5. Security Patterns:

    • Tag security patterns or practices implemented at the architectural level.
    • Example tags: secure_by_design, defense_in_depth, least_privilege_principle

  6. Performance Optimization:

    • Tag areas or components with potential performance optimization opportunities.
    • Example tags: caching_strategy, async_processing, resource_pooling

  7. Deployment and Infrastructure:

    • Tag components or areas related to deployment and infrastructure concerns.
    • Example tags: containerized_deployment, cloud_infrastructure, on-premises_deployment

  8. Integration Patterns:

    • Tag patterns or strategies used for integrating with external systems or APIs.
    • Example tags: event-driven_integration, api_gateway, service_mesh

  9. Monitoring and Observability:

    • Tag components or areas related to monitoring, logging, and observability.
    • Example tags: centralized_logging, distributed_tracing, health_monitoring

  10. Domain-driven Design:

    • Tag components or areas that follow domain-driven design principles.
    • Example tags: bounded_contexts, ubiquitous_language, domain_events

These tags or notes should capture the high-level architectural decisions, patterns, and strategies employed in the codebase. They provide insights into the overall structure, scalability, security, performance, and integration concerns, which can inform the understanding of the highest-level aspects in the subsequent step.

Mid Level (Modules/Components)

At the mid-level of modules or components, the following information should be tracked and distilled into concise tags or notes:

  1. Module Responsibilities:

    • Tag modules with their primary responsibilities or concerns within the application.
    • Example tags: authentication_module, data_access_layer, reporting_module

  2. Module Dependencies:

    • Tag modules with their dependencies on other modules or external libraries.
    • Example tags: depends_on_logging, uses_third_party_library, depends_on_database

  3. Control Flow:

    • Tag modules with information about their control flow or execution paths.
    • Example tags: entry_point, main_flow, event_driven, state_machine

  4. Design Patterns:

    • Tag modules that implement or adhere to specific design patterns.
    • Example tags: mvc_pattern, event_bus_pattern, dependency_injection

  5. Performance and Scalability:

    • Tag modules with potential performance bottlenecks or scalability concerns.
    • Example tags: high_memory_usage, cpu_intensive, potential_bottleneck

  6. Security Aspects:

    • Tag modules that handle security-related concerns (e.g., authentication, authorization, data encryption).
    • Example tags: authentication_module, secure_communication, data_encryption

  7. Cross-cutting Concerns:

    • Tag modules that handle cross-cutting concerns like logging, caching, or error handling.
    • Example tags: logging_module, caching_layer, error_handling_module

  8. Domain Concepts and Business Rules:

    • Tag modules that encapsulate or implement domain-specific concepts or business rules.
    • Example tags: finance_module, medical_diagnosis_module, game_physics_module

  9. Integration Points:

    • Tag modules with their integration points with external systems or APIs.
    • Example tags: integrates_with_payment_gateway, uses_third_party_api, database_integration

  10. Concurrency and Parallelism:

    • Tag modules that handle concurrency or parallelism mechanisms.
    • Example tags: multithreaded_module, async_processing, parallel_execution

These tags or notes should capture the responsibilities, dependencies, control flow, design patterns, and potential areas of concern or optimization at the module or component level. They will provide insights into the overall organization, architecture, and potential areas for refactoring or optimization, which can inform the understanding of higher-level aspects in subsequent steps.

Low Level (Classes/Functions)

At the low level of classes and functions, the following information should be tracked and distilled into concise tags or notes:

  1. Class Responsibilities:

    • Tag classes with their primary responsibilities or concerns.
    • Example tags: data_model, service_provider, utility_class

  2. Class Relationships:

    • Tag classes with their relationships to other classes (e.g., inheritance, composition, aggregation).
    • Example tags: base_class, subclass, composed_of, has_a

  3. Function Responsibilities:

    • Tag functions with their primary responsibilities or tasks.
    • Example tags: data_validation, data_transformation, calculation

  4. Coupling and Cohesion:

    • Tag classes or functions with high or low levels of coupling or cohesion.
    • Example tags: high_coupling, low_cohesion, tightly_coupled, highly_cohesive

  5. Design Patterns:

    • Tag classes or functions that implement or adhere to specific design patterns.
    • Example tags: singleton_pattern, observer_pattern, factory_method

  6. Domain Concepts and Business Rules:

    • Tag classes or functions that encapsulate or implement domain-specific concepts or business rules.
    • Example tags: financial_calculations, medical_diagnosis, game_physics

  7. Error Handling and Exception Management:

    • Tag classes or functions with specific error handling or exception management strategies.
    • Example tags: error_logging, exception_propagation, custom_exceptions

  8. Concurrency and Synchronization:

    • Tag classes or functions that handle concurrency or synchronization mechanisms.
    • Example tags: thread_safe, lock_management, async_operations

  9. Performance Considerations:

    • Tag classes or functions with potential performance implications or optimization opportunities.
    • Example tags: memory_intensive, cpu_bound, io_bound

  10. Security Aspects:

    • Tag classes or functions that handle security-related concerns (e.g., authentication, authorization, data encryption).
    • Example tags: authentication, authorization, data_encryption

These tags or notes should capture the responsibilities, relationships, and characteristics of classes and functions at a higher level than the implementation details. They will provide insights into the organization, design patterns, and potential areas of concern or optimization, which can inform the understanding of higher-level aspects in subsequent steps.