1. tips
   1. 1. Based on non functional requirements
      1. Non-functional requirements
         1. solutions
            1. Performance
            2. Typical Design/Architectural principles to look for:
            3. Connection pooling
            4. Load balancing
            5. Distributed processing
            6. Caching
            7. Lazy instantiation
            8. Transaction Concurrency
            9. Process isolation between OLTP and OLAP
            10. Replication of data
            11. Typical unit of measurement you could use:
            12. Transactions per unit time
            13. Amount of time it takes to complete a transaction
            14. Reliability
            15. Typical Design/Architectural principles to look for:
            16. Using preventive measures (administration) e.g. recycling of server processes in IIS.6 ASP.NET /COM+ 1.5
            17. Containment - COM+ server process isolation
            18. Database transaction logs (rollback)
            19. Typical unit of measurement you could use:
            20. Mean time to failure
            21. Availability
            22. Typical Design/Architectural principles to look for:
            23. Fail-over
            24. Transaction Manager
            25. Stateless design
            26. Typical unit of measurement you can use:
            27. Length of time between failures
            28. Subtopic 1
            29. How quickly the system is able to resume operation in the event of failure.
            30. Security
            31. Typical Design/Architectural principles to look for:
            32. Authentication
            33. Authorisation
            34. Auditing
            35. Integrity
            36. Confidentiality
            37. Denial of Service
            38. Data isolation
            39. Modifiability
            40. Typical Design/Architectural principles to look for:
            41. Client-server
            42. Independence of interface from implementation
            43. Separation
            44. Encoding function into data meta-data and language interpreters
            45. Run-time discovery no hard
            46. Typical unit of measurement
            47. Using specific changes as benchmarks and recording how expensive those changes are to make
            48. Portability
            49. Typical Design/Architectural principles to look for:
            50. Virtual machine
            51. Functionality
            52. Typical unit of measurement:
            53. Number change request
            54. Extensibility
            55. Typical unit of measurement:
            56. Easy, incremental addition of functionality (time, budget, etc.)
            57. Coupling/cohesion
            58. Conceptual Integrity
            59. Underlying theme or vision that unifies the design of the system at all levels.
            60. Interoperability
            61. Typical Design/Architectural principles to look for:
            62. Simple data-types
            63. Subtopic 1
            64. XML
            65. Web services
            66. Usability
            67. Typical Design/Architectural principles to look for:
            68. GUI standards between product line
            69. Typical unit of measurement:
            70. Number of errors made by a user familiar with prior releases or other members of the product line.
            71. Maintainability
            72. Typical unit of measurement:
            73. Easy localisation
            74. Ripple effects of change
            75. Efficiency
            76. Typical Design/Architectural principles to look for:
            77. Acquire late, release early
            78. Reducing round-trips
            79. Lowering traffic throughput (only send what is necessary, only retrieve what is necessary)
            80. Testability
            81. Typical Design/Architectural principles to look for:
            82. Interface based programming
            83. Inversion of control/Dependency injection
            84. Classes with well defined responsibilities
            85. Reusability
            86. Ease of Deployment
            87. Typical measures:
            88. Installer programs (wizards)
            89. Typical unit of measurement:
            90. Can be measured by the time and resources required to install the product and /or distribute a new unit of functionality
            91. Ease of Administration
            92. Scalability
            93. Typical Design/Architectural principles to look for:
            94. Stateless design
            95. Load-balancing
            96. Concurrency (optimistic)
            97. Debug-ability /Monitoring
            98. Typical Design/Architectural principles to look for:
            99. Tracing support
            100. Logging in exception handling mechanism
            101. Development Productivity
            102. Typical Design/Architectural principles to look for:
            103. Framework
            104. Templates /code generation
            105. Best practices Coding checklist & standards
   2. 2. Rationale, rationale, rationale -có lý, phải lẽ
   3. 3. Don’t Repeat Yourself
   4. 4. Slice the cake
   5. 5. Prototype
   6. 6. Quantify
   7. 7. Get it working, Get it right, Get it optimized
   8. 8. Focus on the boundaries and interfaces
   9. 9. The Perfect is the enemy of the Good
   10. 10. Align with your stakeholders
2. principles
   1. 1. Start with the minimal necessary architecture
   2. 2. Consider the specifics of your project: Constraints and risks
   3. 3. Grow as you need.
   4. 4. Deliver continuously.
   5. 5. Require a customer
   6. 6. Avoid waste
   7. 7.Maximise feedback and transparency