Please enable JavaScript.

Coggle requires JavaScript to display documents.

Software architecture (Architectural styles (Service-based styles…

- - - - System is organised as layers with increasing abstraction levels
      - Lower level layers provide services to upper level layers
      - The tier idea can be broken with callbacks without making lower level dependent of the upper
      - Tier architecture can be both vertical (basic services - UI) and horizontal (general purpose - product specific)
      - 3-tier most common: Presentation - Logic - Data(base)
      - Pros & Cons
        
        Pros :green_cross:
        
        Applicable in most cases
        
        Support understanding and mastering of the system
        
        Decrease dependencies (maintenance, adaptability)
        
        Easy to connect with organisation structure
        
        Supports reuse
        
        Distribute easily
        
        Cons :red_cross:
        
        Performance compromises
        
        May lead to unnecessary or repeated computation
        
        Exception handling hard
    - - IDEA
        
        Filters consume & produce data items
        
        Pipes carry items to next component
        
        Units work independently and don't share status info
        
        Units don't know each other
        
        Information can be processed piecewise
        
        Units are stateless
        
        Each unit is its own process: slowest unit defines total time
        
        "Buffer" between filters, as they queue to the next unit
      - Pros & Cons
        
        Pros :green_cross:
        
        Complex process can be divided into separate pieces
        
        Reusable units (filters), can be combined in several ways
        
        Processing unit easily changeable (not dependable)
        
        Supports concurrent processing (see Scala) and distribution of load
        
        Cons :red_cross:
        
        Does not fit interactive systems
        
        Information interpreting may cause performance problems
        
        Error handling difficult
        
        Own error filters?
      - Examples
        
        Command lines (Linux)
        
        GPU computation
        
        Video processing?
  - - - Pros:
        enforces modular structure, continuous development, scalability
      - Cons:
        Services form information barriers
        Inter-service calls -> high cost & latency
        Testing & deployment is hard
        Moving responsibilities between services complicated
        Can lead to too many services, hard to control
- - - - To provide services
      - To require services