Designing the Requirements: Building Applications that the User Wants and Needs

Book description

This is the Rough Cut version of the printed book.

Too many software applications don’t do what’s needed or they do it clumsily, frustrating their users and owners. The core problem: poorly conceived and poorly crafted requirements. In Designing the Requirements, Chris Britton explains why it’s not enough to simply “gather” requirements–you need to design them.

Britton offers powerful techniques for understanding stakeholders’ concerns and working with stakeholders to get the requirements right. Using Britton’s context-driven approach to requirements design, you can detect inconsistencies, incompleteness, poor usability, and misalignment with business goals upstream–long before developers start coding. You can also design outward-looking applications and services that will integrate more effectively in a coherent IT architecture.

First, Britton explains what requirements design really means and presents a hierarchy of designs that move step-by-step from requirements through implementation. Next, he demonstrates how to build on requirements processes you already use and how to overcome their serious limitations in large-scale development. Then, he walks you through designing your application’s relationship with the business, users, data, and other software to ensure superior usability, security, and maximum scalability and resilience.

Coverage includes

  • Designing the entire business solution, not just its software component

  • Using engineering-style design analysis to find flaws before implementation

  • Designing services, and splitting large development efforts into smaller, more manageable projects

  • Planning logical user interfaces that lead to superior user experiences

  • Designing databases and data access to reflect the meaning of your data

  • Building application frameworks that simplify life for programmers and project managers

  • Setting reasonable and achievable goals for performance, availability, and security

  • Designing for security at all levels, from strategy to code

  • Identifying new opportunities created by context-driven design

  • Whether you’re a software designer, architect, project manager, or programmer, Designing the Requirements will help you design software that works–for users, IT, and the entire business.

    Chris Britton has more than forty years of wide-ranging IT experience. He started programming in the 1970s, shortly thereafter becoming a database specialist for large mainframe systems. During the 1980s, he helped develop SIM, a pioneering semantic database product, and later held a variety of responsibilities in systems support, marketing support, IT architecture, and management. During the 1990s, he increasingly focused on IT architecture and coauthored two editions of IT Architectures and Middleware (Addison-Wesley). Since 2001, he has consulted and developed software applications for his own company.

    Table of contents

    1. About This eBook
    2. Title Page
    3. Copyright Page
    4. Dedication Page
    5. Contents
    6. Preface
      1. The Structure of the Book
      2. Who Should Read This Book
    7. Acknowledgments
    8. About the Author
    9. Chapter 1. Introduction to Context-Driven Design
      1. Designing Requirements
      2. What Is Design?
        1. Ad Hoc Design
        2. Planned Design
        3. Engineered Design
        4. Summary of Design Approaches
      3. Making IT Application Development More of an Engineering Discipline
      4. Taking IT Architecture into Account
      5. Concluding Remarks
    10. Chapter 2. A Hierarchy of Designs
      1. Justifying the Hierarchy of Designs
      2. Context Design
        1. Tasks
        2. User Groups
        3. Data Tables
        4. Messages between Tasks
        5. Task Dependencies
        6. Putting It All Together
        7. Analysis of the Context Design
      3. Integration Design
      4. Technical Design
      5. User Interface Design
      6. Database Design
      7. Implementation
      8. Is It Really Engineering?
      9. Concluding Remarks
    11. Chapter 3. Reusing Existing Methods and Practices
      1. Agile
        1. Individuals and Interactions over Processes and Tools
        2. Working Software over Comprehensive Documentation
        3. Customer Collaboration over Contract Negotiations
        4. Responding to Change over Following a Plan
        5. Conclusion
      2. Upside-Down Design
      3. Use Cases
        1. Atomicity
        2. Confusion of Design Layers
        3. Use Cases Are Confusing
        4. Large Use Case Documents Are Hard to Understand
        5. Use Cases Do Not Assist Engineered Design
        6. Conclusion
      4. The Problem with Estimating Cost
      5. Why Is BDUF Big?
      6. Iterations
      7. Quality
      8. Testing and Inspection
      9. Using Existing Practices in Context-Driven Design
      10. Learning Organizations
      11. Concluding Remarks
    12. Chapter 4. The Problem of Large Applications
      1. The Dimensions of Size
      2. Problems with Large Projects
        1. Requirements Problems
        2. Lack of End User Support
        3. Technical Design Problems
        4. Procurement and Outsourcing
      3. Can Large Projects Be Avoided?
      4. Concluding Remarks
    13. Chapter 5. The Relationship with the Business
      1. Understanding Business Processes
      2. When It’s Not a Process
        1. Business Services
        2. Resource Management
        3. Reviewing and Monitoring
      3. The Need for a Wider View
      4. Applying the Business Strategy to Application Development
        1. Speed of Development
        2. Cost versus Performance and Availability
        3. Experimental Business Programs
        4. How Long Before the Benefits
        5. The Need for Security
        6. Designing for the Existing Culture
        7. Design for a Culture to Which the Organization Aspires
        8. Allow for Changing Plans
        9. Support a Learning Organization
        10. Non-Business Applications
      5. Analysis
        1. Is the Process Well Formed?
        2. Dependency Analysis
        3. Objectives Analysis
      6. Concluding Remarks
    14. Chapter 6. The Relationship with the Users
      1. Adding the Detail
        1. Task Details
        2. Task Fragments
        3. Common Purpose Groups
        4. Data Tables
        5. Messages
        6. Nonfunctional Requirements
        7. Who Uses the Context Design?
      2. Who Are the Users?
        1. Business Process Operations
        2. Monitoring by Management
        3. Data Used by Other Applications
        4. Data Analysis
        5. Application Administration
      3. Analyzing the Context Design
        1. Process Layer
        2. Task Details
        3. Data Table Details
        4. User Group Details
        5. Message Details
      4. Reviewing the Context Design
      5. Concluding Remarks
    15. Chapter 7. The Relationship to Other IT Projects
      1. Integration Design
        1. Applications
        2. Services
        3. Databases
      2. Services Interface Design
        1. Service Interface Definition
        2. Designing Reusable Services
      3. Existing Applications
        1. Knowing What Is There
        2. Replacing Existing Applications
        3. Fashioning Services from Existing Applications
      4. Looking Back at the Design Process
      5. Concluding Remarks
    16. Chapter 8. User Interface Design and Ease of Use
      1. Logical User Interfaces
      2. From Tasks to Clicks
      3. Ease of Use
        1. Function
        2. Information
        3. Navigation
        4. Text
        5. Help
        6. Intuitive and Likable Applications
        7. Ease-of-Use Design
        8. Monitoring Ease of Use
      4. Transaction and Task Integrity
      5. The User Interface Design and the Other Detailed Designs
      6. Concluding Remarks
    17. Chapter 9. Database Design
      1. Database Design
      2. Database Design Theory
      3. Programmers versus the Database Designer
      4. Database Access Services
      5. NoSQL
      6. Concluding Remarks
    18. Chapter 10. Technical Design—Principles
      1. Principles of High Performance on a Single Machine
        1. Cache
        2. Multithreading and Multiprocessing
      2. Principles of High Performance on Many Servers
        1. Front-End Parallelism
        2. Back-End Parallelism
      3. Principles of High Resiliency
      4. The Need for Testing and Benchmarking
      5. The Technical Design Process
      6. Concluding Remarks
    19. Chapter 11. Technical Design—Structure
      1. Program Structure
      2. What Is a Framework?
      3. The Variety of Programming Languages
      4. Choosing a Programming Language and Framework
        1. Choose a Language that Fits Your Organization’s Skill Set
        2. Choose a Language that Is Appropriate for Your Application’s Performance Goals
        3. Choose a Language that Can Meet Your Integration Requirements
        4. Choose a Language that Supports Group Working If Needed
        5. Choose Version Control Software and Project Management Software as Well as a Language
        6. Choose a Language that Chimes with Your Development Methodology
      5. Extending the Framework
      6. Implementing Common Functionality
      7. Concluding Remarks
    20. Chapter 12. Security Design
      1. IT Application Security Principles
        1. Authentication
        2. Access Control
        3. User Administration
        4. Security Protection
        5. Security Monitoring
      2. The Security Elements of Each Design
        1. Context Design
        2. Integration Design
        3. User Interface Design
        4. Database Design
        5. Technical Design
      3. Security Programming
      4. Concluding Remarks
    21. Chapter 13. The Future of Application Development
      1. How Context-Driven Design Changes Application Development
      2. Context-Driven Design Opportunities
        1. New Tools
        2. Context and Integration Design
        3. User Interface and Database Design
        4. Technical Design
      3. The Application Development Challenges
        1. Flexibility
        2. Operations
        3. Correctness
        4. Quality
        5. Professionalism
      4. Concluding Remarks
    22. Appendix A. Context Design Checklist
      1. Description
        1. Elaboration
        2. Analysis
    23. References
    24. Index
    25. Code Snippets

    Product information

    • Title: Designing the Requirements: Building Applications that the User Wants and Needs
    • Author(s):
    • Release date: October 2015
    • Publisher(s): Addison-Wesley Professional
    • ISBN: 9780134022949