These are the qualities of our apps

  1. Developer productivity

    Since smart people are the most precious resource you have any framework or architecture we adopt needs to help optimize developer productivity time.
    1. Simplicity
    2. Concise but not obtuse
    3. Standardized way of doing things
    4. Great supporting tools
    5. Short feedback loops
    6. Expressiveness
    7. Quality 3rd party packages?

  2. Elegance

    The elegance of the solution speaks to how well the solution fits the problem space and how coherent the solution is.
    1. Consistent way of solving a problem.
    2. The most common tasks are the easiest to do.
    3. Clear guidance on how to make architectural choices.
    4. Easily extendable in the appropriate places.
    5. As simple as possible but no simpler.
    6. Strong cohesion / low coupling
    7. The problem space forms a large percentage of the frameworks solution space

  3. Usability

    Usability is vitally important for a number of reasons. It improves trust, customer satisfaction and reduces support costs. Any technology you use should allow you to build a world class user experience.
    1. No vendor specific technologies
    2. Support the latest standards
    3. Must provide fast response times in the UI
    4. Allow for use of graphic and charting capabilities
    5. Allow animation where appropriate
    6. Must support A/B testing
    7. Must support analytics

  4. Security

    Security is the capability of a system to reduce the chance of malicious or accidental actions outside of the designed usage of the system, and prevent disclosure or loss of information.
    1. Passes 3rd party penetration tests
    2. Uses security standards wherever possible
    3. Follows security best practices.

  5. Reliability

    Reliability is the ability of a system to continue operating in the expected way over time. Reliability is measured as the probability that a system will not fail and that it will perform its intended function for a specified time interval
    1. It doesn't crash
    2. Autonomic - when it crashes it heals itself
    3. No single point of failure

  6. Performance

    Performance is an indication of the responsiveness of a system to execute specific actions in a given time interval. It can be measured in terms of latency or throughput. Latency is the time taken to respond to any event. Throughput is the number of events that take place in a given amount of time.
    1. Support an appropriate level of performance.
    2. Low latency to the UI (< 250 ms for 90% of requests,, <2s for all requests) or provide mechanisms to compensate (messaging, caching, etc)

  7. Scalability

    Scalability is the ability of a system to either handle increases in load without impact on the performance of the system, or the ability to be readily enlarged.
    1. We prefer scaling out to scaling up.
    2. Easy to add more processing nodes.
    3. Easy to load balance new nodes.
    4. Each node should be low overhead.
    5. Licencing should not prevent scaling.

  8. Testability

    Testability is a measure of how well a system or components allow you to create test criteria and execute tests to determine if the criteria are met.
    1. Provide mechanisms to mock data.
    2. Trigger back end processes via scripting.
    3. Batch processes should be fast when using small data sets.
    4. Easy to create known data.
    5. Ability to automate UI testing.

  9. Interoperability

    Do you play well with others? Communication protocols, interfaces, and data formats are the key considerations for interoperability. Standardization is also an important aspect to be considered when designing an interoperable system.
    1. Use open standards where available.
    2. Publish standards where not available.
    3. Provides you with many options when selecting 3'rd party systems

  10. Transparency and troubleshooting.

    When something goes wrong how easy is it to track down the error and re-produce it?
    1. All errors and important events are logged in a meaningful way
    2. Easily comprehensible stack traces
    3. All data needed to re-produce an error is included in the log
    4. Debug logs can be turned on and off
    5. It should be easy to trace an error all the way through the application.

  11. Community and Product Growth

    There should be a strong community behind the product you are using. Having other people who have already solved the problems you are facing is a major factor in how easy a product or framework is to live with.
    1. Many plugins and open source projects related to the framework
    2. Lots of questions and answers on stack overflow.
    3. A Google trends graph that is going up and to the right.
    4. Many books, blogs and tutorials.

  12. Deployability

    Deployment and propagation through different environments is a huge cost. A product that is difficult to deploy requires longer release cycles and makes it harder to respond to change or fix bugs.
    1. Automated scriptable deployments
    2. Automated tests are easy to write.
    3. Fast build times.
    4. File based configuration or easily scriptable configuration.
    5. Small physical size.
    6. Licencing should not prevent multiple environments.
    7. Easy rollback