MALAYSIA
Law
Welcome Guest | Login
SEARCH
Advanced
The Process of Software Architecting: Eeles, Peter/ Cripps, Peter: BOOKS KINOKUNIYA
Book Details
The Process of Software Architecting
The Process of Software Architecting
Published Date : 2009/07
Binding : Paperback
ISBN : 9780321357489

BookWeb Price : MYR 151.50
Kinokuniya Privilege Card member price : MYR 136.35

Availability Status : Our fulfillment centre has the item in stock.
Usually dispatches within 3 working days.
Language : English
Stock Information
Store Shelf Location Click here Stock
Kuala Lumpur C02-02, B10-03, B08-02 Map
Important
  • While every attempt has been made to ensure stock availability, occasionally we do run out of stock at our stores.
  • Retail store and online prices may vary.
  • To confirm availability and pricing, please call the store directly.
Retail Store Contact Details and Operating Hours

Book Description
Source: ENG
Academic Descriptors: A93500000
Place of Publication: United States
Textual Format: Computer Applications
Academic Level: Professional
Table of Contents
 
Foreword                                           xvii
Preface                                            xix
Acknowledgments                                    xxiii
About the Authors                                  xxv
    Introduction                                   1    (8)
      Applying the Process                         2    (1)
      The Process in Brief                         2    (6)
      Scope                                        8    (1)
      Summary                                      8    (1)
    Architecture, Architect, Architecting          9    (34)
      Architecture                                 9    (12)
        An Architecture Defines Structure          11   (1)
        An Architecture Defines Behavior           12   (1)
        An Architecture Focuses on Significant     13   (1)
        Elements
        An Architecture Balances Stakeholder       14   (1)
        Needs
        An Architecture Embodies Decisions         15   (1)
        Based on Rationale
        An Architecture May Conform to an          15   (1)
        Architectural Style
        An Architecture Is Influenced by Its       16   (1)
        Environment
        An Architecture Influences Development     17   (1)
        Team Structure
        An Architecture Is Present in Every        17   (1)
        System
        An Architecture Has a Particular Scope     18   (3)
      Architect                                    21   (6)
        The Architect Is a Technical Leader        21   (1)
        The Architect Role May Be Fulfilled by     22   (1)
        a Team
        The Architect Understands the Software     23   (1)
        Development Process
        The Architect Has Knowledge of the         23   (1)
        Business Domain
        The Architect Has Technology Knowledge     24   (1)
        The Architect Has Design Skills            24   (1)
        The Architect Has Programming Skills       25   (1)
        The Architect Is a Good Communicator       26   (1)
        The Architect Makes Decisions              26   (1)
        The Architect Is Aware of                  26   (1)
        Organizational Politics
        The Architect Is a Negotiator              27   (1)
      Architecting                                 27   (8)
        Architecting Is a Science                  30   (1)
        Architecting Is an Art                     30   (1)
        Architecting Spans Many Disciplines        30   (1)
        Architecting Is an Ongoing Activity        31   (1)
        Architecting Is Driven by Many             32   (1)
        Stakeholders
        Architecting Often Involves Making         33   (1)
        Trade-Offs
        Architecting Acknowledges Experience       34   (1)
        Architecting Is Both Top-Down and          34   (1)
        Bottom-Up
      The Benefits of Architecting                 35   (5)
        Architecting Addresses System Qualities    35   (1)
        Architecting Drives Consensus              36   (1)
        Architecting Supports the Planning         36   (2)
        Process
        Architecting Drives Architectural          38   (1)
        Integrity
        Architecting Helps Manage Complexity       39   (1)
        Architecting Provides a Basis for Reuse    39   (1)
        Architecting Reduces Maintenance Costs     39   (1)
        Architecting Supports Impact Analysis      40   (1)
      Summary                                      40   (3)
    Method Fundamentals                            43   (18)
      Key Concepts                                 43   (3)
      Method Content                               46   (4)
        Role                                       46   (2)
        Work Product                               48   (1)
        Activity                                   49   (1)
        Task                                       50   (1)
      Process                                      50   (9)
        Waterfall Processes                        51   (1)
        Iterative Processes                        52   (6)
        Agile Processes                            58   (1)
      Summary                                      59   (2)
    Documenting a Software Architecture            61   (28)
      The End Game                                 62   (2)
      Key Concepts                                 64   (1)
      Viewpoints and Views                         65   (7)
        Basic Viewpoints                           67   (1)
        Cross-Cutting Viewpoints                   68   (2)
        Views and Diagrams                         70   (1)
        Benefits of Viewpoints and Views           71   (1)
      Models                                       72   (3)
        Levels of Realization                      73   (2)
        Benefits of Models                         75   (1)
      Characteristics of an Architecture           75   (6)
      Description Framework
        The 4 + 1 View Model of Software           76   (1)
        Architecture
        Zachman Framework                          77   (2)
        Rozanski and Woods                         79   (2)
      An Architecture Description Framework        81   (6)
        Viewpoints                                 81   (3)
        Work Products                              84   (1)
        Levels of Realization                      85   (2)
        View Correspondence                        87   (1)
      The Software Architecture Document           87   (1)
      Summary                                      88   (1)
    Reusable Architecture Assets                   89   (18)
      Sources of Architecture                      89   (1)
      An Architecture Asset Metamodel              90   (4)
        Development-Time Assets                    92   (1)
        Run-Time Assets                            92   (2)
      Asset Types                                  94   (9)
        Reference Architecture                     94   (1)
        Development Method                         94   (1)
        Viewpoint Catalog                          95   (1)
        Architectural Style                        95   (1)
        Architectural Mechanism                    96   (1)
        Pattern                                    96   (4)
        Reference Model                            100  (1)
        Architecture Decision                      100  (1)
        Existing Application                       101  (1)
        Packaged Application                       101  (1)
        Application Framework                      102  (1)
        Component Library/Component                103  (1)
      Attributes of an Architecture Asset          103  (3)
      Other Reuse Considerations                   106  (1)
      Summary                                      106  (1)
    Introduction to the Case Study                 107  (18)
      Applying the Process                         107  (3)
      Scope of the Case Study                      110  (5)
        The Project Team                           112  (1)
        External Influences                        113  (2)
      Application Overview                         115  (3)
      The YourTour Vision                          118  (5)
        Problem Statement                          118  (1)
        Stakeholders                               119  (1)
        Functionality                              120  (2)
        Qualities                                  122  (1)
        Constraints                                122  (1)
      Summary                                      123  (2)
    Defining the Requirements                      125  (54)
      Relating Requirements to Architecture        128  (2)
      Functional and Non-Functional Requirements   130  (1)
      Techniques for Documenting Requirements      131  (1)
      Applying the Process                         132  (1)
      Understanding the Task Descriptions          133  (1)
      Define Requirements: Activity Overview       134  (2)
      Task: Collect Stakeholder Requests           136  (5)
      Task: Capture Common Vocabulary              141  (2)
      Task: Define System Context                  143  (6)
      Task: Outline Functional Requirements        149  (7)
      Task: Outline Non-Functional Requirements    156  (4)
      Task: Prioritize Requirements                160  (4)
      Task: Detail Functional Requirements         164  (7)
      Task: Detail Non-Functional Requirements     171  (3)
      Task: Update Software Architecture           174  (1)
      Document
      Task: Review Requirements with               175  (1)
      Stakeholders
      Summary                                      176  (3)
    Creating the Logical Architecture              179  (82)
      Moving from Requirements to Solution         182  (3)
      How Much Logical Architecture?               185  (3)
        Minimizing Logical Architecture            185  (1)
        Logical Architecture as an Investment      186  (1)
        The Importance of Traceability             187  (1)
      Applying the Process                         188  (1)
      Create Logical Architecture: Activity        188  (4)
      Overview
      Task: Survey Architecture Assets             192  (2)
      Task: Define Architecture Overview           194  (6)
      Task: Document Architecture Decisions        200  (4)
      Task: Outline Functional Elements            204  (18)
      Task: Outline Deployment Elements            222  (6)
      Task: Verify Architecture                    228  (4)
      Task: Build Architecture Proof-of-Concept    232  (2)
      Task: Detail Functional Elements             234  (11)
      Task: Detail Deployment Elements             245  (6)
      Task: Validate Architecture                  251  (5)
      Task: Update Software Architecture           256  (2)
      Document
      Task: Review Architecture with               258  (2)
      Stakeholders
      Summary                                      260  (1)
    Creating the Physical Architecture             261  (42)
      Moving from Logical to Physical              263  (2)
      Architecture
      Applying the Process                         265  (1)
      Creating the Physical Architecture:          266  (3)
      Activity Overview
      Task: Survey Architecture Assets             269  (1)
      Task: Define Architecture Overview           270  (3)
      Task: Document Architecture Decisions        273  (1)
      Task: Outline Functional Elements            274  (15)
        Mapping Logical Functional Elements to     274  (3)
        Physical Functional Elements
        Identifying Physical Functional Elements   277  (2)
        Procuring Products                         279  (1)
        Accommodating Technology-Specific          280  (9)
        Patterns
      Task: Outline Deployment Elements            289  (3)
        Mapping Logical Deployment Elements to     289  (1)
        Physical Deployment Elements
        Identifying Physical Deployment Elements   290  (2)
        Procuring Hardware                         292  (1)
      Task: Verify Architecture                    292  (1)
      Task: Build Architecture Proof-of-Concept    293  (1)
      Task: Detail Functional Elements             294  (2)
      Task: Detail Deployment Elements             296  (4)
      Task: Validate Architecture                  300  (1)
      Task: Update Software Architecture           301  (1)
      Document
      Task: Review Architecture with               301  (1)
      Stakeholders
      Summary                                      302  (1)
    Beyond the Basics                              303  (30)
      The Architect and the Project Team           303  (10)
        The Architect and Requirements             304  (1)
        The Architect and Development              304  (2)
        The Architect and Test                     306  (1)
        The Architect and Project Management       307  (1)
        The Architect and Configuration            308  (2)
        Management
        The Architect and Change Management        310  (1)
        The Architect and the Development          311  (1)
        Environment
        The Architect and Business Analysis        312  (1)
      The Architect and External Influences        313  (5)
        Enterprise Architecture                    315  (1)
        Design Authority                           316  (1)
        Infrastructure Provider                    317  (1)
        Application Maintenance Provider           318  (1)
      Architecting Complex Systems                 318  (12)
        Many Distinct Functions Are Being          319  (1)
        Developed
        Many People Are Involved in Development    320  (4)
        The System Is Highly Distributed           324  (1)
        The Development Team Is Distributed        325  (1)
        Operational Qualities Are Extremely        326  (1)
        Challenging
        There Is a System of Systems               327  (3)
      Summary                                      330  (1)
      In Conclusion: A Note from the Authors       331  (2)
  Appendix A Software Architecture Metamodel       333  (6)
      Definition of Metamodel Terms                335  (4)
  Appendix B Viewpoint Catalog                     339  (12)
      Stakeholder Summary                          340  (1)
      Basic Viewpoints                             341  (3)
      Cross-Cutting Viewpoints                     344  (3)
      View Correspondence                          347  (4)
  Appendix C Method Summary                        351  (14)
      Roles                                        351  (3)
      Work Products                                354  (2)
      Activities                                   356  (1)
      Tasks                                        356  (6)
        Activity: Define Requirements              358  (2)
        Activity: Create Logical Architecture      360  (2)
        Activity: Create Physical Architecture     362  (1)
      Phases                                       362  (3)
        Inception                                  362  (1)
        Elaboration                                363  (1)
        Construction                               363  (1)
        Transition                                 364  (1)
  Appendix D Architectural Requirement Checklist   365  (8)
      Functional Requirements                      366  (1)
      Usability Requirements                       366  (1)
      Reliability Requirements                     367  (1)
      Performance Requirements                     367  (1)
      Supportability Requirements                  368  (1)
      Constraints                                  368  (5)
        Business Constraints                       369  (1)
        Architecture Constraints                   369  (1)
        Development Constraints                    370  (1)
        Physical Constraints                       370  (3)
