Effective Software Development for the Enterprise Beyond Domain Driven Design, Software Architecture, and Extreme Programming
Gespeichert in:
| 1. Verfasser: | |
|---|---|
| Format: | Elektronisch E-Book |
| Sprache: | English |
| Veröffentlicht: |
Berkeley, CA
Apress L. P.
2023
|
| Ausgabe: | 1st ed |
| Online-Zugang: | DE-2070s |
| Tags: |
Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
|
MARC
| LEADER | 00000nam a2200000zc 4500 | ||
|---|---|---|---|
| 001 | BV049876203 | ||
| 003 | DE-604 | ||
| 005 | 00000000000000.0 | ||
| 007 | cr|uuu---uuuuu | ||
| 008 | 240919s2023 xx o|||| 00||| eng d | ||
| 020 | |a 9781484293850 |9 978-1-4842-9385-0 | ||
| 035 | |a (ZDB-30-PQE)EBC30550680 | ||
| 035 | |a (ZDB-30-PAD)EBC30550680 | ||
| 035 | |a (ZDB-89-EBL)EBL30550680 | ||
| 035 | |a (OCoLC)1380465440 | ||
| 035 | |a (DE-599)BVBBV049876203 | ||
| 040 | |a DE-604 |b ger |e rda | ||
| 041 | 0 | |a eng | |
| 049 | |a DE-2070s | ||
| 082 | 0 | |a 658.0551 | |
| 100 | 1 | |a Tutisani, Tengiz |e Verfasser |4 aut | |
| 245 | 1 | 0 | |a Effective Software Development for the Enterprise |b Beyond Domain Driven Design, Software Architecture, and Extreme Programming |
| 250 | |a 1st ed | ||
| 264 | 1 | |a Berkeley, CA |b Apress L. P. |c 2023 | |
| 264 | 4 | |c ©2023 | |
| 300 | |a 1 Online-Ressource (344 Seiten) | ||
| 336 | |b txt |2 rdacontent | ||
| 337 | |b c |2 rdamedia | ||
| 338 | |b cr |2 rdacarrier | ||
| 500 | |a Description based on publisher supplied metadata and other sources | ||
| 505 | 8 | |a Intro -- Table of Contents -- About the Author -- About the Technical Reviewer -- Acknowledgments -- Preface -- Chapter 1: Introduction -- History of Inefficient Monoliths -- Why People Avoid Building Effective Software -- Learning Curve -- Quality over Quantity -- Highly Paid Experts -- Naive Hopes to Survive -- Software Development Perfectionism as a State of Mind -- Is It Crazy? -- Desire Behind Perfectionism -- Is It Worth It? -- Six Pillars of Effective Software -- #1. Meet Users' Expectations -- #2. Allow No Defects -- #3. Scale Out Horizontally -- #4. Have No Dedicated Production Support Team -- #5. Accelerate Development Pace -- #6. Double the ROI per Developer, Team, and Software -- Summary -- Chapter 2: Cross-cutting Concerns -- Execution, Leadership, Management -- Importance of Software Development Transformation -- How to Achieve Software Development Transformation -- Transformation Is for Everybody -- Ad-Hoc Tasks vs. Process -- Hands-on Leaders -- Overall Support from Management -- Organizational Structure -- A Couple of Important Definitions Upfront -- Forming Organizations -- Forming Subsystems -- Forming Microservices -- Forming Teams -- Feature Teams -- Platform and Infrastructure Teams -- Forming Programs, Projects, Requirements, and Deliveries -- Organizational Silos -- Horizontal Silos -- Vertical Silos -- Autonomy vs. Reuse -- Processes, Ongoing Efforts, Teams -- Agile or Waterfall -- Transparent Teams -- Managing Work in Progress -- One for All, All for One -- Transformation from Inside -- Culture -- Professionalism in Software Development -- Trust -- Delegation of Responsibilities -- Identifying Talent -- Relaxed Team Atmosphere -- Work-Life Balance -- Candid Feedback -- Change of Mind -- Social Aspect of Engineering -- Complexity as Job Safety -- Team Spirit -- Keep It Fun -- Recruitment -- Supporting Role of Recruitment | |
| 505 | 8 | |a Hire Best -- Quickly, Fancy, Right -- Corrective vs. Preventive -- Summary -- Chapter 3: From Customer Insights to Internal Requirements -- Understanding Customers' Needs -- Partnership and Customer Focus -- Interview Customers -- Knowledge Exploration Exercises -- Stage #1: Casual Discussions -- Stage #2: Free-Formed Sketches -- Stage #3: Charting the Landscape -- Organization's Response to Customers' Needs -- From Customer Interview to Organizational Transformation -- Navigating the Context Map to Find Fit -- Why Form a New Subdomain? -- Cost of Introducing a Subdomain -- Requirements and Story Writing -- Ubiquitous Language: What Is It? Why Is It Important? -- Who Writes Stories? -- Ubiquitous Language in Requirements -- Writing Executable Specifications -- Halfway into Gherkin -- All the Way into Gherkin -- Planning Work -- Prioritized Backlog -- Feasibility -- Managing Dependencies -- Parent Subdomain Prescribes Child Subdomain Dependencies -- Classify Dependency -- Dependency Goes First -- Dependency Is Functional. Integration Is Technical -- Valuable Stories (Verticals) -- Technical Stories -- Carrying Out Work -- Definition of Done -- Estimates vs. Velocity -- Your Estimate Is Your Deadline -- Achieving Predictability -- Summary -- Chapter 4: Design and Architecture -- Architecture as a Cross-cutting Concern -- Definitions and Purpose -- Software Architecture -- Software Architect -- Is Architecture Dead? -- Brainstorm Before Coding -- Reuse Knowledge -- Architecture as a Service -- Partnership with Domain Experts -- Teams and Microservices -- Architecture Supports Organizational Growth -- Architecture in Analysis and Requirements Gathering -- Upfront Design Supports Gap Analysis -- Doing It in Practice -- Knowledge Exploration and Architecture -- Caveat of a Technical Solution -- Architecture Body of Knowledge -- Architecture Landscape | |
| 505 | 8 | |a Buy vs. Build -- Good Architectures -- Doing It in Practice -- It Is Okay to Postpone Decisions -- Architecture and Technology -- True Value of Software -- Is Technology King? -- Domain -- Using Technology -- Vendor Lock-in -- Unavoidable Level of Technology -- Abstractions Can Help -- Beware of Technologists -- Consolidate Technologies -- Domain Model Kinds -- Rich Domain -- Anemic Domain -- Big Ball of Mud -- Domain-Driven vs. Data-Driven -- Other Anti-Patterns -- Life with Anemic Domains -- Layered Software Architecture -- Popular Application Layering Patterns -- How Many Layers? -- Other Popular Layered Architectures -- Microservices -- Clarification of Terminology -- Implementing Microservices -- Integration -- Autonomy and Scale -- Scale Out -- Reusability vs. Duplication -- Evolving an Ecosystem of Microservices -- Monolithic UI Backed by Microservices -- Client-Side UI Composition -- Server-Side Page Fragment Composition -- Command Query Responsibility Segregation (CQRS) -- Employ Rich Domain to Generate Read Models -- Avoid Vendor Lockdown -- Path to Event-Driven Architecture (EDA) -- Building Cloud-Ready Applications -- Twelve-Factor App -- Containerization -- Avoiding Cloud Vendor Lock-In -- Dev-Prod Parity Locally -- Performance -- Performance vs. Clean Design -- Designing Components That Need to Be Fast -- Front-End Application Architecture -- Built-In Security -- Databases -- Database Technology Is Irrelevant to Design -- In-Memory Identity Value Generation -- Application Database vs. Data Warehouse -- Versioned Databases -- Architecture and Implementation -- Tactical DDD -- Evolving Design -- Writing Domain Layer's Code -- Consolidate Development Tools and Languages -- Architecture for Testable Systems -- Testable Code -- Testable Application -- Architecture for Deployable Systems -- Versioning -- Containerization | |
| 505 | 8 | |a Architecture for Maintainable Systems -- Mindset Shift-No Tech Debt -- Working Systems -- Common Maintenance Tasks -- Fixing It Twice -- Simple vs. Complex Systems -- Summary -- Chapter 5: Implementation and Coding -- Cross-cutting Concerns Related to Coding -- Professionalism of a Coder -- Put Talent into Important Tasks -- Continuous Improvement -- Continuous Refactoring -- Limit Works in Progress -- Quality vs. Quantity -- Code Reviews -- Designing Code -- Implementation of Architecture -- Code Design Techniques -- Essence of Object-Oriented Programming -- Confusion About OOP -- OOP Distilled -- Purpose of Design Patterns -- Composition vs. Inheritance -- Opportunities for Patterns -- Implementing Code -- Tactical DDD Patterns -- Entity -- Entities That Look Like DTOs -- Active Record Entities -- Module -- Enforcing Modular Architecture -- Repository -- Relational Database Mismatch with Repository -- Non-Relational Database Mismatch with Repository -- How About Reports? -- Factory -- Warning About Gang of Four Factory Patterns -- Command -- Warning About Commands -- Declarative Design in Code -- Front-End Development -- Front-End Repositories and Services -- Hosting Static Assets for Front-end -- Developing for Various Form Factors -- Keep Pushing the Limits -- Exception Handling -- Why Catch Exceptions? -- Why Throw Exceptions? -- Law of Demeter for Exception Handling -- Handling Globally Unhandled Exceptions -- Testing Code -- Unit Testing -- Unit Test Coverage Fallacy -- How Many Unit Tests Are Enough? -- Multiple Asserts in a Single Unit Test -- TDD, ATDD, and BDD -- TDD Is Faster Than Unit Testing -- Commonalities Between TDD, ATDD, and BDD -- Code Deployment and Maintenance -- CI/CD Before Development -- Planning Deployment When Developing -- Planning Maintenance When Developing -- Summary -- Chapter 6: Testing and Quality Assurance | |
| 505 | 8 | |a Testing Processes and Principles -- Who Is For and Who Is Against? -- Quality Is Team's Responsibility -- Test Everything, Automate Everything -- Why -- How -- Importance of Test Automation -- Who Owns Test Automation? -- Automate in Time -- Apply Best Practices -- Blur the Line -- Test Design and Architecture -- Test Types -- Integration vs. Functional Tests -- Test Case per Requirement -- Test Automation Design Patterns -- Crux of Test Case Patterns -- Gherkin Test Case Pattern -- Scenario Object Pattern -- Page Object Pattern -- Predominant Misuse of Page Object Pattern -- Test Object Pattern -- Layered Test Architecture -- Ubiquitous Language in Test -- Test Data Management -- Unit Test Data -- Integration Test Data -- Functional Test Data -- End-to-End Test Data -- Implementing Automated Tests -- Delayed Automation -- Early Automation -- Enhancing Deployments with Test Automation -- Fast Feedback and Compensating Actions -- Fast Feedback Accuracy -- Continuous Deployment -- Summary -- Chapter 7: Deployment -- Culture of Releases -- Why Release Software? -- Unimportance of Releases -- What Is the Catch? -- CI/CD-Deployment Foundation -- Continuous Integration -- Briefly About Artifacts -- Continuous Deployment -- Building Deployment-Ready Applications -- Developing Deployable Units -- Ensuring Smooth Deployments via CI/CD -- Dev-Prod Parity -- Effects of Containerization on Deployments -- Summary -- Chapter 8: Maintenance and Support -- Maintenance-Free Mindset -- Organization's Approach to Maintenance -- Support-Oriented Organizations -- Award-Winning Support Teams -- Who Prevents Problems? -- Maintenance-Aware Mindset -- Maintaining Applications in Practice -- Fix Root Cause, Not Surface -- Building Blocks of Maintainable Systems -- Summary -- Afterword: Wrap-up -- References -- Index | |
| 776 | 0 | 8 | |i Erscheint auch als |n Druck-Ausgabe |a Tutisani, Tengiz |t Effective Software Development for the Enterprise |d Berkeley, CA : Apress L. P.,c2023 |z 9781484293843 |
| 912 | |a ZDB-30-PQE | ||
| 943 | 1 | |a oai:aleph.bib-bvb.de:BVB01-035215653 | |
| 966 | e | |u https://ebookcentral.proquest.com/lib/hwr/detail.action?docID=30550680 |l DE-2070s |p ZDB-30-PQE |q HWR_PDA_PQE |x Aggregator |3 Volltext | |
Datensatz im Suchindex
| _version_ | 1819316789488648192 |
|---|---|
| any_adam_object | |
| author | Tutisani, Tengiz |
| author_facet | Tutisani, Tengiz |
| author_role | aut |
| author_sort | Tutisani, Tengiz |
| author_variant | t t tt |
| building | Verbundindex |
| bvnumber | BV049876203 |
| collection | ZDB-30-PQE |
| contents | Intro -- Table of Contents -- About the Author -- About the Technical Reviewer -- Acknowledgments -- Preface -- Chapter 1: Introduction -- History of Inefficient Monoliths -- Why People Avoid Building Effective Software -- Learning Curve -- Quality over Quantity -- Highly Paid Experts -- Naive Hopes to Survive -- Software Development Perfectionism as a State of Mind -- Is It Crazy? -- Desire Behind Perfectionism -- Is It Worth It? -- Six Pillars of Effective Software -- #1. Meet Users' Expectations -- #2. Allow No Defects -- #3. Scale Out Horizontally -- #4. Have No Dedicated Production Support Team -- #5. Accelerate Development Pace -- #6. Double the ROI per Developer, Team, and Software -- Summary -- Chapter 2: Cross-cutting Concerns -- Execution, Leadership, Management -- Importance of Software Development Transformation -- How to Achieve Software Development Transformation -- Transformation Is for Everybody -- Ad-Hoc Tasks vs. Process -- Hands-on Leaders -- Overall Support from Management -- Organizational Structure -- A Couple of Important Definitions Upfront -- Forming Organizations -- Forming Subsystems -- Forming Microservices -- Forming Teams -- Feature Teams -- Platform and Infrastructure Teams -- Forming Programs, Projects, Requirements, and Deliveries -- Organizational Silos -- Horizontal Silos -- Vertical Silos -- Autonomy vs. Reuse -- Processes, Ongoing Efforts, Teams -- Agile or Waterfall -- Transparent Teams -- Managing Work in Progress -- One for All, All for One -- Transformation from Inside -- Culture -- Professionalism in Software Development -- Trust -- Delegation of Responsibilities -- Identifying Talent -- Relaxed Team Atmosphere -- Work-Life Balance -- Candid Feedback -- Change of Mind -- Social Aspect of Engineering -- Complexity as Job Safety -- Team Spirit -- Keep It Fun -- Recruitment -- Supporting Role of Recruitment Hire Best -- Quickly, Fancy, Right -- Corrective vs. Preventive -- Summary -- Chapter 3: From Customer Insights to Internal Requirements -- Understanding Customers' Needs -- Partnership and Customer Focus -- Interview Customers -- Knowledge Exploration Exercises -- Stage #1: Casual Discussions -- Stage #2: Free-Formed Sketches -- Stage #3: Charting the Landscape -- Organization's Response to Customers' Needs -- From Customer Interview to Organizational Transformation -- Navigating the Context Map to Find Fit -- Why Form a New Subdomain? -- Cost of Introducing a Subdomain -- Requirements and Story Writing -- Ubiquitous Language: What Is It? Why Is It Important? -- Who Writes Stories? -- Ubiquitous Language in Requirements -- Writing Executable Specifications -- Halfway into Gherkin -- All the Way into Gherkin -- Planning Work -- Prioritized Backlog -- Feasibility -- Managing Dependencies -- Parent Subdomain Prescribes Child Subdomain Dependencies -- Classify Dependency -- Dependency Goes First -- Dependency Is Functional. Integration Is Technical -- Valuable Stories (Verticals) -- Technical Stories -- Carrying Out Work -- Definition of Done -- Estimates vs. Velocity -- Your Estimate Is Your Deadline -- Achieving Predictability -- Summary -- Chapter 4: Design and Architecture -- Architecture as a Cross-cutting Concern -- Definitions and Purpose -- Software Architecture -- Software Architect -- Is Architecture Dead? -- Brainstorm Before Coding -- Reuse Knowledge -- Architecture as a Service -- Partnership with Domain Experts -- Teams and Microservices -- Architecture Supports Organizational Growth -- Architecture in Analysis and Requirements Gathering -- Upfront Design Supports Gap Analysis -- Doing It in Practice -- Knowledge Exploration and Architecture -- Caveat of a Technical Solution -- Architecture Body of Knowledge -- Architecture Landscape Buy vs. Build -- Good Architectures -- Doing It in Practice -- It Is Okay to Postpone Decisions -- Architecture and Technology -- True Value of Software -- Is Technology King? -- Domain -- Using Technology -- Vendor Lock-in -- Unavoidable Level of Technology -- Abstractions Can Help -- Beware of Technologists -- Consolidate Technologies -- Domain Model Kinds -- Rich Domain -- Anemic Domain -- Big Ball of Mud -- Domain-Driven vs. Data-Driven -- Other Anti-Patterns -- Life with Anemic Domains -- Layered Software Architecture -- Popular Application Layering Patterns -- How Many Layers? -- Other Popular Layered Architectures -- Microservices -- Clarification of Terminology -- Implementing Microservices -- Integration -- Autonomy and Scale -- Scale Out -- Reusability vs. Duplication -- Evolving an Ecosystem of Microservices -- Monolithic UI Backed by Microservices -- Client-Side UI Composition -- Server-Side Page Fragment Composition -- Command Query Responsibility Segregation (CQRS) -- Employ Rich Domain to Generate Read Models -- Avoid Vendor Lockdown -- Path to Event-Driven Architecture (EDA) -- Building Cloud-Ready Applications -- Twelve-Factor App -- Containerization -- Avoiding Cloud Vendor Lock-In -- Dev-Prod Parity Locally -- Performance -- Performance vs. Clean Design -- Designing Components That Need to Be Fast -- Front-End Application Architecture -- Built-In Security -- Databases -- Database Technology Is Irrelevant to Design -- In-Memory Identity Value Generation -- Application Database vs. Data Warehouse -- Versioned Databases -- Architecture and Implementation -- Tactical DDD -- Evolving Design -- Writing Domain Layer's Code -- Consolidate Development Tools and Languages -- Architecture for Testable Systems -- Testable Code -- Testable Application -- Architecture for Deployable Systems -- Versioning -- Containerization Architecture for Maintainable Systems -- Mindset Shift-No Tech Debt -- Working Systems -- Common Maintenance Tasks -- Fixing It Twice -- Simple vs. Complex Systems -- Summary -- Chapter 5: Implementation and Coding -- Cross-cutting Concerns Related to Coding -- Professionalism of a Coder -- Put Talent into Important Tasks -- Continuous Improvement -- Continuous Refactoring -- Limit Works in Progress -- Quality vs. Quantity -- Code Reviews -- Designing Code -- Implementation of Architecture -- Code Design Techniques -- Essence of Object-Oriented Programming -- Confusion About OOP -- OOP Distilled -- Purpose of Design Patterns -- Composition vs. Inheritance -- Opportunities for Patterns -- Implementing Code -- Tactical DDD Patterns -- Entity -- Entities That Look Like DTOs -- Active Record Entities -- Module -- Enforcing Modular Architecture -- Repository -- Relational Database Mismatch with Repository -- Non-Relational Database Mismatch with Repository -- How About Reports? -- Factory -- Warning About Gang of Four Factory Patterns -- Command -- Warning About Commands -- Declarative Design in Code -- Front-End Development -- Front-End Repositories and Services -- Hosting Static Assets for Front-end -- Developing for Various Form Factors -- Keep Pushing the Limits -- Exception Handling -- Why Catch Exceptions? -- Why Throw Exceptions? -- Law of Demeter for Exception Handling -- Handling Globally Unhandled Exceptions -- Testing Code -- Unit Testing -- Unit Test Coverage Fallacy -- How Many Unit Tests Are Enough? -- Multiple Asserts in a Single Unit Test -- TDD, ATDD, and BDD -- TDD Is Faster Than Unit Testing -- Commonalities Between TDD, ATDD, and BDD -- Code Deployment and Maintenance -- CI/CD Before Development -- Planning Deployment When Developing -- Planning Maintenance When Developing -- Summary -- Chapter 6: Testing and Quality Assurance Testing Processes and Principles -- Who Is For and Who Is Against? -- Quality Is Team's Responsibility -- Test Everything, Automate Everything -- Why -- How -- Importance of Test Automation -- Who Owns Test Automation? -- Automate in Time -- Apply Best Practices -- Blur the Line -- Test Design and Architecture -- Test Types -- Integration vs. Functional Tests -- Test Case per Requirement -- Test Automation Design Patterns -- Crux of Test Case Patterns -- Gherkin Test Case Pattern -- Scenario Object Pattern -- Page Object Pattern -- Predominant Misuse of Page Object Pattern -- Test Object Pattern -- Layered Test Architecture -- Ubiquitous Language in Test -- Test Data Management -- Unit Test Data -- Integration Test Data -- Functional Test Data -- End-to-End Test Data -- Implementing Automated Tests -- Delayed Automation -- Early Automation -- Enhancing Deployments with Test Automation -- Fast Feedback and Compensating Actions -- Fast Feedback Accuracy -- Continuous Deployment -- Summary -- Chapter 7: Deployment -- Culture of Releases -- Why Release Software? -- Unimportance of Releases -- What Is the Catch? -- CI/CD-Deployment Foundation -- Continuous Integration -- Briefly About Artifacts -- Continuous Deployment -- Building Deployment-Ready Applications -- Developing Deployable Units -- Ensuring Smooth Deployments via CI/CD -- Dev-Prod Parity -- Effects of Containerization on Deployments -- Summary -- Chapter 8: Maintenance and Support -- Maintenance-Free Mindset -- Organization's Approach to Maintenance -- Support-Oriented Organizations -- Award-Winning Support Teams -- Who Prevents Problems? -- Maintenance-Aware Mindset -- Maintaining Applications in Practice -- Fix Root Cause, Not Surface -- Building Blocks of Maintainable Systems -- Summary -- Afterword: Wrap-up -- References -- Index |
| ctrlnum | (ZDB-30-PQE)EBC30550680 (ZDB-30-PAD)EBC30550680 (ZDB-89-EBL)EBL30550680 (OCoLC)1380465440 (DE-599)BVBBV049876203 |
| dewey-full | 658.0551 |
| dewey-hundreds | 600 - Technology (Applied sciences) |
| dewey-ones | 658 - General management |
| dewey-raw | 658.0551 |
| dewey-search | 658.0551 |
| dewey-sort | 3658.0551 |
| dewey-tens | 650 - Management and auxiliary services |
| discipline | Wirtschaftswissenschaften |
| edition | 1st ed |
| format | Electronic eBook |
| fullrecord | <?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>10938nam a2200433zc 4500</leader><controlfield tag="001">BV049876203</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">00000000000000.0</controlfield><controlfield tag="007">cr|uuu---uuuuu</controlfield><controlfield tag="008">240919s2023 xx o|||| 00||| eng d</controlfield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9781484293850</subfield><subfield code="9">978-1-4842-9385-0</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(ZDB-30-PQE)EBC30550680</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(ZDB-30-PAD)EBC30550680</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(ZDB-89-EBL)EBL30550680</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)1380465440</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)BVBBV049876203</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">rda</subfield></datafield><datafield tag="041" ind1="0" ind2=" "><subfield code="a">eng</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-2070s</subfield></datafield><datafield tag="082" ind1="0" ind2=" "><subfield code="a">658.0551</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">Tutisani, Tengiz</subfield><subfield code="e">Verfasser</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">Effective Software Development for the Enterprise</subfield><subfield code="b">Beyond Domain Driven Design, Software Architecture, and Extreme Programming</subfield></datafield><datafield tag="250" ind1=" " ind2=" "><subfield code="a">1st ed</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">Berkeley, CA</subfield><subfield code="b">Apress L. P.</subfield><subfield code="c">2023</subfield></datafield><datafield tag="264" ind1=" " ind2="4"><subfield code="c">©2023</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">1 Online-Ressource (344 Seiten)</subfield></datafield><datafield tag="336" ind1=" " ind2=" "><subfield code="b">txt</subfield><subfield code="2">rdacontent</subfield></datafield><datafield tag="337" ind1=" " ind2=" "><subfield code="b">c</subfield><subfield code="2">rdamedia</subfield></datafield><datafield tag="338" ind1=" " ind2=" "><subfield code="b">cr</subfield><subfield code="2">rdacarrier</subfield></datafield><datafield tag="500" ind1=" " ind2=" "><subfield code="a">Description based on publisher supplied metadata and other sources</subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">Intro -- Table of Contents -- About the Author -- About the Technical Reviewer -- Acknowledgments -- Preface -- Chapter 1: Introduction -- History of Inefficient Monoliths -- Why People Avoid Building Effective Software -- Learning Curve -- Quality over Quantity -- Highly Paid Experts -- Naive Hopes to Survive -- Software Development Perfectionism as a State of Mind -- Is It Crazy? -- Desire Behind Perfectionism -- Is It Worth It? -- Six Pillars of Effective Software -- #1. Meet Users' Expectations -- #2. Allow No Defects -- #3. Scale Out Horizontally -- #4. Have No Dedicated Production Support Team -- #5. Accelerate Development Pace -- #6. Double the ROI per Developer, Team, and Software -- Summary -- Chapter 2: Cross-cutting Concerns -- Execution, Leadership, Management -- Importance of Software Development Transformation -- How to Achieve Software Development Transformation -- Transformation Is for Everybody -- Ad-Hoc Tasks vs. Process -- Hands-on Leaders -- Overall Support from Management -- Organizational Structure -- A Couple of Important Definitions Upfront -- Forming Organizations -- Forming Subsystems -- Forming Microservices -- Forming Teams -- Feature Teams -- Platform and Infrastructure Teams -- Forming Programs, Projects, Requirements, and Deliveries -- Organizational Silos -- Horizontal Silos -- Vertical Silos -- Autonomy vs. Reuse -- Processes, Ongoing Efforts, Teams -- Agile or Waterfall -- Transparent Teams -- Managing Work in Progress -- One for All, All for One -- Transformation from Inside -- Culture -- Professionalism in Software Development -- Trust -- Delegation of Responsibilities -- Identifying Talent -- Relaxed Team Atmosphere -- Work-Life Balance -- Candid Feedback -- Change of Mind -- Social Aspect of Engineering -- Complexity as Job Safety -- Team Spirit -- Keep It Fun -- Recruitment -- Supporting Role of Recruitment</subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">Hire Best -- Quickly, Fancy, Right -- Corrective vs. Preventive -- Summary -- Chapter 3: From Customer Insights to Internal Requirements -- Understanding Customers' Needs -- Partnership and Customer Focus -- Interview Customers -- Knowledge Exploration Exercises -- Stage #1: Casual Discussions -- Stage #2: Free-Formed Sketches -- Stage #3: Charting the Landscape -- Organization's Response to Customers' Needs -- From Customer Interview to Organizational Transformation -- Navigating the Context Map to Find Fit -- Why Form a New Subdomain? -- Cost of Introducing a Subdomain -- Requirements and Story Writing -- Ubiquitous Language: What Is It? Why Is It Important? -- Who Writes Stories? -- Ubiquitous Language in Requirements -- Writing Executable Specifications -- Halfway into Gherkin -- All the Way into Gherkin -- Planning Work -- Prioritized Backlog -- Feasibility -- Managing Dependencies -- Parent Subdomain Prescribes Child Subdomain Dependencies -- Classify Dependency -- Dependency Goes First -- Dependency Is Functional. Integration Is Technical -- Valuable Stories (Verticals) -- Technical Stories -- Carrying Out Work -- Definition of Done -- Estimates vs. Velocity -- Your Estimate Is Your Deadline -- Achieving Predictability -- Summary -- Chapter 4: Design and Architecture -- Architecture as a Cross-cutting Concern -- Definitions and Purpose -- Software Architecture -- Software Architect -- Is Architecture Dead? -- Brainstorm Before Coding -- Reuse Knowledge -- Architecture as a Service -- Partnership with Domain Experts -- Teams and Microservices -- Architecture Supports Organizational Growth -- Architecture in Analysis and Requirements Gathering -- Upfront Design Supports Gap Analysis -- Doing It in Practice -- Knowledge Exploration and Architecture -- Caveat of a Technical Solution -- Architecture Body of Knowledge -- Architecture Landscape</subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">Buy vs. Build -- Good Architectures -- Doing It in Practice -- It Is Okay to Postpone Decisions -- Architecture and Technology -- True Value of Software -- Is Technology King? -- Domain -- Using Technology -- Vendor Lock-in -- Unavoidable Level of Technology -- Abstractions Can Help -- Beware of Technologists -- Consolidate Technologies -- Domain Model Kinds -- Rich Domain -- Anemic Domain -- Big Ball of Mud -- Domain-Driven vs. Data-Driven -- Other Anti-Patterns -- Life with Anemic Domains -- Layered Software Architecture -- Popular Application Layering Patterns -- How Many Layers? -- Other Popular Layered Architectures -- Microservices -- Clarification of Terminology -- Implementing Microservices -- Integration -- Autonomy and Scale -- Scale Out -- Reusability vs. Duplication -- Evolving an Ecosystem of Microservices -- Monolithic UI Backed by Microservices -- Client-Side UI Composition -- Server-Side Page Fragment Composition -- Command Query Responsibility Segregation (CQRS) -- Employ Rich Domain to Generate Read Models -- Avoid Vendor Lockdown -- Path to Event-Driven Architecture (EDA) -- Building Cloud-Ready Applications -- Twelve-Factor App -- Containerization -- Avoiding Cloud Vendor Lock-In -- Dev-Prod Parity Locally -- Performance -- Performance vs. Clean Design -- Designing Components That Need to Be Fast -- Front-End Application Architecture -- Built-In Security -- Databases -- Database Technology Is Irrelevant to Design -- In-Memory Identity Value Generation -- Application Database vs. Data Warehouse -- Versioned Databases -- Architecture and Implementation -- Tactical DDD -- Evolving Design -- Writing Domain Layer's Code -- Consolidate Development Tools and Languages -- Architecture for Testable Systems -- Testable Code -- Testable Application -- Architecture for Deployable Systems -- Versioning -- Containerization</subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">Architecture for Maintainable Systems -- Mindset Shift-No Tech Debt -- Working Systems -- Common Maintenance Tasks -- Fixing It Twice -- Simple vs. Complex Systems -- Summary -- Chapter 5: Implementation and Coding -- Cross-cutting Concerns Related to Coding -- Professionalism of a Coder -- Put Talent into Important Tasks -- Continuous Improvement -- Continuous Refactoring -- Limit Works in Progress -- Quality vs. Quantity -- Code Reviews -- Designing Code -- Implementation of Architecture -- Code Design Techniques -- Essence of Object-Oriented Programming -- Confusion About OOP -- OOP Distilled -- Purpose of Design Patterns -- Composition vs. Inheritance -- Opportunities for Patterns -- Implementing Code -- Tactical DDD Patterns -- Entity -- Entities That Look Like DTOs -- Active Record Entities -- Module -- Enforcing Modular Architecture -- Repository -- Relational Database Mismatch with Repository -- Non-Relational Database Mismatch with Repository -- How About Reports? -- Factory -- Warning About Gang of Four Factory Patterns -- Command -- Warning About Commands -- Declarative Design in Code -- Front-End Development -- Front-End Repositories and Services -- Hosting Static Assets for Front-end -- Developing for Various Form Factors -- Keep Pushing the Limits -- Exception Handling -- Why Catch Exceptions? -- Why Throw Exceptions? -- Law of Demeter for Exception Handling -- Handling Globally Unhandled Exceptions -- Testing Code -- Unit Testing -- Unit Test Coverage Fallacy -- How Many Unit Tests Are Enough? -- Multiple Asserts in a Single Unit Test -- TDD, ATDD, and BDD -- TDD Is Faster Than Unit Testing -- Commonalities Between TDD, ATDD, and BDD -- Code Deployment and Maintenance -- CI/CD Before Development -- Planning Deployment When Developing -- Planning Maintenance When Developing -- Summary -- Chapter 6: Testing and Quality Assurance</subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">Testing Processes and Principles -- Who Is For and Who Is Against? -- Quality Is Team's Responsibility -- Test Everything, Automate Everything -- Why -- How -- Importance of Test Automation -- Who Owns Test Automation? -- Automate in Time -- Apply Best Practices -- Blur the Line -- Test Design and Architecture -- Test Types -- Integration vs. Functional Tests -- Test Case per Requirement -- Test Automation Design Patterns -- Crux of Test Case Patterns -- Gherkin Test Case Pattern -- Scenario Object Pattern -- Page Object Pattern -- Predominant Misuse of Page Object Pattern -- Test Object Pattern -- Layered Test Architecture -- Ubiquitous Language in Test -- Test Data Management -- Unit Test Data -- Integration Test Data -- Functional Test Data -- End-to-End Test Data -- Implementing Automated Tests -- Delayed Automation -- Early Automation -- Enhancing Deployments with Test Automation -- Fast Feedback and Compensating Actions -- Fast Feedback Accuracy -- Continuous Deployment -- Summary -- Chapter 7: Deployment -- Culture of Releases -- Why Release Software? -- Unimportance of Releases -- What Is the Catch? -- CI/CD-Deployment Foundation -- Continuous Integration -- Briefly About Artifacts -- Continuous Deployment -- Building Deployment-Ready Applications -- Developing Deployable Units -- Ensuring Smooth Deployments via CI/CD -- Dev-Prod Parity -- Effects of Containerization on Deployments -- Summary -- Chapter 8: Maintenance and Support -- Maintenance-Free Mindset -- Organization's Approach to Maintenance -- Support-Oriented Organizations -- Award-Winning Support Teams -- Who Prevents Problems? -- Maintenance-Aware Mindset -- Maintaining Applications in Practice -- Fix Root Cause, Not Surface -- Building Blocks of Maintainable Systems -- Summary -- Afterword: Wrap-up -- References -- Index</subfield></datafield><datafield tag="776" ind1="0" ind2="8"><subfield code="i">Erscheint auch als</subfield><subfield code="n">Druck-Ausgabe</subfield><subfield code="a">Tutisani, Tengiz</subfield><subfield code="t">Effective Software Development for the Enterprise</subfield><subfield code="d">Berkeley, CA : Apress L. P.,c2023</subfield><subfield code="z">9781484293843</subfield></datafield><datafield tag="912" ind1=" " ind2=" "><subfield code="a">ZDB-30-PQE</subfield></datafield><datafield tag="943" ind1="1" ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-035215653</subfield></datafield><datafield tag="966" ind1="e" ind2=" "><subfield code="u">https://ebookcentral.proquest.com/lib/hwr/detail.action?docID=30550680</subfield><subfield code="l">DE-2070s</subfield><subfield code="p">ZDB-30-PQE</subfield><subfield code="q">HWR_PDA_PQE</subfield><subfield code="x">Aggregator</subfield><subfield code="3">Volltext</subfield></datafield></record></collection> |
| id | DE-604.BV049876203 |
| illustrated | Not Illustrated |
| indexdate | 2024-12-24T10:21:35Z |
| institution | BVB |
| isbn | 9781484293850 |
| language | English |
| oai_aleph_id | oai:aleph.bib-bvb.de:BVB01-035215653 |
| oclc_num | 1380465440 |
| open_access_boolean | |
| owner | DE-2070s |
| owner_facet | DE-2070s |
| physical | 1 Online-Ressource (344 Seiten) |
| psigel | ZDB-30-PQE ZDB-30-PQE HWR_PDA_PQE |
| publishDate | 2023 |
| publishDateSearch | 2023 |
| publishDateSort | 2023 |
| publisher | Apress L. P. |
| record_format | marc |
| spelling | Tutisani, Tengiz Verfasser aut Effective Software Development for the Enterprise Beyond Domain Driven Design, Software Architecture, and Extreme Programming 1st ed Berkeley, CA Apress L. P. 2023 ©2023 1 Online-Ressource (344 Seiten) txt rdacontent c rdamedia cr rdacarrier Description based on publisher supplied metadata and other sources Intro -- Table of Contents -- About the Author -- About the Technical Reviewer -- Acknowledgments -- Preface -- Chapter 1: Introduction -- History of Inefficient Monoliths -- Why People Avoid Building Effective Software -- Learning Curve -- Quality over Quantity -- Highly Paid Experts -- Naive Hopes to Survive -- Software Development Perfectionism as a State of Mind -- Is It Crazy? -- Desire Behind Perfectionism -- Is It Worth It? -- Six Pillars of Effective Software -- #1. Meet Users' Expectations -- #2. Allow No Defects -- #3. Scale Out Horizontally -- #4. Have No Dedicated Production Support Team -- #5. Accelerate Development Pace -- #6. Double the ROI per Developer, Team, and Software -- Summary -- Chapter 2: Cross-cutting Concerns -- Execution, Leadership, Management -- Importance of Software Development Transformation -- How to Achieve Software Development Transformation -- Transformation Is for Everybody -- Ad-Hoc Tasks vs. Process -- Hands-on Leaders -- Overall Support from Management -- Organizational Structure -- A Couple of Important Definitions Upfront -- Forming Organizations -- Forming Subsystems -- Forming Microservices -- Forming Teams -- Feature Teams -- Platform and Infrastructure Teams -- Forming Programs, Projects, Requirements, and Deliveries -- Organizational Silos -- Horizontal Silos -- Vertical Silos -- Autonomy vs. Reuse -- Processes, Ongoing Efforts, Teams -- Agile or Waterfall -- Transparent Teams -- Managing Work in Progress -- One for All, All for One -- Transformation from Inside -- Culture -- Professionalism in Software Development -- Trust -- Delegation of Responsibilities -- Identifying Talent -- Relaxed Team Atmosphere -- Work-Life Balance -- Candid Feedback -- Change of Mind -- Social Aspect of Engineering -- Complexity as Job Safety -- Team Spirit -- Keep It Fun -- Recruitment -- Supporting Role of Recruitment Hire Best -- Quickly, Fancy, Right -- Corrective vs. Preventive -- Summary -- Chapter 3: From Customer Insights to Internal Requirements -- Understanding Customers' Needs -- Partnership and Customer Focus -- Interview Customers -- Knowledge Exploration Exercises -- Stage #1: Casual Discussions -- Stage #2: Free-Formed Sketches -- Stage #3: Charting the Landscape -- Organization's Response to Customers' Needs -- From Customer Interview to Organizational Transformation -- Navigating the Context Map to Find Fit -- Why Form a New Subdomain? -- Cost of Introducing a Subdomain -- Requirements and Story Writing -- Ubiquitous Language: What Is It? Why Is It Important? -- Who Writes Stories? -- Ubiquitous Language in Requirements -- Writing Executable Specifications -- Halfway into Gherkin -- All the Way into Gherkin -- Planning Work -- Prioritized Backlog -- Feasibility -- Managing Dependencies -- Parent Subdomain Prescribes Child Subdomain Dependencies -- Classify Dependency -- Dependency Goes First -- Dependency Is Functional. Integration Is Technical -- Valuable Stories (Verticals) -- Technical Stories -- Carrying Out Work -- Definition of Done -- Estimates vs. Velocity -- Your Estimate Is Your Deadline -- Achieving Predictability -- Summary -- Chapter 4: Design and Architecture -- Architecture as a Cross-cutting Concern -- Definitions and Purpose -- Software Architecture -- Software Architect -- Is Architecture Dead? -- Brainstorm Before Coding -- Reuse Knowledge -- Architecture as a Service -- Partnership with Domain Experts -- Teams and Microservices -- Architecture Supports Organizational Growth -- Architecture in Analysis and Requirements Gathering -- Upfront Design Supports Gap Analysis -- Doing It in Practice -- Knowledge Exploration and Architecture -- Caveat of a Technical Solution -- Architecture Body of Knowledge -- Architecture Landscape Buy vs. Build -- Good Architectures -- Doing It in Practice -- It Is Okay to Postpone Decisions -- Architecture and Technology -- True Value of Software -- Is Technology King? -- Domain -- Using Technology -- Vendor Lock-in -- Unavoidable Level of Technology -- Abstractions Can Help -- Beware of Technologists -- Consolidate Technologies -- Domain Model Kinds -- Rich Domain -- Anemic Domain -- Big Ball of Mud -- Domain-Driven vs. Data-Driven -- Other Anti-Patterns -- Life with Anemic Domains -- Layered Software Architecture -- Popular Application Layering Patterns -- How Many Layers? -- Other Popular Layered Architectures -- Microservices -- Clarification of Terminology -- Implementing Microservices -- Integration -- Autonomy and Scale -- Scale Out -- Reusability vs. Duplication -- Evolving an Ecosystem of Microservices -- Monolithic UI Backed by Microservices -- Client-Side UI Composition -- Server-Side Page Fragment Composition -- Command Query Responsibility Segregation (CQRS) -- Employ Rich Domain to Generate Read Models -- Avoid Vendor Lockdown -- Path to Event-Driven Architecture (EDA) -- Building Cloud-Ready Applications -- Twelve-Factor App -- Containerization -- Avoiding Cloud Vendor Lock-In -- Dev-Prod Parity Locally -- Performance -- Performance vs. Clean Design -- Designing Components That Need to Be Fast -- Front-End Application Architecture -- Built-In Security -- Databases -- Database Technology Is Irrelevant to Design -- In-Memory Identity Value Generation -- Application Database vs. Data Warehouse -- Versioned Databases -- Architecture and Implementation -- Tactical DDD -- Evolving Design -- Writing Domain Layer's Code -- Consolidate Development Tools and Languages -- Architecture for Testable Systems -- Testable Code -- Testable Application -- Architecture for Deployable Systems -- Versioning -- Containerization Architecture for Maintainable Systems -- Mindset Shift-No Tech Debt -- Working Systems -- Common Maintenance Tasks -- Fixing It Twice -- Simple vs. Complex Systems -- Summary -- Chapter 5: Implementation and Coding -- Cross-cutting Concerns Related to Coding -- Professionalism of a Coder -- Put Talent into Important Tasks -- Continuous Improvement -- Continuous Refactoring -- Limit Works in Progress -- Quality vs. Quantity -- Code Reviews -- Designing Code -- Implementation of Architecture -- Code Design Techniques -- Essence of Object-Oriented Programming -- Confusion About OOP -- OOP Distilled -- Purpose of Design Patterns -- Composition vs. Inheritance -- Opportunities for Patterns -- Implementing Code -- Tactical DDD Patterns -- Entity -- Entities That Look Like DTOs -- Active Record Entities -- Module -- Enforcing Modular Architecture -- Repository -- Relational Database Mismatch with Repository -- Non-Relational Database Mismatch with Repository -- How About Reports? -- Factory -- Warning About Gang of Four Factory Patterns -- Command -- Warning About Commands -- Declarative Design in Code -- Front-End Development -- Front-End Repositories and Services -- Hosting Static Assets for Front-end -- Developing for Various Form Factors -- Keep Pushing the Limits -- Exception Handling -- Why Catch Exceptions? -- Why Throw Exceptions? -- Law of Demeter for Exception Handling -- Handling Globally Unhandled Exceptions -- Testing Code -- Unit Testing -- Unit Test Coverage Fallacy -- How Many Unit Tests Are Enough? -- Multiple Asserts in a Single Unit Test -- TDD, ATDD, and BDD -- TDD Is Faster Than Unit Testing -- Commonalities Between TDD, ATDD, and BDD -- Code Deployment and Maintenance -- CI/CD Before Development -- Planning Deployment When Developing -- Planning Maintenance When Developing -- Summary -- Chapter 6: Testing and Quality Assurance Testing Processes and Principles -- Who Is For and Who Is Against? -- Quality Is Team's Responsibility -- Test Everything, Automate Everything -- Why -- How -- Importance of Test Automation -- Who Owns Test Automation? -- Automate in Time -- Apply Best Practices -- Blur the Line -- Test Design and Architecture -- Test Types -- Integration vs. Functional Tests -- Test Case per Requirement -- Test Automation Design Patterns -- Crux of Test Case Patterns -- Gherkin Test Case Pattern -- Scenario Object Pattern -- Page Object Pattern -- Predominant Misuse of Page Object Pattern -- Test Object Pattern -- Layered Test Architecture -- Ubiquitous Language in Test -- Test Data Management -- Unit Test Data -- Integration Test Data -- Functional Test Data -- End-to-End Test Data -- Implementing Automated Tests -- Delayed Automation -- Early Automation -- Enhancing Deployments with Test Automation -- Fast Feedback and Compensating Actions -- Fast Feedback Accuracy -- Continuous Deployment -- Summary -- Chapter 7: Deployment -- Culture of Releases -- Why Release Software? -- Unimportance of Releases -- What Is the Catch? -- CI/CD-Deployment Foundation -- Continuous Integration -- Briefly About Artifacts -- Continuous Deployment -- Building Deployment-Ready Applications -- Developing Deployable Units -- Ensuring Smooth Deployments via CI/CD -- Dev-Prod Parity -- Effects of Containerization on Deployments -- Summary -- Chapter 8: Maintenance and Support -- Maintenance-Free Mindset -- Organization's Approach to Maintenance -- Support-Oriented Organizations -- Award-Winning Support Teams -- Who Prevents Problems? -- Maintenance-Aware Mindset -- Maintaining Applications in Practice -- Fix Root Cause, Not Surface -- Building Blocks of Maintainable Systems -- Summary -- Afterword: Wrap-up -- References -- Index Erscheint auch als Druck-Ausgabe Tutisani, Tengiz Effective Software Development for the Enterprise Berkeley, CA : Apress L. P.,c2023 9781484293843 |
| spellingShingle | Tutisani, Tengiz Effective Software Development for the Enterprise Beyond Domain Driven Design, Software Architecture, and Extreme Programming Intro -- Table of Contents -- About the Author -- About the Technical Reviewer -- Acknowledgments -- Preface -- Chapter 1: Introduction -- History of Inefficient Monoliths -- Why People Avoid Building Effective Software -- Learning Curve -- Quality over Quantity -- Highly Paid Experts -- Naive Hopes to Survive -- Software Development Perfectionism as a State of Mind -- Is It Crazy? -- Desire Behind Perfectionism -- Is It Worth It? -- Six Pillars of Effective Software -- #1. Meet Users' Expectations -- #2. Allow No Defects -- #3. Scale Out Horizontally -- #4. Have No Dedicated Production Support Team -- #5. Accelerate Development Pace -- #6. Double the ROI per Developer, Team, and Software -- Summary -- Chapter 2: Cross-cutting Concerns -- Execution, Leadership, Management -- Importance of Software Development Transformation -- How to Achieve Software Development Transformation -- Transformation Is for Everybody -- Ad-Hoc Tasks vs. Process -- Hands-on Leaders -- Overall Support from Management -- Organizational Structure -- A Couple of Important Definitions Upfront -- Forming Organizations -- Forming Subsystems -- Forming Microservices -- Forming Teams -- Feature Teams -- Platform and Infrastructure Teams -- Forming Programs, Projects, Requirements, and Deliveries -- Organizational Silos -- Horizontal Silos -- Vertical Silos -- Autonomy vs. Reuse -- Processes, Ongoing Efforts, Teams -- Agile or Waterfall -- Transparent Teams -- Managing Work in Progress -- One for All, All for One -- Transformation from Inside -- Culture -- Professionalism in Software Development -- Trust -- Delegation of Responsibilities -- Identifying Talent -- Relaxed Team Atmosphere -- Work-Life Balance -- Candid Feedback -- Change of Mind -- Social Aspect of Engineering -- Complexity as Job Safety -- Team Spirit -- Keep It Fun -- Recruitment -- Supporting Role of Recruitment Hire Best -- Quickly, Fancy, Right -- Corrective vs. Preventive -- Summary -- Chapter 3: From Customer Insights to Internal Requirements -- Understanding Customers' Needs -- Partnership and Customer Focus -- Interview Customers -- Knowledge Exploration Exercises -- Stage #1: Casual Discussions -- Stage #2: Free-Formed Sketches -- Stage #3: Charting the Landscape -- Organization's Response to Customers' Needs -- From Customer Interview to Organizational Transformation -- Navigating the Context Map to Find Fit -- Why Form a New Subdomain? -- Cost of Introducing a Subdomain -- Requirements and Story Writing -- Ubiquitous Language: What Is It? Why Is It Important? -- Who Writes Stories? -- Ubiquitous Language in Requirements -- Writing Executable Specifications -- Halfway into Gherkin -- All the Way into Gherkin -- Planning Work -- Prioritized Backlog -- Feasibility -- Managing Dependencies -- Parent Subdomain Prescribes Child Subdomain Dependencies -- Classify Dependency -- Dependency Goes First -- Dependency Is Functional. Integration Is Technical -- Valuable Stories (Verticals) -- Technical Stories -- Carrying Out Work -- Definition of Done -- Estimates vs. Velocity -- Your Estimate Is Your Deadline -- Achieving Predictability -- Summary -- Chapter 4: Design and Architecture -- Architecture as a Cross-cutting Concern -- Definitions and Purpose -- Software Architecture -- Software Architect -- Is Architecture Dead? -- Brainstorm Before Coding -- Reuse Knowledge -- Architecture as a Service -- Partnership with Domain Experts -- Teams and Microservices -- Architecture Supports Organizational Growth -- Architecture in Analysis and Requirements Gathering -- Upfront Design Supports Gap Analysis -- Doing It in Practice -- Knowledge Exploration and Architecture -- Caveat of a Technical Solution -- Architecture Body of Knowledge -- Architecture Landscape Buy vs. Build -- Good Architectures -- Doing It in Practice -- It Is Okay to Postpone Decisions -- Architecture and Technology -- True Value of Software -- Is Technology King? -- Domain -- Using Technology -- Vendor Lock-in -- Unavoidable Level of Technology -- Abstractions Can Help -- Beware of Technologists -- Consolidate Technologies -- Domain Model Kinds -- Rich Domain -- Anemic Domain -- Big Ball of Mud -- Domain-Driven vs. Data-Driven -- Other Anti-Patterns -- Life with Anemic Domains -- Layered Software Architecture -- Popular Application Layering Patterns -- How Many Layers? -- Other Popular Layered Architectures -- Microservices -- Clarification of Terminology -- Implementing Microservices -- Integration -- Autonomy and Scale -- Scale Out -- Reusability vs. Duplication -- Evolving an Ecosystem of Microservices -- Monolithic UI Backed by Microservices -- Client-Side UI Composition -- Server-Side Page Fragment Composition -- Command Query Responsibility Segregation (CQRS) -- Employ Rich Domain to Generate Read Models -- Avoid Vendor Lockdown -- Path to Event-Driven Architecture (EDA) -- Building Cloud-Ready Applications -- Twelve-Factor App -- Containerization -- Avoiding Cloud Vendor Lock-In -- Dev-Prod Parity Locally -- Performance -- Performance vs. Clean Design -- Designing Components That Need to Be Fast -- Front-End Application Architecture -- Built-In Security -- Databases -- Database Technology Is Irrelevant to Design -- In-Memory Identity Value Generation -- Application Database vs. Data Warehouse -- Versioned Databases -- Architecture and Implementation -- Tactical DDD -- Evolving Design -- Writing Domain Layer's Code -- Consolidate Development Tools and Languages -- Architecture for Testable Systems -- Testable Code -- Testable Application -- Architecture for Deployable Systems -- Versioning -- Containerization Architecture for Maintainable Systems -- Mindset Shift-No Tech Debt -- Working Systems -- Common Maintenance Tasks -- Fixing It Twice -- Simple vs. Complex Systems -- Summary -- Chapter 5: Implementation and Coding -- Cross-cutting Concerns Related to Coding -- Professionalism of a Coder -- Put Talent into Important Tasks -- Continuous Improvement -- Continuous Refactoring -- Limit Works in Progress -- Quality vs. Quantity -- Code Reviews -- Designing Code -- Implementation of Architecture -- Code Design Techniques -- Essence of Object-Oriented Programming -- Confusion About OOP -- OOP Distilled -- Purpose of Design Patterns -- Composition vs. Inheritance -- Opportunities for Patterns -- Implementing Code -- Tactical DDD Patterns -- Entity -- Entities That Look Like DTOs -- Active Record Entities -- Module -- Enforcing Modular Architecture -- Repository -- Relational Database Mismatch with Repository -- Non-Relational Database Mismatch with Repository -- How About Reports? -- Factory -- Warning About Gang of Four Factory Patterns -- Command -- Warning About Commands -- Declarative Design in Code -- Front-End Development -- Front-End Repositories and Services -- Hosting Static Assets for Front-end -- Developing for Various Form Factors -- Keep Pushing the Limits -- Exception Handling -- Why Catch Exceptions? -- Why Throw Exceptions? -- Law of Demeter for Exception Handling -- Handling Globally Unhandled Exceptions -- Testing Code -- Unit Testing -- Unit Test Coverage Fallacy -- How Many Unit Tests Are Enough? -- Multiple Asserts in a Single Unit Test -- TDD, ATDD, and BDD -- TDD Is Faster Than Unit Testing -- Commonalities Between TDD, ATDD, and BDD -- Code Deployment and Maintenance -- CI/CD Before Development -- Planning Deployment When Developing -- Planning Maintenance When Developing -- Summary -- Chapter 6: Testing and Quality Assurance Testing Processes and Principles -- Who Is For and Who Is Against? -- Quality Is Team's Responsibility -- Test Everything, Automate Everything -- Why -- How -- Importance of Test Automation -- Who Owns Test Automation? -- Automate in Time -- Apply Best Practices -- Blur the Line -- Test Design and Architecture -- Test Types -- Integration vs. Functional Tests -- Test Case per Requirement -- Test Automation Design Patterns -- Crux of Test Case Patterns -- Gherkin Test Case Pattern -- Scenario Object Pattern -- Page Object Pattern -- Predominant Misuse of Page Object Pattern -- Test Object Pattern -- Layered Test Architecture -- Ubiquitous Language in Test -- Test Data Management -- Unit Test Data -- Integration Test Data -- Functional Test Data -- End-to-End Test Data -- Implementing Automated Tests -- Delayed Automation -- Early Automation -- Enhancing Deployments with Test Automation -- Fast Feedback and Compensating Actions -- Fast Feedback Accuracy -- Continuous Deployment -- Summary -- Chapter 7: Deployment -- Culture of Releases -- Why Release Software? -- Unimportance of Releases -- What Is the Catch? -- CI/CD-Deployment Foundation -- Continuous Integration -- Briefly About Artifacts -- Continuous Deployment -- Building Deployment-Ready Applications -- Developing Deployable Units -- Ensuring Smooth Deployments via CI/CD -- Dev-Prod Parity -- Effects of Containerization on Deployments -- Summary -- Chapter 8: Maintenance and Support -- Maintenance-Free Mindset -- Organization's Approach to Maintenance -- Support-Oriented Organizations -- Award-Winning Support Teams -- Who Prevents Problems? -- Maintenance-Aware Mindset -- Maintaining Applications in Practice -- Fix Root Cause, Not Surface -- Building Blocks of Maintainable Systems -- Summary -- Afterword: Wrap-up -- References -- Index |
| title | Effective Software Development for the Enterprise Beyond Domain Driven Design, Software Architecture, and Extreme Programming |
| title_auth | Effective Software Development for the Enterprise Beyond Domain Driven Design, Software Architecture, and Extreme Programming |
| title_exact_search | Effective Software Development for the Enterprise Beyond Domain Driven Design, Software Architecture, and Extreme Programming |
| title_full | Effective Software Development for the Enterprise Beyond Domain Driven Design, Software Architecture, and Extreme Programming |
| title_fullStr | Effective Software Development for the Enterprise Beyond Domain Driven Design, Software Architecture, and Extreme Programming |
| title_full_unstemmed | Effective Software Development for the Enterprise Beyond Domain Driven Design, Software Architecture, and Extreme Programming |
| title_short | Effective Software Development for the Enterprise |
| title_sort | effective software development for the enterprise beyond domain driven design software architecture and extreme programming |
| title_sub | Beyond Domain Driven Design, Software Architecture, and Extreme Programming |
| work_keys_str_mv | AT tutisanitengiz effectivesoftwaredevelopmentfortheenterprisebeyonddomaindrivendesignsoftwarearchitectureandextremeprogramming |