Please enable JavaScript.

Coggle requires JavaScript to display documents.

Introduction (Challenges (Heterogeneity (Varying characteristics e.g.…

- - - - Networks
      - Computer hardware
      - Operating Systems
      - Programming languages
      - Implementation by different developers
    - - Using standard protocols
      - Using agreed upon message formats and data types
      - Adhering to an agreed upon Application Program Interfaces (APIs)
      - Using Middleware
        
        Software layer between the distributed application and the operating systems that
        
        Provides programming abstraction
        
        Masks heterogeneity of underlying networks, hardware, OS and programming languages
        
        Middleware models
        
        Distributed file systems
        
        Remote procedure call
        
        Remode method invocation
        
        Distributed documents
        
        Distributed databases
      - Portable code
        
        Code is sent from one computer to another to run at the destination
        
        Code might not compile in another OS due to different hardware or OS versions
        
        Approaches
        
        Cross-platform compilation
        
        Code portability
        
        Virtual machine approach: compiler produces code that is interpreted by the virtual machine
  - - - Publishing key interfaces
      - Allow a uniform communication mechanism to communicate over the published interfaces
      - Ensure all implementations adhere to the published standards
  - - - Confidentiality: protection against disclosure to unauthorised individuals
      - Integrity: protection against alteration and corruption
      - Availability: protection against interference with the means of access
    - - Encryption (e.g. Blowfish, RSA)
      - Authentication (passwords, public key authentication)
      - Authorization (access control lists)
  - - - Cost of physical resources: scalable system can support n users with O(n) resources -> 1 server for 20 users; 2 servers for 40 users
      - Controlling performance loss: O(log(n)) search algorithm yes, O(n^2) no
      - Resources should not run out -> 32-bit Internet IP address thus led to 128-bit address
      - Avoid performance bottlenecks: use decentralised architecutres and algorithms
  - - - Detecting: checksums to detect corrupted data vs failure of a remote server (difficult to detect)
      - Masking: some failures that have been detected can be hidden or made less severe (e.g. timeout and message transmission)
      - Tolerating: e.g. failure reported back to the user; web server not available try again later; video rendered with errors
      - Recovery: failure sometimes lead to corrupted data and software can be designed so that it can recover the original state after failure; e.g. implementin a roll back mechanism
      - Redundancy: e.g. multiple servers providing the same service
  - - - Make access sequential -> slows down the system
      - Semaphores
  - - - Access
      - Location
      - Concurrency
      - Replication
      - Failure
      - Mobility
      - Performance
      - Scaling