Glossary                                           373  (6)
References                                         379  (6)
Index                                              385
 

A Comprehensive Process for Defining Software Architectures That Work A good software architecture is the foundation of any successful software system. Effective architecting requires a clear understanding of organizational roles, artifacts, activities performed, and the optimal sequence for performing those activities. With The Process of Software Architecting, Peter Eeles and Peter Cripps provide guidance on these challenges by covering all aspects of architecting a software system, introducing best-practice techniques that apply in every environment, whether based on Java EE, Microsoft .NET, or other technologies. Eeles and Cripps first illuminate concepts related to software architecture, including architecture documentation and reusable assets. Next, they present an accessible, task-focused guided tour through a typical project, focusing on the architect's role, with common issues illuminated and addressed throughout. Finally, they conclude with a set of best practices that can be applied to today's most complex systems.You will come away from this book understanding * The role of the architect in a typical software development project * How to document a software architecture to satisfy the needs of different stakeholders * The applicability of reusable assets in the process of architecting * The role of the architect with respect to requirements definition * The derivation of an architecture based on a set of requirements * The relevance of architecting in creating complex systemsThe Process of Software Architecting will be an indispensable resource for every working and aspiring software architect-and for every project manager and other software professional who needs to understand how architecture influences their work.

Contents
Foreword xvii Preface xix Acknowledgments xxiii About the Authors xxv Chapter 1: Introduction 1 Applying the Process 2 The Process in Brief 2 Scope 8 Summary 8 Chapter 2: Architecture, Architect, Architecting 9 Architecture 9 Architect 21 The Benefits of Architecting 35 Summary 40 Chapter 3: Method Fundamentals 43 Key Concepts 43 Method Content 46 Process 50 Summary 59 Chapter 4: Documenting a Software Architecture 61 The End Game 62 Key Concepts 64 Viewpoints and Views 65 Models 72 Characteristics of an Architecture Description Framework 75 An Architecture Description Framework 81 The Software Architecture Document 87 Summary 88 Chapter 5: Reusable Architecture Assets 89 Sources of Architecture 89 An Architecture Asset Metamodel 90 Asset Types 94 Attributes of an Architecture Asset 103 Other Reuse Considerations 106 Summary 106 Chapter 6: Introduction to the Case Study 107 Applying the Process 107 Scope of the Case Study 110 Application Overview 115 The YourTour Vision 118 Summary 123 Chapter 7: Defining the Requirements 125 Relating Requirements to Architecture 128 Functional and Non-Functional Requirements 130 Techniques for Documenting Requirements 131 Applying the Process 132 Understanding the Task Descriptions 133 Define Requirements: Activity Overview 134 Task: Collect Stakeholder Requests 136 Task: Capture Common Vocabulary 141 Task: Define System Context 143 Task: Outline Functional Requirements 149 Task: Outline Non-Functional Requirements 156 Task: Prioritize Requirements 160 Task: Detail Functional Requirements 164 Task: Detail Non-Functional Requirements 171 Task: Update Software Architecture Document 174 Task: Review Requirements with Stakeholders 175 Summary 176 Chapter 8: Creating the Logical Architecture 179 Moving from Requirements to Solution 182 How Much Logical Architecture? 185 Applying the Process 188 Create Logical Architecture: Activity Overview 188 Task: Survey Architecture Assets 192 Task: Define Architecture Overview 194 Task: Document Architecture Decisions 200 Task: Outline Functional Elements 204 Task: Outline Deployment Elements 222 Task: Verify Architecture 228 Task: Build Architecture Proof-of-Concept 232 Task: Detail Functional Elements 234 Task: Detail Deployment Elements 245 Task: Validate Architecture 251 Task: Update Software Architecture Document 256 Task: Review Architecture with Stakeholders 258 Summary 260 Chapter 9: Creating the Physical Architecture 261 Moving from Logical to Physical Architecture 263 Applying the Process 265 Creating the Physical Architecture: Activity Overview 266 Task: Survey Architecture Assets 269 Task: Define Architecture Overview 270 Task: Document Architecture Decisions 273 Task: Outline Functional Elements 274 Task: Outline Deployment Elements 289 Task: Verify Architecture 292 Task: Build Architecture Proof-of-Concept 293 Task: Detail Functional Elements 294 Task: Detail Deployment Elements 296 Task: Validate Architecture 300 Task: Update Software Architecture Document 301 Task: Review Architecture with Stakeholders 301 Summary 302 Chapter 10: Beyond the Basics 303 The Architect and the Project Team 303 The Architect and External Influences 313 Architecting Complex Systems 318 Summary 330 In Conclusion: A Note from the Authors 331 Appendix A: Software Architecture Metamodel 333 Definition of Metamodel Terms 335 Appendix B: Viewpoint Catalog 339 Stakeholder Summary 340 Basic Viewpoints 341 Cross-Cutting Viewpoints 344 View Correspondence 347 Appendix C: Method Summary 351 Roles 351 Work Products 354 Activities 356 Tasks 356 Phases 362 Appendix D: Architectural Requirement Checklist 365 Functional Requirements 366 Usability Requirements 366 Reliability Requirements 367 Performance Requirements 367 Supportability Requirements 368 Constraints 368 Glossary 373 References 379 Index 385
Customers Who Bought This Item Also Bought
Clean Code : A Handbook o...
By Martin, Robert C.
MYR 165.00
for KPC member:
MYR 148.50
Agile Principles, Pattern...
By Martin, Robert C./ Martin, Micah
MYR 247.50
for KPC member:
MYR 222.75