Software Engineering Books

Book SynopsisRust Servers, Services, and Apps is a hands-on guide to developing modern distributed web applications with Rust. You'll learn how to build efficient services, write custom web servers, and even build full stack applications end-to-end in Rust. You'll start with the foundations, using Rust to build an HTTP server, and RESTful API that you'll secure, debug, and evolve with fearless refactoring. You'll then put Rust through its paces to develop a digital storefront service, and a single-page client-side application. This fastpaced book is packed with code samples you can adapt to your own projects, and detailed annotations to help you understand how Rust works under the hood. About the technologyThe blazingly fast, safe, and efficient Rust language has been voted “most loved” for five consecutive years on the StackOverflow survey. It's easy to see why. Rust combines all the features of a modern language with the low-latency power of C. Its efficiency will slash your runtime footprint—and your cloud hosting bills—and its flexibility lets you write network programs and high-level applications with equal ease.Trade Review"The missing book for anyone that has taken the time to learn Rust but now doesn't know how to apply the language to any real world scenarios." Gustavo Filipe Ramos Gomes "This is my kind of book! The author takes you through writing a variety of web services in Rust toward a final project." Jerome Meyer "Great examples with good level of difficulty." Marcos Oliveira "A clear and pragmatic guide to building services in Rust." Dan Sheikh

Read more less

Book SynopsisProfessor Ian Sommerville is an Emeritus Professor at the School of Computer Science, University of St. Andrews. His research interests are focused on dependable socio-technical systems and incorporating their techniques in systems engineering processesTable of ContentsPart 1 Introduction to Software Engineering Chapter 1: Introduction Chapter 2: Software processes Chapter 3: Agile software development Chapter 4: Requirements engineering Chapter 5: System modeling Chapter 6: Architectural design Chapter 7: Design and Implementation Chapter 8: Software testing Chapter 9: Software Evolution Part 2 System Dependability and Security Chapter 10: Dependable Systems Chapter 11: Reliability engineering Chapter 12: Safety Engineering Chapter 13: Security Engineering Chapter 14: Resilience Engineering Part 3 Advanced Software Engineering Chapter 15: Software Reuse Chapter 16: Component-based Software Engineering Chapter 17: Distributed Software Engineering Chapter 18: Service-oriented Software Engineering Chapter 19: Systems engineering Chapter 20: Systems of systems Chapter 21: Real-time software engineering Part 4 Software management Chapter 22: Project management Chapter 23: Project planning Chapter 24: Quality management Chapter 25: Configuration management Glossary Appendix: System requirements for the MentCare system

Read more less

Book SynopsisAlistair Cockburn is a recognized expert on use cases. He is consulting fellow at Humans and Technology, where he is responsible for helping clients succeed with object-oriented projects. He has more than twenty years of experience leading projects in hardware and software development in insurance, retail, and e-commerce companies and in large organizations such as the Central Bank of Norway and IBM. 0201702258AB07302002 Table of Contents Preface. Acknowlegments. 1. Introduction. What Is a Use Case (More or Less)? USE CASE 1. Buy Stocks over the Web. USE CASE 2. Get Paid for Car Accident. USE CASE 3. Register Arrival of a Box. Your Use Case Is Not My Use Case. USE CASE 4. Buy Something (Casual Version). USE CASE 5. Buy Something (Fully Dressed Version). Steve Adolph: “Discovering” Requirements in New Territory. Requirements and Use Cases. Use Cases as Project-Linking Structure. Figure 1: The “Hub-and-Spoke” Model of Requirements. When Use Cases Add Value. Manage Your Energy. Warm Up with a Usage Narrative. Usage Narrative: Getting “Fast Cash”. Exercises. PART I. THE USE CASE BODY PARTS. 2. The Use Case as a Contract for Behavior. Interactions between Actors with Goals. Actors Have Goals. Figure 2: An Actor with a Goal Calls on the Responsibilities of Another. Goals Can Fail. Interactions Are Compound. A Use Case Collects Scenarios. Figure 3: Striped Trousers: Scenarios Succeed or Fail. Figure 4: The Striped Trousers Showing Subgoals. Contract between Stakeholders with Interests. Figure 5: The Sud Serves the Primary Actor, Protecting Offstage Stakeholders. The Graphical Model. Figure 6: Actors and Stakeholders. Figure 7: Behavior. Figure 8: Use Case as Responsibility Invocation. Figure 9: Interactions as Composite. 3. Scope. Table a Sample In/Out List. Functional Scope. The Actor-Goal List. Table a Sample Actor-Goal List. The Use Case Briefs. Table Sample Use Case Briefs. Design Scope. Figure 10: Design Scope Can Be Any Size. Using Graphical Icons to Highlight the Design Scope. Design Scope Examples. Enterprise-to-System Examples. USE CASE 6 Add New Service (Enterprise). USE CASE 7 Add New Service (Acura). Many Computers to One Application. USE CASE 8 Enter and Update Requests (Joint System). USE CASE 9 Add New Service (into Acura). USE CASE 10 Note New Service Request (in BSSO). USE CASE 11 Update Service Request (in BSSO). USE CASE 12 Note Updated Request (in Acura). Figure 11: Use Case Diagrams for Acura-BSSO. Figure 12: A Combined Use Case Diagram for Acura-BSSO. Nuts and Bolts Use Cases. USE CASE 13 Serialize Access to a Resource. USE CASE 14 Apply a Lock Conversion Policy. USE CASE 15 Apply an Access Compatibility Policy. USE CASE 16 Apply an Access Selection Policy. USE CASE 17 Make Service Client Wait for Resource Access 49 The Outermost Use Cases. Using the Scope-Defining Work Products. Exercises. 4. Stakeholders and Actors. Stakeholders. The Primary Actor. Why Primary Actors Are Unimportant (and Important). Actors versus Roles. Characterizing the Primary Actors. Table a Sample Actor Profile Table. Supporting Actors. The System Under Discussion. Internal Actors and White-Box Use Cases. Exercises. 5. Three Named Goal Levels. User Goals (Blue, Sea-Level). Figure 13: Use Case Levels. Two Levels of Blue. Summary Level (White, Cloud/ Kite). USE CASE 18 Operate an Insurance Policy+. The Outermost Use Cases Revisited. Subfunctions (Indigo/Black, Underwater/Clam). Summarizing Goal Levels. Using Graphical Icons to Highlight Goal Levels. Finding the Right Goal Level. Finding the User's Goal. Raising and Lowering Goal Levels. Figure 14: Ask “Why” to Shift Levels. A Longer Writing Sample: “Handle a Claim” at Several Levels. USE CASE 19 Handle a Claim (Business). USE CASE 20 Evaluate Work Comp Claim. USE CASE 21 Handle a Claim (Systems) +. USE CASE 22 Register a Loss. USE CASE 23 Find a Whatever (Problem Statement). Exercises. 6. Preconditions, Triggers, and Guarantees. Preconditions. Minimal Guarantees. Success Guarantee. Triggers. Exercises. 7. Scenarios and Steps. The Main Success Scenario. The Common Surrounding Structure. The Scenario Body. Action Steps. Guidelines. GUIDELINE 1: Use Simple Grammar. GUIDELINE 2: Show Clearly “Who Has the Ball”. GUIDELINE 3: Write from a Bird's Eye View. GUIDELINE 4: Show the Process Moving Forward. GUIDELINE 5: Show the Actor's Intent, Not the Movements. GUIDELINE 6: Include a “Reasonable” Set of Actions. Figure 15: A Transaction Has Four Parts. GUIDELINE 7: “Validate,” Don't “Check Whether”. GUIDELINE 8: Optionally Mention the Timing. GUIDELINE 9: Idiom: “User Has System a Kick System B”. GUIDELINE 10: Idiom: “Do Steps x-y Until Condition”. To Number or Not to Number. Exercises. 8. Extensions. Extension Basics. The Extension Conditions. Brainstorm All Conceivable Failures and Alternative Courses. GUIDELINE 11: Make the Condition Say What Was Detected. Rationalize the Extensions List. Rollup Failures. Extension Handling. GUIDELINE 12: Indent Condition Handling. Failures within Failures. Creating a New Use Case from an Extension. Exercises. 9. Technology and Data Variations. Figure 16: Technology Variations Using Specialization in UML. 10. Linking Use Cases. Sub Use Cases. Extension Use Cases. Figure 17: UML Diagram of Extension Use Cases. When to Use Extension Use Cases. Exercises. 11. Use Case Formats. Formats to Choose From. Fully Dressed. USE CASE 24 Fully Dressed Use Case Template. Casual. USE CASE 25 Actually Login (Casual Version). One-Column Table. Table 1 One-Column Table Format of a Use Case. Two-Column Table. Table 1 Two-Column Table. RUP Style. USE CASE 26 Register for Courses. If-Statement Style. Occam Style. Diagram Style. The UML Use Case Diagram. Forces Affecting Use Case Writing Styles. Consistency. Complexity. Standards for Five Project Types. For Requirements Elicitation. USE CASE 27 Elicitation Template—Oble a New Biscum. For Business Process Modeling. USE CASE 28 Business Process Template—Symp a Carstromming. For Sizing the Requirements. USE CASE 29 Sizing Template—Burble the Tramling. For a Short, High-Pressure Project. USE CASE 30 High-Pressure Template: Kree a Ranfath. For Detailed Functional Requirements. USE CASE 31 Use Case Name—Nathorize a Permion. 1Conclusion. 1Exercise. PART II. FREQUENTLY DISCUSSED TOPICS. 12. When Are We Done. On Being Done. 13. Scaling Up to Many Use Cases. Say Less about Each One (Low-Precision Representation). Create Clusters of Use Cases. 14. CRUD and Parameterized Use Cases. CRUD Use Cases. USE CASE 32 Manage Reports. USE CASE 33 Save Report. Parameterized Use Cases. 15. Business Process Modeling. Modeling versus Designing. Work from the Core Business. Figure 18: Core Business Black Box. Figure 19: New Business Design in White Box. Work from Business Process to Technology. Figure 20: New Business Design in White Box (Again). Figure 21: New Business Process in Black-Box System Use Cases. Work from Technology to Business Process. Linking Business and System Use Cases. Rusty Walters: Business Modeling and System Requirements. 16. The Missing Requirements. Precision in Data Requirements. Cross-linking from Use Cases to Other Requirements. Figure 22: “Hub-and-Spoke” Model of Requirements. 17. Use Cases in the Overall Process. Use Cases in Project Organization. Organize by Use Case Titles. Table 1 Sample Planning Table. Handle Use Cases Crossing Releases. Deliver Complete Scenarios. Use Cases to Task or Feature Lists. USE CASE 34 Capture Trade-In. Table Work List for Capture Trade-In. Use Cases to Design. A Special Note to Object-Oriented Designers. Use Cases to UI Design. Use Cases to Test Cases. USE CASE 35 Order Goods, Generate Invoice (Testing Example). Table 1 Main Success Scenario Tests (Good Credit Risk). Table 1 Main Success Scenario Tests (Bad Credit Risk). The Actual Writing. A Branch-and-Join Process. Time Required per Use Case. Collecting Use Cases from Large Groups. Andy Kraus: Collecting Use Cases from a Large, Diverse Lay Group. 18. Use Case Briefs and Extreme Programming. 19. Mistakes Fixed. No System. No Primary Actor. Too Many User Interface Details. Very Low Goal Levels. Purpose and Content Not Aligned. Advanced Example of Too Much UI. USE CASE 36 Research a Solution—Before. USE CASE 37 Research Possible Solutions—After. PART III. REMINDERS FOR THE BUSY. Chatper 21. Reminders for Each Use Case. Reminder 1: A Use Case Is a Prose Essay. Reminder 2: Make the Use Case Easy to Read. Reminder 3: Just One Sentence Form. Reminder 4: “Include” Sub Use Cases. Reminder 5: Who Has the Ball. Reminder 6: Get the Goal Level Right. Figure 23: Ask “Why” to Shift Levels. Reminder 7: Keep the GUI Out. Reminder 8: Two Endings. Reminder 9: Stakeholders Need Guarantees. Reminder 10: Preconditions. Reminder 11: Pass/Fail Tests for One Use Case. Table 2 Pass/Fail Tests for One Use Case. 22. Reminders for the Use Case Set. Reminder 12: An Ever-Unfolding Story. Reminder 13: Both Corporate Scope and System Scope. Reminder 14: Core Values and Variations. Reminder 15: Quality Questions across the Use Case Set. 23. Reminders for Working on the Use Cases. Reminder 16: It's Just3 (Where's Chapter 4?). Reminder 17: Work Breadth First. Figure 24: Work Expands with Precision. Reminder 18: The 12-Step Recipe. Reminder 19: Know the Cost of Mistakes. Reminder 20: Blue Jeans Preferred. Reminder 21: Handle Failures. Reminder 22: Job Titles Sooner and Later. Reminder 23: Actors Play Roles. Reminder 14: The Great Drawing Hoax. Figure 25: “Mommy, I Want to Go Home.”. Figure 26: Context Diagram in Ellipse Figure Form. Table 2 Actor-Goal List for Context Diagram. Reminder 25: The Great Tool Debate. Reminder 26: Project Planning Using Titles and Briefs. Appendices. Appendix A. Use Cases in UML. A.1 Ellipses and Stick Figures. A.2 UML's Includes Relation. Figure A.1: Drawing Includes. GUIDELINE 13: Draw Higher Goals Higher. A.3 UML's Extends Relation. Figure A.2: Drawing Extends. GUIDELINE 14: Draw Extending Use Cases Lower. GUIDELINE 15: Use Different Arrow Shapes. Correct Use of Extends. Figure A.3: Three Interrupting Use Cases Extending a Base Use Case. Extension Points. A.4 UML's Generalizes Relations. Correct Use of Generalizes. Figure A.4: Drawing Generalizes. Draw General Goals Higher. Hazards of Generalizes. Figure A.5: Hazardous Generalization — Closing a Big Deal. Figure A.6: Correctly Closing a Big Deal. A.5 Subordinate versus Sub Use Cases. A.6 Drawing Use Case Diagrams. GUIDELINE 16: User Goals in a Context Diagram. GUIDELINE 17: Supporting Actors on the Right. A.7 Write Text-based Use Cases Instead. Appendix B. Answers to (Some) Exercises. Chapter 3 (page 51). Figure B.1: Design Scopes for the ATM. Chapter 4 (page 60). Chapter 5 (page 79). Chapter 6 (page 85). Chapter 7 (page 98). USE CASE 38 Use the Order Processing System. Chapter 8 (page 110). USE CASE 39 Buy Stocks Over the Web. Chapter 11 (page 138). USE CASE 40 Perform Clean Spark Plugs Service. Appendix C: Glossary. Appendix D: Readings Index. 0201702258T04062001

Read more less

Book SynopsisJurgen Appelo is a writer, speaker, trainer, developer, entrepreneur, manager, blogger, reader, dreamer, leader, and freethinker. And he's Dutch, which explains his talent for being weird.   After studying software engineering at the Delft University of Technology, and earning his Master's degree in 1994, Jurgen busied himself either starting up or leading a variety of Dutch businesses, always in the position of team leader, manager, or executive.   Jurgen's most recent occupation was CIO at ISM eCompany, one of the largest e-business solution providers in The Netherlands. As a manager, Jurgen has experience in leading software developers, development managers, project managers, quality managers, service managers, and kangaroos, some of which he hired accidentally.   He is primarily interestedTrade Review“ I don’t care for cookbooks, as in ‘5 steps to success at whatever.’ I like books that urge you to think–that present new ideas and get mental juices flowing. Jurgen’s book is in this latter category; it asks us to think about leading and managing as a complex undertaking–especially in today’s turbulent world. Management 3.0 offers managers involved in agile/lean transformations a thought-provoking guide how they themselves can ‘become’ agile.” – Jim Highsmith, Executive Consultant, ThoughtWorks, Inc., www.jimhighsmith.com, Author of Agile Project Management “ An up-to-the-minute, relevant round-up of research and practice on complexity and management, cogently summarized and engagingly presented.” –David Harvey, Independent Consultant, Teams and Technology “ Management 3.0 is an excellent book introducing agile to management. I’ve not seen any book that comes near to what this book offers for managers of agile teams. It’s not only a must read, it’s a must share.” –Olav Maassen, Xebia “ If you want hard fast rules like ‘if x happens, do y to fix it’ forget this book. Actually forget about a management career. But if you want tons of ideas on how to make the work of your team more productive and thereby more fun and thereby more productive and thereby more fun and…read this book! You will get a head start on this vicious circle along with a strong reasoning on why the concepts work.” –Jens Schauder, Software Developer, LINEAS “ There are a number of books on managing Agile projects and transitioning from being a Project Manager to working in an Agile setting. However, there isn’t much on being a manager in an Agile setting. This book fills that gap, but actually addresses being an effective manager in any situation. The breadth of research done and presented as background to the actual concrete advice adds a whole other element to the book. And all this while writing in an entertaining style as well.” –Scott Duncan, Agile Coach/Trainer, Agile Software Qualities “ Don’t get tricked by the word ‘Agile’ used in the subtitle. The book isn’t really about Agile; it is about healthy, sensible and down-to-earth management. Something, which is still pretty uncommon.” –Pawel Brodzinski, Software Project Management “ When I first met Jurgen and learned he was writing a book based on complexity theory, I thought, ‘That sounds good, but I’ll never understand it.’ Books with words like entropy, chaos theory, and thermodynamics tend to scare me. In fact, not only did I find Management 3.0 accessible and easy to understand, I can [also] apply the information immediately, in a practical way. It makes sense that software teams are complex adaptive systems, and a relief to learn how to apply these ideas to help our teams do the best work possible. This book will help you whether you’re a manager or a member of a software team”. –Lisa Crispin, Agile Tester, ePlan Services, Inc., author of Agile Testing “ This book is an important read for managers who want to move bTable of Contents 1 Why Things Are Not That Simple 2 Agile Software Development 3 Complex Systems Theory 4 The Information-Innovation System 5 How to Energize People 6 The Basics of Self-Organization 7 How to Empower Teams 8 Leading and Ruling on Purpose 9 How to Align Constraints 10 The Craft of Rulemaking 11 How to Develop Competence 12 Communication on Structure 13 How to Grow Structure 14 The Landscape of Change 15 How to Improve Everything 16 All Is Wrong, but Some Is Useful Index

Read more less

Book SynopsisNick Rozanski has worked in IT since 1980 for several large and small systems integrators, including Logica, Capgemini, and Sybase, and end user organizations including Marks and Spencer and Barclays Global Investors. He has taken senior roles on a wide range of programs in finance, retail, manufacturing, and government. His technology background includes enterprise application integration, package implementation, relational database, data replication, and object-oriented software development. He is also an experienced technical instructor and certified internal project auditor.   Eoin (pronounced Owen) Woods is a lead system architect in the equities technology group of a major European investment bank with architecture and design responsibility for a number of the organization's key systems. Prior to this, he led the application architecture group at Barclays Global Investors and has worked as a software eTable of Contents Chapter 1: Introduction Chapter 2: Software Architecture Concepts Chapter 3: Viewpoints and Views Chapter 4: Architectural Perspectives Chapter 5: The Role Of The Software Architect Chapter 6: Introduction to the Software Architecture Process Chapter 7: The Architecture Definition Process Chapter 8: Concerns, Principles, and Decisions Chapter 9: Identifying and Engaging Stakeholders Chapter 10: Identifying and Using Scenarios Chapter 11: Using Styles and Patterns Chapter 12: Producing Architectural Models Chapter 13: Creating the Architectural Description Chapter 14: Evaluating the Architecture Chapter 15: Introduction to the Viewpoint Catalog Chapter 16: The Context Viewpoint Chapter 17: The Functional Viewpoint Chapter 18: The Information Viewpoint Chapter 19: The Concurrency Viewpoint Chapter 20: The Development Viewpoint Chapter 21: The Deployment Viewpoint Chapter 22: The Operational Viewpoint Chapter 23: Achieving Consistency Across Views Chapter 24: Introduction to the Perspective Catalo Chapter 25: The Security Perspective Chapter 26: The Performance and Scalability Perspective Chapter 27: The Availability and Resilience Perspective Chapter 28: The Evolution Perspective Chapter 29: Other Perspectives Chapter 30: Working As A Software Architect Appendix: Other Viewpoint Sets

Read more less

Book SynopsisSoftware Engineering: Principles and Practice challenges the reader to appreciate the issues, design trade-offs and teamwork required for successful software development. This new edition has been brought fully up to date, with complete coverage of all aspects of the software lifecycle and a strong focus on all the skills needed to carry out software projects on time and within budget. Highlights of the third edition include: Fully updated chapters on requirements engineering and software architecture. New chapters on component-based software engineering, service orientation and global software development. Extensive coverage of the human and social aspects of software development. Balanced coverage of both traditional, heavyweight development and agile, lightweight development approaches such as Extreme Programming (XP). Written to support both introductory and advanced software engineering courses, this book is invaluable for everyone in softwareTable of ContentsForeword xvii Preface xix 1 Introduction 1 1.1 What Is Software Engineering? 5 1.2 Phases in the Development of Software 10 1.3 Maintenance or Evolution 15 1.4 From the Trenches 17 1.4.1 Ariane 5, Flight 501 18 1.4.2 Therac-25 19 1.4.3 The London Ambulance Service 21 1.4.4 Who Counts the Votes? 23 1.5 Software Engineering Ethics 24 1.6 Quo Vadis? 27 1.7 Summary 29 1.8 Further Reading 30 Exercises 31 Part I Software Management 35 2 Introduction to Software Engineering Management 37 2.1 Planning a Software Development Project 40 2.2 Controlling a Software Development Project 43 2.3 Summary 45 Exercises 46 3 The Software Life Cycle Revisited 49 3.1 The Waterfall Model 52 3.2 Agile Methods 54 3.2.1 Prototyping 56 3.2.2 Incremental Development 60 3.2.3 Rapid Application Development and Dynamic Systems Development Method 62 3.2.4 Extreme Programming 66 3.3 The Rational Unified Process (RUP) 68 3.4 Model-Driven Architecture 71 3.5 Intermezzo: Maintenance or Evolution 72 3.6 Software Product Lines 75 3.7 Process Modeling 77 3.8 Summary 80 3.9 Further Reading 81 Exercises 82 4 Configuration Management 85 4.1 Tasks and Responsibilities 87 4.2 Configuration Management Plan 92 4.3 Summary 93 4.4 Further Reading 94 Exercises 94 5 People Management and Team Organization 97 5.1 People Management 99 5.1.1 Coordination Mechanisms 101 5.1.2 Management Styles 102 5.2 Team Organization 104 5.2.1 Hierarchical Organization 104 5.2.2 Matrix Organization 106 5.2.3 Chief Programmer Team 107 5.2.4 SWAT Team 107 5.2.5 Agile Team 108 5.2.6 Open Source Software Development 108 5.2.7 General Principles for Organizing a Team 111 5.3 Summary 112 5.4 Further Reading 113 Exercises 113 6 On Managing Software Quality 115 6.1 On Measures and Numbers 118 6.2 A Taxonomy of Quality Attributes 123 6.3 Perspectives on Quality 130 6.4 The Quality System 134 6.5 Software Quality Assurance 135 6.6 The Capability Maturity Model (CMM) 137 6.6.1 Personal Software Process 142 6.6.2 BOOTSTRAP and SPICE 143 6.6.3 Some Critical Notes 143 6.7 Getting Started 144 6.8 Summary 147 6.9 Further Reading 148 Exercises 149 7 Cost Estimation 153 7.1 Algorithmic Models 158 7.1.1 Walston–Felix 160 7.1.2 COCOMO 162 7.1.3 Putnam 163 7.1.4 Function Point Analysis 165 7.1.5 COCOMO 2: Variations on a Theme 168 7.1.6 Use-Case Points: Another Variation on a Theme 173 7.2 Guidelines for Estimating Cost 175 7.3 Distribution of Manpower over Time 179 7.4 Agile Cost Estimation 183 7.5 Summary 184 7.6 Further Reading 186 Exercises 187 8 Project Planning and Control 189 8.1 A Systems View of Project Control 190 8.2 A Taxonomy of Software Development Projects 192 8.2.1 Realization Control Situation 194 8.2.2 Allocation Control Situation 195 8.2.3 Design Control Situation 195 8.2.4 Exploration Control Situation 196 8.2.5 Summary of Control Situations 197 8.3 Risk Management 198 8.4 Techniques for Project Planning and Control 201 8.5 Summary 207 8.6 Further Reading 208 Exercises 208 Part II The Software Life Cycle 211 9 Requirements Engineering 213 9.1 Requirements Elicitation 220 9.1.1 Requirements Engineering Paradigms 224 9.1.2 Requirements Elicitation Techniques 226 9.1.3 Goals and Viewpoints 234 9.1.4 Prioritizing Requirements 237 9.1.5 COTS selection 239 9.1.6 Crowdsourcing 240 9.2 Requirements Documentation and Management 241 9.2.1 Requirements Specification 241 9.2.2 Requirements Management 247 9.3 Requirements Specification Techniques 249 9.3.1 Choosing a Notation 250 9.3.2 Specifying Non-Functional Requirements 252 9.4 Verification and Validation 253 9.5 Summary 254 9.6 Further Reading 255 Exercises 257 10 Modeling 261 10.1 Classic Modeling Techniques 263 10.1.1 Entity–Relationship Modeling 263 10.1.2 Finite State Machines 265 10.1.3 Data Flow Diagrams 267 10.1.4 CRC Cards 267 10.2 On Objects and Related Stuff 268 10.3 The Unified Modeling Language 274 10.3.1 The Class Diagram 276 10.3.2 The State Machine Diagram 279 10.3.3 The Sequence Diagram 283 10.3.4 The Communication Diagram 284 10.3.5 The Component Diagram 285 10.3.6 The Use Case 286 10.4 Summary 287 10.5 Further Reading 287 Exercises 288 11 Software Architecture 289 11.1 Software Architecture and the Software Life Cycle 293 11.2 Architecture Design 294 11.3 Architectural Views 298 11.4 Architectural Styles 303 11.5 Software Architecture Assessment 317 11.6 Summary 321 11.7 Further Reading 322 Exercises 322 12 Software Design 325 12.1 Design Considerations 329 12.1.1 Abstraction 330 12.1.2 Modularity 333 12.1.3 Information Hiding 336 12.1.4 Complexity 337 12.1.5 System Structure 344 12.1.6 Object-Oriented Metrics 348 12.2 Classical Design Methods 351 12.2.1 Functional Decomposition 353 12.2.2 Data Flow Design (SA/SD) 356 12.2.3 Design Based on Data Structures 361 12.3 Object-Oriented Analysis and Design Methods 369 12.3.1 The Booch Method 376 12.3.2 Fusion 377 12.3.3 RUP Revisited 379 12.4 How to Select a Design Method 380 12.4.1 Design Method Classification 381 12.4.2 Object Orientation: Hype or the Answer? 382 12.5 Design Patterns 385 12.6 Design Documentation 389 12.7 Verification and Validation 393 12.8 Summary 393 12.9 Further Reading 398 Exercises 399 13 Software Testing 405 13.1 Test Objectives 410 13.1.1 Test Adequacy Criteria 412 13.1.2 Fault Detection Versus Confidence Building 413 13.1.3 From Fault Detection to Fault Prevention 415 13.2 Testing and the Software Life Cycle 417 13.2.1 Requirements Engineering 417 13.2.2 Design 419 13.2.3 Implementation 420 13.2.4 Maintenance 420 13.2.5 Test-Driven Development (TDD) 421 13.3 Verification and Validation Planning and Documentation 422 13.4 Manual Test Techniques 425 13.4.1 Reading 425 13.4.2 Walkthroughs and Inspections 426 13.4.3 Correctness Proofs 428 13.4.4 Stepwise Abstraction 429 13.5 Coverage-Based Test Techniques 430 13.5.1 Control-Flow Coverage 431 13.5.2 Data Flow Coverage 433 13.5.3 Coverage-Based Testing of Requirements Specifications 435 13.6 Fault-Based Test Techniques 437 13.6.1 Error Seeding 437 13.6.2 Mutation Testing 438 13.7 Error-Based Test Techniques 440 13.8 Comparison of Test Techniques 441 13.8.1 Comparison of Test Adequacy Criteria 442 13.8.2 Properties of Test Adequacy Criteria 443 13.8.3 Experimental Results 446 13.9 Test Stages 448 13.10 Estimating Software Reliability 450 13.11 Summary 457 13.12 Further Reading 458 Exercises 459 14 Software Maintenance 465 14.1 Maintenance Categories Revisited 468 14.2 Major Causes of Maintenance Problems 471 14.3 Reverse Engineering and Refactoring 475 14.3.1 Refactoring 478 14.3.2 Inherent Limitations 480 14.3.3 Tools 484 14.4 Software Evolution Revisited 486 14.5 Organizational and Managerial Issues 488 14.5.1 Organization of Maintenance Activities 488 14.5.2 Software Maintenance from a Service Perspective 492 14.5.3 Control o fMaintenance Tasks 497 14.5.4 Quality Issues 500 14.6 Summary 501 14.7 Further Reading 502 Exercises 504 15 Software Tools 507 15.1 Toolkits 511 15.2 Language-Centered Environments 513 15.3 Integrated Environments and WorkBenches 514 15.3.1 Analyst WorkBenches 515 15.3.2 Programmer WorkBenches 516 15.3.3 Management WorkBenches 520 15.3.4 Integrated Project Support Environments 520 15.4 Process-Centered Environments 521 15.5 Summary 522 15.6 Further Reading 524 Exercises 525 Part III Advanced Topics 527 16 User Interface Design 529 16.1 Where Is the User Interface? 532 16.2 What Is the User Interface? 536 16.3 Human Factors in Human–Computer Interaction 537 16.3.1 Humanities 537 16.3.2 Artistic Design 538 16.3.3 Ergonomics 539 16.4 The Role of Models in Human–Computer Interaction 540 16.4.1 A Model of Human Information Processing 542 16.4.2 Mental Models of Information Systems 544 16.4.3 Conceptual Models in User Interface Design 547 16.5 The Design of Interactive Systems 549 16.5.1 Design as an Activity Structure 550 16.5.2 Design as Multi-Disciplinary Collaboration 552 16.6 Task Analysis 553 16.6.1 Task Analysis in HCI Design 554 16.6.2 Analysis Approaches for Collaborative Work 556 16.6.3 Sources of Knowledge and Collection Methods 557 16.6.4 An Integrated Approach to Task Analysis: GTA 558 16.7 Specification of the User Interface Details 559 16.7.1 Dialog 560 16.7.2 Representation 561 16.8 Evaluation 562 16.8.1 Evaluation of Analysis Decisions 562 16.8.2 Evaluation of UVM Specifications 563 16.8.3 Evaluation of Prototypes 566 16.9 Summary 567 16.10 Further Reading 568 Exercises 569 17 Software Reusability 571 17.1 Reuse Dimensions 574 17.2 Reuse of Intermediate Products 576 17.2.1 Libraries of Software Components 576 17.2.2 Templates 580 17.2.3 Reuse of Architecture 581 17.2.4 Application Generators and Fourth-Generation Languages 581 17.3 Reuse and the Software Life Cycle 582 17.4 Reuse Tools and Techniques 585 17.4.1 From Module Interconnection Language to Architecture Description Language 586 17.4.2 Middleware 588 17.5 Perspectives of Software Reuse 591 17.6 Non-Technical Aspects of Software Reuse 594 17.6.1 Economics 596 17.6.2 Management 597 17.6.3 Psychology of Programmers 598 17.7 Summary 599 17.8 Further Reading 601 Exercises 601 18 Component-Based Software Engineering 605 18.1 Why Component-Based Software Engineering? 607 18.2 Component Models and Components 608 18.2.1 Component Forms in Component Models 610 18.2.2 Architecture and Component Models 614 18.3 Component-Based Development Process and Component Life Cycle 619 18.3.1 Component-Based System Development Process 620 18.3.2 Component Assessment 622 18.3.3 Component Development Process 623 18.4 Architectural Approaches in Component-Based Development 625 18.4.1 Architecture-Driven Component Development 626 18.4.2 Product-Line Development 626 18.4.3 COTS-Based Development 627 18.4.4 Selecting an Approach 627 18.5 Summary 628 18.6 Further Reading 628 Exercises 629 19 Service Orientation 631 19.1 Services, Service Descriptions, and Service Communication 634 19.2 Service-Oriented Architecture (SOA) 639 19.3 Web Services 641 19.3.1 Extensible Markup Language (XML) 643 19.3.2 Simple Object Access Protocol (SOAP) 644 19.3.3 Web Services Description Language (WSDL) 644 19.3.4 Universal Description, Discovery, and Integration (UDDI) 646 19.3.5 Business Process Execution Language for Web Services (BPEL4WS) 647 19.4 Service-Oriented Software Engineering 650 19.5 Summary 652 19.6 Further Reading 652 Exercises 653 20 Global Software Development 655 20.1 Challenges of Global System Development 657 20.2 How to Overcome Distance 664 20.2.1 Common Ground 664 20.2.2 Coupling of Work 666 20.2.3 Collaboration Readiness 666 20.2.4 Technology Readiness 666 20.2.5 Organizing Work in Global Software Development 668 20.3 Summary 670 20.4 Further Reading 670 Exercises 671 Bibliography 673 Index 705

Read more less

Book SynopsisShows you how to analyze, design, and write serious object-oriented software. This work helps you learn how to: use OO principles like encapsulation and delegation to build applications that are flexible; apply the Open-Closed Principle (OCP) and the Single Responsibility Principle (SRP) to promote reuse of your code; among others.

Read more less

Book SynopsisDescription The Redux JavaScript library consolidates state in a single object, radically simplifying one of the largest sources of bugs. With Redux in Action, you'll discover how to integrate Redux into your React application and development environment, write custom middleware, and optimize for performance. Key features · Clear introduction · Hands-on examples · Step-by-step guide Audience Written for web developers comfortable with JavaScript and ES6, as well as experience using React. About the technology Whether users are passing data through several layers of components or sharing and syncing data between unrelated parts of the app, Redux makes state management a breeze. Redux promotes predictability, testability, and the ability to debug dynamic applications, letting users focus on building great apps. Author biography Marc Garreau has architected and executed half a dozen unique client-side applications leveraging Redux for state management. Will Faurot is experienced in equal parts production Redux, and mentoring Redux developers of all skill levels.

Read more less

Book Synopsis"Helps explain some of the knowledge gaps between enthusiastic new graduates and grouchy old gray beards like myself." - Joe Ivans Practical techniques for writing code that is robust, reliable, and easy for team members to understand and adapt. Good code or bad code? The difference often comes down to how you apply the conventions, style guides, and other established practices of the software development community. In Good Code, Bad Code you'll learn how to boost your effectiveness and productivity with code development insights normally only learned through years of experience, careful mentorship, and hundreds of code reviews. In Good Code, Bad Code you'll learn how to:- Think about code like an effective software engineer- Write functions that read like a well-structured sentence- Ensure code is reliable and bug free- Effectively unit test code- Identify code that can cause problems and improve it- Write code that is reusable and adaptable to new requirements- Improve your medium and long-term productivity- Save you and your team's time about the technologyCoding in a development team requires very different skills to working on personal projects. Successful software engineers need to ensure that their code is reusable, maintainable, and easy for others to understand and adapt. about the bookGood Code, Bad Code is a shortcut guide to writing high-quality code. Your mentor is Google veteran Tom Long, who lays out lessons and mindsets that will take your code from “junior developer” to “senior engineer.” This instantly-useful book distils the principles of professional coding into one comprehensive and hands-on beginner's guide. You'll start with a jargon-free primer to coding fundamentals that teaches you to think about abstractions, consider your fellow engineers, and write code that can recover from errors. Next, you'll dive into specific techniques and practices. You'll run through common coding practices to learn when to apply the right technique to your problem—and which might be best avoided! All practices are illustrated with annotated code samples written in an instantly recognizable pseudocode that you can relate to your favourite object-oriented language. By the time you're done, you'll be writing the kind of readable, reusable, and testable code that's the mark of a true software professional. about the readerFor coders looking to improve their experience in professional software development. about the authorTom Long is a software engineer at Google. He works as a tech lead, mentoring and teaching professional coding practices to new graduates and beginner software engineers.Trade Review“A wealth of knowledge to sharpen your toolset.” Joe Ivans,California Regional MLS “Pragmatic advice and useful tips for a career in software development.” George Thomas, Manhattan Associates “A practical, informative book designed to help developers writehigh-quality, effective code.” Christopher Villanueva, IndependentConsultant “Smart, well written, actionable information for creating maintainable code.” Hawley Waldman, Consultant

Read more less

Book SynopsisBuilt specifically for statistical computing and graphics, the R language, along with its amazing collection of libraries and tools, is one of the most powerful tools you can use to tackle data analysis for business, research, and other data-intensive domains. This revised and expanded third edition of R in Action covers the new tidy verse approach to data analysis and R's state-of-the-art graphing capabilities with the ggplot2 package. R in Action, Third Edition teaches you to use the R language, including the popular tidy verse packages, through hands-on examples relevant to scientific, technical, and business developers. Focusing on practical solutions to real-world data challenges, R expert RobKabacoff takes you on a crash course in statistics, from dealing with messy and incomplete data to creating stunning visualisations. The R language is the most powerful platform you can choose for modern data analysis. Free and open source, R's community has created thousands of modules to tackle challenges from data-crunching to presentation. R's graphical capabilities are also state-of-the-art, with a comprehensive and powerful feature set available for data visualization. R runs on all major operating systems and is used by businesses, researchers, and organizations worldwide.Trade Review“Read it and masterthe invaluable art of solving data analysis problems efficiently: a must!” AlainLompo “Excellent primer for starting R.” Martin Perry “The book gives a amazing introduction to R and the applicable methods for machine learning and statistics.” Nicole Koenigstein “Amusing writing style and great material ingeneral, great book for those who are beginning in Statistics programming.” LuisFelipe Medeiro Alves “This is an awesome book on R.” Tiklu Ganguly “The definitive guide to bring you from beginner to advanced with R.” Jean-François Morin “A clear and comprehensive guide to using R forreal work. I was able to get an R environment up and running with minimal difficulty!” Jim Frohnhofer

Read more less

Book SynopsisMicroservice APIs in Python shares successful strategies and techniques for designing Microservices systems, with a particular emphasis on creating easy-to-consume APIs.This practical guide focuses on implementation over philosophizing and has just enough theory to get you started. You'll quickly go hands on designing the architecture for a microservices platform, produce standard specifications for REST and GraphQL APIs, and bake in authentication features to keep your APIs secure. Written in a framework-agnostic manner, its universal principles of API and microservices design can easily be applied to your favorite stack and toolset. About the TechnologyStandard Python web applications, such as those you'd typically build with Django or Flask, can be hard to scale and maintain when built as monoliths. Microservices design makes it possible to isolate key features and functionality as independently written and maintained services. To take advantage of this more resilient architecture, you need to learn the patterns, frameworks, and tools that make Python-based microservices easy to build and manage.Trade Review"Read this book now. It will change your mind about how to architect your software and services!" Stuart Woodward "A thorough introduction to the concept of developing microservice APIs with Python." Rodney Weis "The Author has done an excellent job in explaining key concepts." Manish Jain "There are many pitfalls with microservices, and this book will provide you with all the knowledge you need to be properly prepared to create your first one!" Pierre-Michel Ansel "Before you start coding for your microservice please read this book once, irrespective of your programming language." Debmalya Jash "A roundhouse kick for all aspects regarding APIs and python." Björn Neuhaus "A very thorough discussion of the considerations that are involved in developing microservice APIs with Python." Rodney Weis "I really like both the breadth and depth of the content. It is exciting to see an entire book which focuses upon Python as a back-end component—for which I see a natural fit." Bryan Miller "A great book for Python developers to understand how to implement APIs using web frameworks." Sambasiva Andaluri "I genuinely feel smarter for having read this book and knowing that I can refer to it when I make my next design." Stuart Woodward

Read more less

Book SynopsisFast Python for Data Science is a hands-on guide to writing Python code that can process more data, faster, and with less resources. It takes a holistic approach to Python performance, showing you how your code, libraries, and computing architecture interact and can be optimized together. Written for experienced practitioners, Fast Python for Data Science dives right into practical solutions for improving computation and storage efficiency. You'll experiment with fun and interesting examples such as rewriting games in lower-level Cython and implementing a MapReduce framework from scratch. Finally, you'll go deep into Python GPU computing and learn how modern hardware has rehabilitated some former antipatterns and made counterintuitive ideas the most efficient way of working. About the technologyFast, accurate systems are vital for handling the huge datasets and complex analytical algorithms that are common in modern data science. Python programmers need to boost performance by writing faster pure-Python programs, optimizing the use of libraries, and utilizing modern multi-processor hardware; Fast Python for Data Science shows you how. Trade Review"If you want to go beyond scripting in Python, you need this book." Brian S. Cole. "If you need to improve the performance of your Python code, you need to read this book!" Lorenzo DeLeon "I really like how the book walks you through interesting projects and code. I think that does a great job of demonstrating the concepts and giving you something to play with." Dana Robinson "Explains the essential concepts required for using high performance Python." Biswanath Chowdhury "A must have to speed up your Python code." Abhilash Babu Jyotheendra Babu

Read more less

Book SynopsisRichard Knaster, SAFe Fellow and Principal Consultant at Scaled Agile, Inc., has more than 25 years' experience in software development in roles ranging from developer to executive and has been involved in Agile for more than a decade. Prior to joining Scaled Agile, Inc., Richard worked at IBM, where his career spanned from product line management (PPM domain) and professional services to chief methodologist, Agile and Lean. Richard is a certified IBM Thought Leader and an Open Group Distinguished IT Specialist. He is also a certified SPC, PSM, Agile Certified Practitioner, PMP, and a contributor to the Disciplined Agile Delivery framework and PMI Portfolio/Program Management standards. He is a contributor to  SAFe 4.5 Reference Guide (Addison-Wesley, 2018). Dean Leffingwell, creator of SAFe, is widely recognized as the one of the world's foremost authorities on Lean-Agile best practices. He is an author, serial entreprTable of ContentsPreface ixAcknowledgments xvAbout the Authors xvii Part I: Competing in the Age of Software 1Chapter 1: Business Agility 3Chapter 2: Introduction to SAFe 11Chapter 3: Lean-Agile Mindset 25Chapter 4: SAFe Principles 39 Part II: The Seven Core Competencies of the Lean Enterprise 63Chapter 5: Lean-Agile Leadership 65Chapter 6: Team and Technical Agility 75Chapter 7: Agile Product Delivery 89Chapter 8: Enterprise Solution Delivery 121Chapter 9: Lean Portfolio Management 143Chapter 10: Organizational Agility 167Chapter 11: Continuous Learning Culture 187 Part III: Implementing SAFe, Measure and Grow 201Chapter 12: The Guiding Coalition 205Chapter 13: Designing the Implementation 215Chapter 14: Implementing Agile Release Trains 229Chapter 15: Launch More ARTs and Value Streams; Extending to the Portfolio 245Chapter 16: Measure, Grow, and Accelerate 253 Glossary 267Index 279

Read more less

Book SynopsisA multi-user game, web site, cloud application, or networked database can have thousands of users all interacting at the same time. You need a powerful, industrial-strength tool to handle the really hard problems inherent in parallel, concurrent environments. You need Erlang. In this second edition of the bestselling Programming Erlang, you'll learn how to write parallel programs that scale effortlessly on multicore systems. Using Erlang, you'll be surprised at how easy it becomes to deal with parallel problems, and how much faster and more efficiently your programs run. That's because Erlang uses sets of parallel processes-not a single sequential process, as found in most programming languages. Joe Armstrong, creator of Erlang, introduces this powerful language in small steps, giving you a complete overview of Erlang and how to use it in common scenarios. You'll start with sequential programming, move to parallel programming and handling errors in parallel programs, and learn to work confidently with distributed programming and the standard Erlang/Open Telecom Platform (OTP) frameworks. You need no previous knowledge of functional or parallel programming. The chapters are packed with hands-on, real-world tutorial examples and insider tips and advice, and finish with exercises for both beginning and advanced users. The second edition has been extensively rewritten. New to this edition are seven chapters covering the latest Erlang features: maps, the type system and the Dialyzer, WebSockets, programming idioms, and a new stand-alone execution environment. You'll write programs that dynamically detect and correct errors, and that can be upgraded without stopping the system. There's also coverage of rebar (the de facto Erlang build system), and information on how to share and use Erlang projects on github, illustrated with examples from cowboy and bitcask. Erlang will change your view of the world, and of how you program.

Read more less

Book SynopsisFrom start to finish, you'll see what it takes to develop a successful agile project. Find out how the Swedish police combined XP, Scrum, and Kanban to modernize their department--and learn how you can apply those same principles to your own workplace. We start with an organization in desperate need of a new way of doing things and finish with a group of sixty, all working in sync to develop a scalable, complex system. You'll walk through the project step by step, from customer engagement, to the daily "cocktail party," version control, bug tracking, and release. In this honest look at what works--and what doesn't--you'll find out how to: * Make quality everyone's business, not just the testers. * Keep everyone moving in the same direction without micromanagement. * Use simple and powerful metrics to aid in planning and process improvement. * Balance between low-level feature focus and high-level system focus. You'll be ready to jump into the trenches yourself as you apply those same techniques to your own software development projects.

Read more less

Book SynopsisThis fast-moving tutorial introduces you to OCaml, an industrial-strength programming language designed for expressiveness, safety, and speed. Through the book''s many examples, you''ll quickly learn how OCaml stands out as a tool for writing fast, succinct, and readable systems code using functional programming. Real World OCaml takes you through the concepts of the language at a brisk pace, and then helps you explore the tools and techniques that make OCaml an effective and practical tool. You''ll also delve deep into the details of the compiler toolchain and OCaml''s simple and efficient runtime system. This second edition brings the book up to date with almost a decade of improvements in the OCaml language and ecosystem, with new chapters covering testing, GADTs, and platform tooling. This title is also available as open access on Cambridge Core, thanks to the support of Tarides. Their generous contribution will bring more people to OCaml.Trade Review'An invaluable guide to effective OCaml programming! With extended and updated coverage of key libraries and tools, it covers the language concepts and will teach you not only how to program in OCaml, but also how to develop efficient systems applications in this language.' Xavier Leroy, Collège de France and INRIA'OCaml is widely known as an elegant language based on cutting-edge ideas. But this book focuses on use of OCaml as a powerful tool for the software industry. Using a series of hands-on examples, it shows the reader how to use advanced features from the OCaml ecosystem (types, modules, testing frameworks, libraries, package management, build tools, etc.) to solve practical problems. Real World OCaml is my go-to reference for learning how to develop real-world software systems in OCaml.' Nate Foster, Cornell UniversityTable of Contents1. Prologue; Part I. Language Concepts: 2. A guided tour; 3. Variables and functions; 4. Lists and patterns; 5. Files, modules, and programs; 6. Records; 7. Variants; 8. Error handling; 9. Imperative programming; 10. GADTs; 11. Functors; 12. First-class Modules; 13. Objects; 14. Classes; Part II. Tools and Techniques: 15. Maps and hash tables; 16. Command-line parsing; 17. Concurrent programming with Async; 18. Testing; 19. Handling JSON data; 20. Parsing with Ocamllex and Menhir; 21. Data serialization with S-expressions; 22. The OCaml platform; Part III. The Compiler and Runtime System: 23. Foreign function interface; 24. Memory representation of values; 25. Understanding the garbage collector; 26. The compiler frontend: parsing and type checking; 27. The compiler backend: bytecode and native code; References; Index.

Read more less

Book SynopsisTensorFlow is a one-stop solution for building, monitoring, optimizing,and deploying your models. This practical guide to building deep learning models with the new features of TensorFlow 2.0is filled with engaging projects, simple language, and coverage of the latest algorithms. TensorFlow 2.0 in Action teaches you to use the new features of TensorFlow 2.0 to create advanced deep learning models. You'll learn by building hands-on projects including an image classifier that can recognize objects, a French-to-English machine translator, and even a neural network that can write fiction. You'll dive into the details of modern deep learning techniques including both transformer and attention models, and learn how pretrained models can solve your tricky data science- problems. TensorFlow is the go-to framework for putting deep learning into production. Created by Google, this ground breaking tool handles repetitive low-level operations and frees you up to focus on innovating your AIs.TensorFlow encompasses almost every element of a deep learning pipeline—aone-stop solution for building, monitoring, optimizing, and deploying your models.Trade Review“Excellent explanations and walk throughs to help bring you up to speed in Tensorflow 2.” Todd Cook “The illustrations of technical concepts are excellent.” BrianGriner “A hands-on introduction to effective Tensorflow use for real worlds problems.” Francisco Rivas “Mr Ganegedara goes to great lengths, with the exemplary use of many figures, to explain not only TensorFlow 2 solutions themselves but also the mechanics of the technology. Highly recommended!” TonyHoldroyd “An excellent resource to learning Tensorflow 2.0 using practical examples.” Biswanath Chowdhury “The conversation on writing custom layer was probably the best discussion on that I've ever seen. I learned a lot from that chapter.” LeviMcClenny “In you want to gain a deep knowledge of deep learning, read this book.”Tiklu Ganguly

Read more less

Book SynopsisTo really benefit from the reliability and scalability you get with cloud platforms, your applications need to be designed for that environment. Cloud Native Spring in Action is a practical guide for planning, designing, and building your first cloud native apps using the powerful, industry-standard Spring framework Cloud Native Spring in Action teaches you effective Spring and Kubernetes cloud development techniques that you can immediately apply to enterprise-grade applications. As you develop an online bookshop, you'll learn how to build and test a cloud native app with Spring, containerize it with Docker, and deploy it to the public cloud with Kubernetes. Including coverage of security, continuous delivery, and configuration, this hands-on guide is the perfect primer for navigating the increasingly complex cloud landscape. About the TechnologyModern applications need scalability, resilience, reliability, and zero-downtime. For most large systems, that means you'll take advantage of cloud-based tools and services. For Java developers, Spring helps effortlessly build cloud native, production-ready applications. Combined with Kubernetes, the Spring ecosystem offers numerous built-in features to help out developers migrating or building new cloud native projects efficiently.Trade Review"An excellent practical guide to learn and develop Cloud Native apps using Spring. A must-have for Spring professional." Harinath Kuntamukkala "Curious about writing production grade Cloud Native applications using Spring and don't know where to start? Read this book and thank me later!" Yogesh Shetty "The definitive guide to developing cloud native applications using Spring." Nathan B Crocker "Filled to the brim with real world examples and ready to use code." Mladen Knežić "This book is perfect to understand how to build cloud native architecture using Java and Spring. All the chapters are useful and their content can be applied in real-world scenarios." Gilberto Taccari

Read more less

Book SynopsisPrivacyEngineering is a hands-on guide to building a modern and flexible privacy program for your organization. It helps map essential legal requirements into practical engineering techniques that you can implement right away. The book develops your strategic understanding of data governance and helps you navigate the tricky trade-offs between privacy and business needs. You'll learn to spot risks in your own data management systems and prepare to satisfy both internal and external privacy audits. There's no bureaucratic new processes or expensive new software necessary. You'll learn how to repurpose the data and security tools you already use to achieve your privacy goals. Preserving the privacy of your users is essential for any successful business. Well-designed processes and data governance ensure that privacy is built into your systems from the ground up, keeping your users safe and helping your organization maintain compliance with the law. Trade Review“A great high-level resource on privacy as it relates to the data collected by business software systems.” Joe Ivans “Provides a clear and thorough explanation of the how and the why of data privacy pitched at a level which isn't too technical, yet has a sufficient level of detail to allow for interpretation of implementation.” Matthew Todd “Really interesting subject matter. The author provides relevant examples and obviously has a lot of direct experience.” John Tyler “A great resource on approaching data privacy.” Doniyor Ulmasov “The best parts are the personal elements added to the narrative. I also enjoyed the case studies that help to illustrate the examples provided throughout.” Ayana Miller

Read more less

Book SynopsisCreate your first 2D, 3D, and AR/VR games with the awesome Unity game platform. With this hands-on beginner's guide, you'll start building games fast! In Unity in Action, Third Edition, you will learn how to: Create characters that run, jump, and bump into things Build 3D first-person shooters and third-person action games Construct 2D card games and side-scrolling platformers Script enemies with AI Improve game graphics by importing models and images Design an intuitive user interface for your games Play music and spatially-aware sound effects Connect your games to the internet for online play Deploy your games to desktop, mobile, and the web Thousands of new game developers have chosen Joe Hocking's Unity in Action as their first step toward Unity mastery. This fully updated third edition comes packed with fully refreshed graphics, Unity's latest features, and coverage of the augmented and virtual reality toolkits. Using your existing coding skills, you'll write custom code instead of just clicking together premade scripts. You'll master the Unity toolset from the ground up, adding the skills you need to go from application coder to game developer. Build your next game without sweating the low-level details. The Unity game engine handles the heavy lifting, so you can focus on game play, graphics, and user experience. With support for C#, a huge ecosystem of production-quality prebuilt assets, and a strong dev community, Unity will get your game idea off the drawing board and onto the screen! You can even use Unity for more than game development, with new tools for VR and augmented reality that are perfect for developing useful apps.Trade ReviewThis is the best resource, bar none, for an introduction to Unity and fundamental game programming concepts. Erik Hansson This book is a wonderful introduction to Unity. I believe this book will be very useful to readers from a wide range of backgrounds. Everything is explained very well and is easy to read and understand. Kent R. Spillner This is a great introduction to Unity. I think it could even be used as the foundation for a high school or college course. Robert Walsh If you want to start building games as a hobby or a profession, this is a good place to start! Bradley Irby A great introduction to learning Game development with Unity and C#. The author steps you through all the elements of Unity so if you've never used Unity before, don't worry about it. Owain Williams If you already have some programming experience, this book on Unity can really help you connect into a new platform and enable you to create a game! James Matlock

Read more less

Book SynopsisBy explaining the goals and methodologies behind prototyping-and demonstrating how to prototype for both physical and digital products-this practical guide helps beginning and intermediate designers become more comfortable with creating and testing prototypes early and often in the process.

Read more less

Book SynopsisThis guide teaches the practical uses of Quicken for Macintosh software - the chapter topics are organized like the product for easy familiarity. It includes coverage of all the product features, menu items and tools for financial management.Table of ContentsPart I Quicken setup and basics: getting to know Quicken; setting up accounts and categories; going online with Quicken and Quicken.com. Part II Managing your bank and credit card accounts: recording bank and credit card transactions; online banking with Quicken. Part III Tracking your investments: tracking investments; using online investment tracking tools; maximizing investment returns. Part IV Managing your assets and debts: monitoring assets and loans; managing home, car and insurance expenses. Part V Saving money and achieving your goals: saving money at tax time; saving money and reducing debt; planning for the future. Part VI Working with Quicken data: automating Quicken transactions; reconciling accounts; insights, reports and graphs.

Read more less

Book SynopsisTrade Review"The book is largely self-contained, has countless examples, and focuses on what really matters. As such, it is very well suited for both a teaching environment and for practitioners looking for an opportunity to learn about this topic...The book is written in a way that makes multiprocessor programming accessible. This updated version will further confirm its status as a classic." --ComputingReviews.com, 2013Table of Contents1. Introduction 2. Mutual exclusion 3. Concurrent objects 4. Foundations of shared memory 5. The relative power of synchronization operations 6. Universality of consensus 7. Spin locks and contention 8. Monitors and blocking synchronization 9. Linked lists: The role of locking 10. Queues, memory management, and the ABA problem 11. Stacks and elimination 12. Counting, sorting and distributed coordination 13. Concurrent hashing and natural parallelism 14. Skiplists and balanced search 15. Priority queues 16. Scheduling and work distribution 17. Data parallelism 18. Barriers 19. Optimism and manual memory management 20. Transactional programming Appendix A: Software basics Appendix B: Hardware basics

Read more less

Book Synopsis Ken Schwaber is president of Advanced Development Methods (ADM), a company dedicated to improving the software development practice. He is an experienced software developer, product manager, and industry consultant. Schwaber initiated the process management product revolution of the early 1990's and also worked with Jeff Sutherland to formulate the initial versions of the Scrum development process. Mike Beedle, an experienced software development practitioner, is the founder and CEO of e-Architects, Inc., a management and technical consulting company that helps its clients develop software in record time. Beedle has contributed to thousands of software projects for the last 20 years, and has used, recommended, and guided others to implement Scrum since 1995. Trade Review"Agile development methods are key to the future of flexible software systems. Scrum is one of the vanguards of the new way to buy and manage software development when business conditions are changing. This book distills both the theory and practice and is essential reading for anyone who needs to cope with software in a volatile world." — Martin Fowler, industry consultant and CTO, ThoughtWorks "Most executives today are not happy with their organization's ability to deliver systems at reasonable cost and timeframes. Yet, if pressed, they will admit that they don't think their software developers are not competent. If it's not the engineers, then what is it that prevents fast development at reasonable cost? Scrum gives the answer to the question and the solution to the problem. — Alan Buffington, industry consultant, former Present, Fidelity Systems Company Table of Contents 1. Introduction. 2. Great Ready for Scrum! 3. Scrum Practices. 4. Applying Scrum. 5. Why Scrum? 6. Why Does Scrum Work? 7. Advanced Scrum Applications. 8. Scrum and the Organization. 9. Scrum Values.

Read more less

Book SynopsisMary Lynn Manns, Ph.D., is a professor in the Department of Management and Accountancy at the University of North Carolina, Asheville. Her doctoral work focused on the introduction of patterns into organizations. She is well known for her many presentations on this topic. Linda Rising, Ph.D., is well known throughout the patterns community as the editor of Design Patterns in Communications Software (Cambridge University Press, 2001) and The Patterns Handbook (Cambridge University Press, 1997). Now an independent consultant, she helped lead the introduction of patterns into AG Communication Systems in Phoenix, Arizona. Linda has worked in the telecommunications, avionics, and strategic weapons industries, and has extensive training and university teaching experience. She holds a Ph.D. from Arizona State University. Table of ContentsForeword. Preface. Acknowledgments. I. OVERVIEW. 1. Organizations and Change. The Change Agent. The Culture. The People. 2. Strategies or Patterns. Pattern Formats. Using Patterns. 3. Where Do I Start? Evangelism Is Critical for Success. A Small Package of Patterns. 4. What Do I Do Next? Target Groups to Ask for Help. It's Important to Say "Thanks". 5. Meetings and More. Let's Meet! Using Information That's Out There. Stay Connected. 6. Take Action! Other Ways to Learn. 7. It's All About People. What's in It for the Organization? You Have Feelings, Too! 8. A New Role: Now You're Dedicated! You Have Convinced Them–You Are a Dedicated Champion. 9. Convince the Masses. Enlist Gurus and Famous People. 10. More Influence Strategies. Keep Things Visible. It's Just a Token. Location Also Counts. Things Are Humming. 11. Keep It Going. Be Proactive! 12. Dealing with Resistance. Build Bridges. A Champion Skeptic. It's All About Politics. II. EXPERIENCES. Multiple Sclerosis Society Experience Report. UNCA Experience Report. Sun Core J2EE Patterns Experience Report. Customer Training Experience Report. III. THE PATTERNS. Ask for Help. Big Jolt. Bridge-Builder. Brown Bag. Champion Skeptic. Connector. Corporate Angel. Corridor Politics. Dedicated Champion. Do Food. e-Forum. Early Adopter. Early Majority. Evangelist. External Validation. Fear Less. Group Identity. Guru on Your Side. Guru Review. Hometown Story. In Your Space. Innovator. Involve Everyone. Just Do It. Just Enough. Just Say Thanks. Local Sponsor. Location, Location, Location. Mentor. Next Steps. Personal Touch. Piggyback. Plant the Seeds. The Right Time. Royal Audience. Shoulder to Cry On. Small Successes. Smell of Success. Stay in Touch. Step by Step. Study Group. Sustained Momentum. Tailor Made. Test the Waters. Time for Reflection. Token. Trial Run. Whisper in the General's Ear. External Pattern References. Appendix. References. Index.

Read more less

Book SynopsisCyrille Martraire (@cyriux on Twitter) is CTO, co-founder, and partner at Arolla (@ArollaFr on Twitter), the founder of the Paris Software Crafters community, and a regular speaker at international conferences. Cyrille refers to himself as a developer, since he has designed software since 1999 for startups, software vendors, and corporations as an employee and as a consultant. He has worked and led multiple significant projects, mostly in capital finance, including the complete rewriting of a multilateral trading facility of interest rate swaps. In most cases he has to start from large and miserable legacy systems. He's passionate about software design in every aspect: test-driven development, behavior-driven development, and, in particular, domain-driven design. Cyrille lives in Paris with his wTable of ContentsIntroduction Chapter 1: Rethinking Documentation A Tale from the Land of Living Documentation Why This Feature? Tomorrow You Won’t Need This Sketch Anymore Sorry, We Don’t Have Marketing Documents! You Keep Using This Word, but This Is Not What It Means Show Me the Big Picture, and You’ll See What’s Wrong There The Future of Living Documentation Is Now The Problem with Traditional Documentation Documentation Is Not Cool, Usually The Flaws of Documentation The Agile Manifesto and Documentation It’s Time for Documentation 2.0 Documentation Is About Knowledge The Origination of Knowledge How Does Knowledge Evolve? Why Knowledge Is Necessary Documentation Is About Transferring Knowledge Focusing on What Matters Core Principles of Living Documentation Reliable Low Effort Collaborative Insightful How Ants Exchange Knowledge: Stigmergy Most Knowledge Is Already There Internal Documentation Internal Versus External Documentation Examples of Internal and External Documentation Preferring Internal Documentation In Situ Documentation Machine-Readable Documentation Specific Versus Generic Knowledge Learning Generic Knowledge Focusing on Specific Knowledge Ensuring Documentation Accuracy Accuracy Mechanism for Reliable Documentation When Documentation Does Not Need an Accuracy Mechanism Big Questions to Challenge Your Documentation Questioning the Need for Documentation at All Need for Documentation Because of Lack of Trust Just-in-Time Documentation, or a Cheap Option on Future Knowledge Questioning the Need for Traditional Documentation Minimizing Extra Work Now Minimizing Extra Work Later Making an Activity Fun Documentation Reboot Living Documentation: The Very Short Version Approaches to Better Documentation A Gateway to DDD Domain-Driven Design in a Nutshell Living Documentation and Domain-Driven Design When Living Documentation Is an Application of DDD A Story of Mutual Roots Between BDD, DDD, XP, and Living Documentation Summary Chapter 2: Behavior-Driven Development as an Example of Living Specifications BDD Is All About Conversations BDD with Automation Is All About Living Documentation Redundancy and Reconciliation The Anatomy of Scenarios in a File The Intent of a Feature File Feature File Scenarios Specification Details Tags in Feature Files Scenarios as Interactive Living Documentation Scenarios in Boring Paper Documents A Feature File Example A Canonical Case of Living Documentation in Every Aspect Going Further: Getting the Best of Your Living Documentation Property-Based Testing and BDD Summary Chapter 3: Knowledge Exploitation Identifying Authoritative Knowledge Where Is the Knowledge Now? Single-Source Publishing Some Examples of Producing a Published Document A Published Snapshot with a Version Number Remarks Setting Up a Reconciliation Mechanism (aka Verification Mechanism) Running Consistency Tests Reconciliation on the Test Assumptions Published Contracts Consolidating Dispersed Facts How Consolidation Works Consolidation Implementation Considerations Ready-Made Documentation The Power of a Standard Vocabulary Linking to Standard Knowledge More Than Just Vocabulary Using Ready-Made Knowledge in Conversation to Speed Up Knowledge Transfer Tools History Summary Chapter 4: Knowledge Augmentation When Programming Languages Are Not Enough Documentation Using Annotations Annotations as More Than Tags Describing the Rationale Behind Decisions Embedded Learning Documentation by Convention Living Documentation in Legacy Code with Conventions Documenting the Conventions Consistently Adhering to Conventions The Limitations of Conventions External Documentation Methods Sidecar Files Metadata Databases Designing Custom Annotations Stereotypical Properties Stereotypes and Tactical Patterns Using Meaningful Annotation Package Names Hijacking Standard Annotations Standard Annotation: @Aspect and Aspect-Oriented Programming Annotation by Default or Unless Necessary Handling Module-Wide Knowledge Dealing with Many Kinds of Modules Module-Wide Augmentation In Practice Intrinsic Knowledge Augmentation Machine-Accessible Documentation Recording Your Rationale What’s in a Rationale? Making the Rationale Explicit Beyond Documentation: Motivated Design Avoid Documenting Speculation Skills as Pre-Documented Rationales Recording the Rationale as an Enabler for Change Acknowledging Your Influences (aka Project Bibliography) Declaring Your Style Commit Messages as Comprehensive Documentation Commit Guidelines Summary Chapter 5: Living Curation: Identifying Authoritative Knowledge Dynamic Curation Examples of Dynamic Curation Editorial Curation Low-Maintenance Dynamic Curation One Corpus of Knowledge for Multiple Uses Scenario Digests Highlighting the Core Highlighting Inspiring Exemplars Guided Tours and Sightseeing Maps Creating a Sightseeing Map Creating a Guided Tour Creating a Living Guided Tour A Poor Man’s Literate Programming Summing Up: The Curator Preparing an Art Exhibition Selecting and Organizing Existing Knowledge Adding What’s Missing When Needed Accessibility for People Who Can’t Attend and for Posterity Summary Chapter 6: Automating Documentation Living Documents Steps in Creating a Living Document Presentation Rules Living Glossaries How a Living Glossary Works An Example Please! Information Curation for Living Documents Creating a Glossary Within a Bounded Context Case Study of a Living Glossary Living Diagrams Diagrams Assist in Conversations One Diagram, One Story Living Diagrams to Keep You Honest The Quest for the Perfect Diagram Rendering a Living Diagram Visualization Guidelines Example: Hexagonal Architecture Living Diagram Case Study: A Business Overview as a Living Diagram Example: A Context Diagram The Challenges with Automated Generation of Design Documentation Summary Chapter 7: Runtime Documentation Example: Living Services Diagram A Matter of Augmented Code but at Runtime Discovering the Architecture The Magic That Makes This Work Going Further Visible Workings: Working Software as Its Own Documentation Visible Tests Domain-Specific Notation Generating Custom Domain-Specific Diagrams to Get Visual Feedback Example: A Visible Test When Using Event Sourcing A Concrete Example in Code Living Diagrams from Event Sourcing Scenarios Introspectable Workings: Code in Memory as a Source of Knowledge Introspecting with Reflection Introspecting Without Reflection Summary Chapter 8: Refactorable Documentation Code as Documentation Text Layout Coding Conventions Naming as the Primary Documentation Composed Methods: You Need to Name Them Idiomatic Naming Is Contextual Coding Against a Framework Type-Driven Documentation From Primitives to Types Documented Types and Integrated Documentation Types and Associations Types over Comments The Composed Method Fluent Style Using an Internal DSL Implementing a Fluent Interface Fluent Tests Creating a DSTL When Not to Use a Fluent Style Case Study: An Example of Refactoring Code, Guided by Comments Integrated Documentation Type Hierarchy Code Searching Semantics Derived from Actual Usage Using Plain-Text Diagrams Example: Plain-Text Diagrams Diagrams as Code Summary Chapter 9: Stable Documentation Evergreen Content Requirements Are More Stable Than Design Decisions High-Level Goals Tend to Be Stable A Lot of Knowledge Is Less Stable Than It Looks Case Study: A README File Tips for Evergreen Documentation Avoiding Mixing Strategy Documentation with the Documentation of Its Implementation Ensuring Stability Using Perennial Naming Organizing Artifacts Along Stable Axes Linked Knowledge Volatile-to-Stable Dependencies Broken Link Checkers Link Registry Bookmarked Searches Categories of Stable Knowledge Evergreen README Vision Statement Domain Vision Statements Goals Impact Mapping Investing in Stable Knowledge Domain Immersion Investigation Wall Domain Training Live-My-Life Sessions Shadow Users A Long-Term Investment Summary Chapter 10: Avoiding Traditional Documentation Conversations About Formal Documentation Wiio’s Laws The Rule of Three Interpretations Obstacles to Conversations Working Collectively for Continuous Knowledge Sharing Pair Programming Cross Programming Mob Programming The Three Amigos (or More) Event Storming as an Onboarding Process Knowledge Transfer Sessions Continuous Documentation Truck Factor Coffee Machine Communication Idea Sedimentation Throw-Away Documentation On-Demand Documentation Just-in-Time Documentation Provoking Just-in-Time Learning Early Astonishment Report Including Some Upfront Documentation Interactive Documentation Declarative Automation Declarative Style Declarative Dependency Management Declarative Configuration Management Declarative Automated Deployment Machine Documentation Remarks on Automation in General Enforced Guidelines Some Examples of Rules Evolving the Guidelines Enforcement or Encouragement Declarative Guidelines A Matter of Tools Guidelines or Design Documentation? Warranty Sticker Void if Tampered With Trust-First Culture Constrained Behavior Making It Easy to Do the Right Thing Making Mistakes Impossible: Error-Proof API Design Principles for Documentation Avoidance Replaceability First Consistency First Example: The Zero Documentation Game Continuous Training Summary Chapter 11: Beyond Documentation: Living Design Listening to the Documentation What Happened to the Language of the Domain? Programming by Coincidence Design Deliberate Decision Making “Deliberate Decision” Does Not Mean “Upfront Decision” Documentation Is a Form of Code Review Shameful Documentation Example: Shameful Documentation The Troubleshooting Guide Shameful Code Documentation Documenting Errors or Avoiding Errors? Documentation-Driven Development Documentation to Keep You Honest The Apparent Contradiction Between Documentation Driven and “Avoiding Documentation” Abusing Living Documentation (Anti-pattern) Procrastination by Living Documentation Biodegradable Documentation Hygienic Transparency Diagnostic Tools Positive Pressure to Clean the Inside Design Skills Everywhere Reporter Porter Interviewing Mr. Living Doc Doc Summary Chapter 12: Living Architecture Documentation Documenting the Problem An Example of a Problem Brief Explicit Quality Attributes Stake-Driven Architecture Documentation Explicit Assumptions Brevity Suggests Quality Evolving Continuously: Change-Friendly Documentation Decision Logs An Example of a Structured Decision Log Journals or Blogs as Brain Dumps Fractal Architecture Documentation The Architecture Landscape Architecture Diagrams and Notations An Architecture Codex Transparent Architecture Architectural Annotations Enforced Design Decisions Architectural Reality Check Test-Driven Architecture Quality Attributes as Scenarios Quality Attributes at Runtime in Production Other Quality Attributes From Fragmented Knowledge to Usable Documentation Small-Scale Simulation as Living Architecture Documentation The Desirable Properties of a Small-Scale Simulation Techniques to Simplify a System Building a Small-Scale Simulation Is Half the Fun System Metaphor Explaining a System by Talking About Another System Useful Even Without Prior Knowledge A Metaphor in Another Metaphor Summary Chapter 13: Introducing Living Documentation to a New Environment Undercover Experiments Official Ambition New Things Have to Work and Have to Be Accepted Starting Gently Going Big and Visible Case Study: A Tale of Introducing Living Documentation to a Team Member Conversations First The First Debriefing Time to Talk About the Code Decision Logs and Guided Tours Common Objections to Living Documentation Annotations Are Not Meant for Documentation “We Do It Already” Migrating Legacy Documentation into Living Documentation Marginal Documentation Case Study: Introducing Living Documentation in a Batch System README and Ready-Made Documentation Business Behavior Visible Workings and a Single Source of Truth Integrated Documentation for Developers and a Living Glossary for Other Stakeholders A Living Diagram to Show the Design Intent Contact Information and Guided Tours Microservices Big Picture Selling Living Documentation to Management Starting with an Actual Problem A Living Documentation Initiative Contrasting the Current Situation with the Promise of a Better World to Match People’s Aspirations Compliance in Spirit Case Study: Compliance with ITIL The ITIL Example Summary Chapter 14: Documenting Legacy Applications Documentation Bankruptcy Legacy Application as Fossilized Knowledge Archeology Bubble Context Superimposed Structure Highlighted Structure External Annotations Biodegradable Transformation Example: Strangler Application Example: Bankruptcy Agree on Maxims Enforced Legacy Rules Summary Chapter 15: Extra: Conspicuous Documentation Focusing on Differences How Is Your Lemon? Tell Only What’s Unknown Segmenting by Known Audience Flexible Content Low-Fidelity Content Visual Facilitation Search-Friendly Documentation Concrete Examples, Together, Now In Practice Fast Media and Prior Preparation Together, Now Stack Overflow Documentation Affordable and Attractive Specs Digest Easter Eggs and Fun Anecdotes Promoting News Unorthodox Media Maxims Posters and Domestic Ads Meme-Based Posters Information Radiators Humor and Cheap Media Goodies/Swag Comics Infodecks Visualizations and Animations LEGO Bricks Furniture 3D Printed Stuff Summary 9780134689326 TOC 4/17/2019

Read more less

Book SynopsisOliver Goldman leads the AEC software architecture practice at Autodesk. He has thirty years of industry experience delivering innovative products in distributed real-time interaction, scientific computing, financial systems, mobile application development, and cloud architecture at Adobe and other employers. He holds degrees in computer science from Stanford University, holds more than 50 US software patents, and has previously contributed to Dr. Dobb's Journal.

Read more less

Book SynopsisSrinath Perera has been an Apache open source developer for the last 20 years. He has played a major role in the architecture of Apache Axis2, Apache Airavata, WSO2 CEP (Siddhi), and WSO2 Choreo. He has designed two SOAP engines and helped build four. He is a committer (a developer who can commit to a code base) for Apache Axis, Axis2, Apache Geronimo, and Apache Airavata.   He joined WSO2 in 2009 after finishing his PhD. WSO2 products are used by many Fortune 500 companies such as airlines, banks, and governments. At WSO2, he has played an architecture review role for 10+ projects and 100+ releases. He reviewed hundreds of customer solution architectures and deployments and sat in on thousands of architecture reviews. He has published 40+ peer-reviewed research articles, which have been referenced by thousands of other research publications.Table of ContentsChapter 1: Introduction to Software Leadership 1 Role of Judgment 1 Goal of This Book 3 Part I: Introduction 6 Part II: Essential Background 7 Part III: System Design 7 Part IV: Putting Everything Together 8 Chapter 2: Understanding Systems, Design, and Architecture 9 What Is Software Architecture? 9 How to Design a System 11 Five Questions 12 Seven Principles: The Overarching Concepts 16 Designing for an Online Bookstore 24 Designing for the Cloud 27 Summary 29 Chapter 3: Mental Models for Understanding and Explaining System Performance 31 A Computer System 32 Models for Performance 33 Optimization Techniques 41 Intuitive Feel for Performance 46 Leadership Considerations 46 Summary 47 Chapter 4: Understanding User Experience (UX) 49 General UX Concepts for Architects 49 UX Design for Configurations 53 UX Design for APIs 54 UX Design for Extensions 56 Leadership Considerations 57 Summary 57 Chapter 5: Macro Architecture: Introduction 59 History of Macro Architecture 60 Modern Architectures 62 Macro Architectural Building Blocks 63 Leadership Considerations 66 Summary 68 Chapter 6: Macro Architecture: Coordination 69 Approach 1: Drive Flow from Client 69 Approach 2: Use Another Service 70 Approach 3: Use Centralized Middleware 71 Approach 4: Implement Choreography 71 Leadership Considerations 73 Summary 73 Chapter 7: Macro Architecture: Preserving Consistency of State 75 Why Transactions? 75 Why Do We Need to Go Beyond Transactions? 76 Going Beyond Transactions 77 Best Practices 80 Leadership Considerations 81 Summary 83 Chapter 8: Macro Architecture: Handling Security 85 User Management 86 Interaction Security 88 Storage, GDPR, and Other Regulations 96 Security Strategy and Advice 98 Leadership Considerations 101 Summary 103 Chapter 9: Macro Architecture: Handling High Availability and Scale 105 Adding High Availability 105 Understanding Scalability 109 Scaling for a Modern Architecture: Base Solution 110 Scaling: The Tools of Trade 111 Building Scalable Systems 113 Leadership Considerations 117 Summary 118 Chapter 10: Macro Architecture: Microservices Considerations 119 Decision 1: Handling Shared Database(s) 120 Decision 2: Securing Microservices 122 Decision 3: Coordinating Microservices 122 Decision 4: Avoiding Dependency Hell 122 Loosely Coupled, Repository-Based Teams as an Alternative to Microservices 125 Leadership Considerations 126 Summary 127 Chapter 11: Server Architectures 129 Writing a Service 129 Understanding Best Practices for Writing a Service 130 Understanding Advanced Techniques 132 Using These Techniques in Practice 143 Leadership Considerations 146 Summary 147 Chapter 12: Building Stable Systems 149 Why Do Systems Fail, and What Can We Do About Them? 149 How to Handle Known Errors 151 Common Bugs 159 How to Handle Unknown Errors 161 Graceful Degradation 163 Leadership Considerations 163 Summary 164 Chapter 13: Building and Evolving the Systems 165 Getting Your Hands Dirty 165 Communicating the Design 172 Evolving the System: How to Learn from Your Users and Improve the System 172 Leadership Considerations 175 Summary 176 Index 179

Read more less

Book SynopsisDorothy Graham and Mark Fewster are the principal consultant partners of Grove Consultants which provides consultancy and training in software testing, test automation, and Inspection. Mark Fewster developed the test automation design techniques which are the primary subject of this book. He has been refining and applying his ideas through consultancy with a wide variety of clients since 1991. Dorothy Graham is the originator and co-author of the CAST Report (Computer Aided Software Testing tools) published by Cambridge Market Intelligence, and the co-author of Software Inspection published by Addison-Wesley in 1993. Both authors are popular and sought-after speakers at international conferences and workshops on software testing.Table of ContentsPreface Part One: Techniques for Automating Test Execution 1 Test automation context1.1 Introduction 1.2 Testing and test automation are different 1.3 The V-model 1.4 Tool support for life-cycle testing 1.5 The promise of test automation 1.6 Common problems of test automation 1.7 Test activities 1.8 Automate test design? 1.9 The limitations of automating software testing 2 Capture Replay is Not Test Automation2.1 An example application: Scribble 2.2 The manual test process: what is to be automated 2.3 Automating Test Execution: inputs 2.4 Automating Test Result Comparison 2.5 The next steps in evolving test automation 2.6 Conclusion: Automated is not automatic 3 Scripting techniques3.1 Introduction 3.2 Scripting techniques 3.3 Script pre-processing 4 Automated comparison4.1 Verification, comparison and automation 4.2 What do comparators do? 4.3 Dynamic comparison 4.4 Post-execution comparison 4.5 Simple comparison 4.6 Complex comparison 4.7 Test sensitivity 4.8 Comparing different types of outcome 4.9 Comparison filters 4.10 Comparison guidelines 5 Testware Architecture5.1 What is testware architecture? 5.2 Key issues to be resolved 5.3 An Approach 5.4 Might this be Overkill? 6 Automating Pre- and Post-Processing6.1 What are Pre- and Post-Processing? 6.2 Pre- and Post Processing 6.3 What should happen after test case execution 6.4 Implementation Issues 7 Building maintainable tests7.1 Problems in maintaining automated tests 7.2 Attributes of test maintenance 7.3 The conspiracy 7.4 Strategy and tactics 8 Metrics8.1 Why measure testing and test automation? 8.2 What can we measure? 8.3 Objectives for testing and test automation 8.4 Attributes of software testing 8.5 Attributes of test automation 8.6 Which is the best test automation regime? 8.7 Should I really measure all these? 8.8 Summary 8.9 Answer to DDP Exercise 9 Other Issues9.1 Which Tests to Automate (first)? 9.2 Selecting which tests to run when 9.3 Order of test execution 9.4 Test status 9.5 Designing software for (automated) testability 9.6 Synchronization 9.7 Monitoring progress of automated tests 9.8 Tailoring your own regime around your tools 10 Choosing a tool to automate testing10.1 Introduction to Chapters 10 and 11 10.2 Where to start in selecting tools: your requirements, not the tool market 10.3 The tool selection project 10.4 The tool selection team 10.5 Identifying your requirements 10.6 Identifying your constraints 10.7 Build or buy? 10.8 Identifying what is available on the market 10.9 Evaluating the short listed candidate tools 10.10 Making the decision 11 Implementing tools within the organization11.1 What could go wrong? 11.2 Importance of managing the implementation process 11.3 Roles in the implementation/change process 11.4 Management commitment 11.5 Preparation 11.6 Pilot project 11.7 Planned phased installation or roll-out 11.8 Special problems in implementing 11.9 People issues 11.10 Conclusion 12 Racal-Redac Case History12.1 Introduction 12.2 Background 12.3 Solutions 12.4 Integration to Test Automation 12.5 System Test Automation 12.6 The Results Achieved 12.7 Summary of the case history up to 1991 12.8 What happened next? 13 The Evolution of an Automated Software Test System13.1 Introduction 13.2 Background 13.3 Gremlin 1 13.4 Gremlin 2.0: A Step Beyond Capture/Replay 13.5 Finding The Real Problem 13.6 Lesson Learned 14 Experiences with Test Automation14.1

Read more less

Book SynopsisPete McBreen is an independent consultant who actually enjoys writing and delivering software. Despite spending a lot of time writing, teaching, and mentoring, he goes out of his way to ensure that he does hands-on coding on a live project every year. Pete specializes in finding creative solutions to the problems that software developers face. After many years of working on formal and informal process improvement initiatives, he took a sideways look at the problem and realized, Software development is meant to be fun. If it isn't, the process is wrong. Pete lives in Cochrane, Alberta, Canada and has no plans to move back to a big city. 0201733862AB07092002Table of Contents Preface. I. QUESTIONING SOFTWARE ENGINEERING. 1. Understanding Software Engineering. The Paradox of Software Engineering. The Modern Definition of Software Engineering. Is Software Engineering a Good Choice for Your Project? 2. The Problems with Software Engineering. Can Software Development Be Made Systematic and Quantified? The Hazards of the Good Enough Software Approach. What Is the Alternative to Software Engineering? 3. Understanding Software Development. Software as Capital. Does the Division of Labor Work for Software Development? One Size Does Not Fit All. 4. Finding a Better Metaphor Than Software Engineering. Finding a Better Metaphor Than Software Engineering. The Craft of Software Development. Parallels with Traditional Craftsmanship. The Resurgence of the Craft of Software Development. II. SOFTWARE CRAFTSMANSHIP. 5. Putting People Back into Software Development. Craftsmanship Is About Getting Better at Software Development. Craftsmanship Encourages Developers to Write Great Software. A Call to Arms. 6. Craftsmanship Is the Opposite of Licensing. Craftsmanship Is Personal. Licensing Is an Illusion. Craftsmanship Focuses on the Individual. III. IMPLICATIONS OF SOFTWARE CRAFTSMANSHIP. 7. How Craftsmanship Affects the Users of Systems. Software Craftsmanship Works Because Software Is Easy to Copy. Craftsmen Have a Different Relationship with Their Users. Great Software Deserves to Be Signed. Craftsmen Need Demanding Users. Software Craftsmanship Leads to Collaborative Development. 8. Customers Have a Different Relationship with Craftsmen. Setting Realistic Delivery Dates. Exposing the Fallacy of Good Enough Software. Allowing Software Craftsmen to Take Credit for Their Work. Start Exploiting the Difference in Productivity Between Developers. But How Do We Know How Good a Developer Really Is? Customers Make a Cost/Quality Trade-off When Choosing Craftsmen. Customers Have Long Term Relationships with Software Craftsmen. Customer Interests Are Aligned with the Interests of Software Craftsmen. 9. Managing Craftsmen. Software Craftsmen Are Not Hired Hands. Good Developers Are More Valuable Than Their Managers. Software Craftsmen Have a Different Relationship with Their Managers, Managing Great Developers Is a Pleasure and a Privilege. Software Craftsmen Like Creating Applications. Managing Software Craftsmen Is Different. Software Craftsmen Push for What They Need. 10. Becoming a Software Craftsman. Software Craftsmanship Is a Rejection of Narrow Specialization. Craftsmanship Requires Dedication. How Does a Person Become a Software Craftsman? The Craft Tradition Has Endured for Centuries. 11. Mastering the Craft. What Does a Master Software Craftsman Look Like? Use Your Old-timers. Mastery Implies the Use of Stable Technologies. Developing Mastery Takes Time. Mastery Implies Taking Responsibility for Passing on the Craft. 12. Apprentice Developers. We Must Reverse the Decline in the Quality of Developer Training. Becoming an Apprentice Is a Significant Step. Apprenticeship Instills Lifelong Learning. The Role of Apprentices. An Apprenticeship Is a Significant Investment of Time and Energy. 13. Journeymen Developers. Where Journeymen Fit in the Craft Tradition. Journeymen Developers. Journeymen Are Focused on Delivering Applications. Journeymen Play a Key Role in Software Craftsmanship. IV. REPOSITIONING SOFTWARE ENGINEERING. 14. Software Engineering Projects. Software Engineering Is Designed for Large Systems Projects. Software Engineering Projects Are Diverse and Varied. 15. Hazards of the Software Engineering Metaphor. You Cannot Do Software Engineering on a Low Budget. Software Engineering Encourages Scientific Management. Software Factories: The Production Line for Software. Reuse over Time Is Hazardous. The Myth of the Standardized Software Development Process. Software Engineering Forces Us to Forget the Individual. We Need More Variety in Our Development Processes, Not Less. 16. Learning from Software Engineering. Size and Complexity Matter. Applications Need to Be Well Structured. Change Can Be Expensive Unless You Allow for It. Communication Inside the Team and with Users Is Crucial. Producing Accurate Estimates Is Very Expensive. V. WHAT TO DO ON MONDAY MORNING. 17. Experience— The Best Indicator of Project Success. Choose Software Craftsmen Based on Their Reputations. Evaluate Craftsmen Based on Their Reputations and Portfolio. Auditioning a Software Craftsman. Let Your Software Craftsman Pick the Rest of the Development Team. Collaborative Development. Avoid Bleeding-Edge Technology If At All Possible. Paying for Experience. Be Prepared to Be Amazed. Design for Testing and Maintenance. Think Applications, Not Projects. Maintenance Teams Should Refuse to Accept Bad Applications. 18. Design for Maintenance. Software Craftsmen Prefer Nonproprietary, Open Source Tools. Great Software Is Global. Software Craftsmen Need to Fight Back Against Planned Obsolescence. Great Software Needs to Be Given a Great User Interface. Maintainable Software Is Easy to Diagnose. The Hazards of Outsourcing. You Can Still Use Outside Craftsmen to Create Your Application. Maintenance Is the Most Important Part of the Life of Any Application. Not All Software Has to Be Maintainable. Design for Testing and Maintenance Is Not Rocket Science. 19. Perpetual Learning. Creating a Learning Environment. Mastering the Craft of Software Development. Choose Training Courses Very Carefully. Encourage Your People to Be Visible in the Software Development Community. Becoming a Reflective Practitioner. Epilogue. Acknowledgements. Index. 0201733862T08072001

Read more less

Book SynopsisThis book is a critical introduction to code and software that develops an understanding of its social and philosophical implications in the digital age. Written specifically for people interested in the subject from a non-technical background, the book provides a lively and interesting analysis of these new media forms.Trade Review'This is a beautifully written book that pulls off the difficult task of introducing the subject of software and the workings of code to the non specialist whilst also providing an original take of the philosophical and the cultural importance of Code in contemporary culture.' - Michael Bull, University of Sussex, UK 'The book is warmly recommended:[Berry's] understanding of software is fantastic. It reaches out to so many discussions and has so many implications that it is an engine in itself: it produces ideas.' - Jussi Parikka, Leonardo on-line 'What is important about The Philosophy of Software is that it really is about what it claims to be about. Rather than trying to shoehorn software into an existing philosophical or political agenda it considers software as a thing in itself and finds those philosophers and philosophical ideas that best address the vitally important phenomenon of software. However much philosophy, computer science or cybercultural theory you may know this is a book that will set you thinking about software anew.' - Rob Myers, Furtherfield 'One of the most prolific contributors to the CCSWGs, David M. Berry has also contributed one of the most extensive manuscripts on reading code and code culture. The Philosophy of Software contains chapters on the epistemology and ontology of code, reading and writing code, running code, and the phenomenology of code. Written for a general audience, the book reads several code examples including the Microsoft Windows 2000 source code and obfuscated code competitions.' - Mark C. Marino, Computational Culture, 2014Table of ContentsAcknowledgements The Idea of Code What is Code? Reading and Writing Code Running Code Towards a Phenomenology of Computation Real-Time Streams Bibliography Index

Read more less

Book Synopsis

Read more less

Book SynopsisThe first comprehensive presentation of reduction semantics in one volume, and the first tool set for such forms of semantics.This text is the first comprehensive presentation of reduction semantics in one volume; it also introduces the first reliable and easy-to-use tool set for such forms of semantics. Software engineers have long known that automatic tool support is critical for rapid prototyping and modeling, and this book is addressed to the working semantics engineer (graduate student or professional language designer). The book comes with a prototyping tool suite to develop, explore, test, debug, and publish semantic models of programming languages. With PLT Redex, semanticists can formulate models as grammars and reduction models on their computers with the ease of paper and pencil. The text first presents a framework for the formulation of language models, focusing on equational calculi and abstract machines, then introduces PLT Redex, a suite of software tools for e

Read more less

Book SynopsisAn introduction to writing proofs about computer programs, written in an accessible question-and-answer style, complete with step-by-step examples and a simple proof assistant.The Little Prover introduces inductive proofs as a way to determine facts about computer programs. It is written in an approachable, engaging style of question-and-answer, with the characteristic humor of The Little Schemer (fourth edition, MIT Press). Sometimes the best way to learn something is to sit down and do it; the book takes readers through step-by-step examples showing how to write inductive proofs. The Little Prover assumes only knowledge of recursive programs and lists (as presented in the first three chapters of The Little Schemer) and uses only a few terms beyond what novice programmers already know. The book comes with a simple proof assistant to help readers work through the book and complete solutions to every example.

Read more less

Book Synopsis Ian Alexander is an independent consultant specialising in Requirements Engineering. He has written several training courses on systems and requirements engineering. He has led hundreds of training courses on systems engineering, requirements, DOORS, and DXL, and has run numerous practical workshops on scenarios, trade-offs and requirements. He was co-author of an Addison-Wesley book on HTML 3 and its 2nd Edition on HTML 4. He is the author of the Scenario Plus for Use Cases toolkit, and is a well-known speaker and writer on scenario usage. He is currently on a technology project to investigate the reuse of specifications for control systems in the German automobile industry. He helps to run the BCS Requirements Engineering Specialist Group and the IEE Professional Network for Systems Engineering. He is a Chartered Engineer. Richard Stevens is the founder of QSS, the firm that launched the pioneering RequirTable of Contents Table of Contents 1. Introduction 9 1.1 Why do requirements matter? 9 1.2 Who are requirements for? 12 1.3 Different names for requirements 13 1.4 Different types of specification 14 1.5 The challenge of writing better requirements 15 1.6 The requirements writing process 18 2. Identifying the stakeholders 21 2.1 Different types of stakeholder 21 2.2 Your house extension: a simple case? 22 2.3 A practical approach to identifying stakeholders 23 Exercise 1: Listing the stakeholders 23 3. Gathering requirements from stakeholders 26 3.1 Possible techniques 26 Exercise 2: Asking 'why?' 28 3.2 Interviews 28 3.3 Workshops 32 3.4 Experiencing life as a user 36 3.5 Observing users at work 36 3.6 Acting out what needs to happen 36 3.7 Prototypes 38 4. Other sources of requirements 40 4.1 Possible sources 40 Exercise 3: Extracting requirements from source documents 44 Exercise 4: Extracting requirements from a memo 45 4.2 Getting requirements for mass-market products 45 4.3 User requirements in subsystem projects 46 5. Structuring the requirements 47 5.1 You need structure as well as text 47 5.2 Breaking the problem down into steps 48 5.3 Organizing requirements into scenarios 50 5.4 Examples of goal decomposition 52 Exercise 5: A structure for user requirements 53 5.5 Handling exceptions 53 Exercise 6: Could anything go wrong here? 54 Exercise 7: Exceptions 55 5.6 Examples and exercises in requirement structure 57 Exercise 8: Creating a heading structure 57 Exercise 9: The right document for each subject 57 Exercise 10: Wrongly placed requirements 58 6. Requirements in context 59 6.1 The user requirements document 59 6.2 Organizing the constraints 60 Exercise 11: Writing constraints 64 6.3 Defining the scope 64 Exercise 12: Restricting the scope 65 6.4 Requirement attributes 65 6.5 Keeping track of the requirements 67 7. Requirements writing 70 7.1 Quality, not perfection 70 7.2 Sketch, then improve 70 7.3 Anatomy of a good requirement 70 7.4 Guidelines for good requirements 71 7.5 Don't write like this 72 Exercise 13: Good requirements 75 Exercise 14: Writing requirements for familiar domestic systems 75 Exercise 15: Ambiguous requirements 76 8. Checking and reviewing 78 8.1 Checking the document structure with users 78 8.2 Checking the requirements 80 Exercise 16: Checking individual requirements 81 Exercise 17: Checking a set of requirements 82 8.3 Reviewing 83 8.4 Success - the reviewed document 85 Exercise 18: Reviewing 85 A: Answers to exercises 87 Exercise 1: Listing the stakeholders 87 Exercise 2: Asking 'why?' 87 Exercise 3: Extracting requirements from source documents 87 Exercise 4: Extracting requirements from a memo 88 Exercise 5: A structure for user requirements 88 Exercise 6: Could anything go wrong here? 89 Exercise 7: Exceptions 89 Exercise 8: Creating a heading structure 90 Exercise 9: The right document for each subject 90 Exercise 10: Wrongly placed requirements 90 Exercise 11: Writing constraints 91 Exercise 12: Restricting the scope 92 Exercise 13: Good requirements 92 Exercise 14: Writing requirements for familiar domestic systems 93 Exercise 15: Ambiguous requirements 93 Exercise 16: Checking individual re

Read more less

Book SynopsisMultiagent systems (MAS) are one of the most exciting and the fastest growing domains in the intelligent resource management and agent-oriented technology, which deals with modeling of autonomous decisions making entities. Recent developments have produced very encouraging results in the novel approach of handling multiplayer interactive systems. In particular, the multiagent system approach is adapted to model, control, manage or test the operations and management of several system applications including multi-vehicles, microgrids, multi-robots, where agents represent individual entities in the network. Each participant is modeled as an autonomous participant with independent strategies and responses to outcomes. They are able to operate autonomously and interact pro-actively with their environment. In recent works, the problem of information consensus is addressed, where a team of vehicles communicate with each other to agree on key pieces of information that enable them to work tTable of ContentsPreface. Introduction. Theoretical Background. Distributed Intelligence in Power Systems. Consensus for Heterogeneous Systems with Delays. Secure Control of Distributed Multiagent Systems. Advanced Consensus Algorithms. Cooperative Control of Networked Power Systems. Dynamic Graphical Games. References. Index.

Read more less

Book SynopsisThis book records the author's years of experience in the software industry. In his own practices, the author has found that the distributed work pattern has become increasingly popular in more and more work environments, either between vendors and customers or between different teams inside a company. This means that all practitioners in the software industry need to adapt to this new way of communication and collaboration and get skilled enough to meet the greater challenges in integrating the distributed work pattern with agile software delivery. By centering on the difficulties in communication and collaboration between distributed teams, this book digs into the reasons why so many remote delivery projects end up anticlimactic and provides solutions for readers' reference. It also cites successful cases in promoting agile development in distributed teams, which has been a vexing problem for many software development companies. In addition, readers can find suggestions andTable of ContentsForeword 1: Taking Up Delivery Wholeheartedly. Foreword 2: Pursue Ideal Software Delivery. Preface. Chapter 1 Current Situation of Distributed Teams. Chapter 2 Communication between Distributed Teams. Chapter 3 Collaboration between Distributed Teams. Chapter 4 Application of Visualization. Chapter 5 Waste in Distributed Teams. Chapter 6 Self-Managed Offshore Teams. Chapter 7 Customer-Oriented Offshore Teams. Chapter 8 The Future of Distributed Teams. Postscript. References. Index.

Read more less

Book SynopsisThis book focuses on elementary concepts of both radio frequency energy harvesting (RFEH) and wireless power transfer (WPT), and highlights their fundamental requirements followed by recent advancements. It provides a systematic overview of the key components required for RFEH and WPT applications and also comprehensively introduces the pioneering research advancements achieved to date. The state-of-the-art circuit design topologies for the two different applications are presented mainly in terms of antenna operating frequencies, polarization characteristics, efficient matching network circuits, rectifier topologies, and overall rectenna systems. The book serves as a single point of reference for practicing engineers and researchers searching for potential sources and elements involved in the RFEH system as well as in the WPT system, and need rapid training and design guidelines in the following areas:â Different sensing elements used in RFEH and WPTâ Inclusions of matTable of ContentsPART A Elements of RF Energy Harvesting (RFEH) Systems Chapter 1 Introduction..........................................................................................3Chapter 2 Antennas for RFEH Systems.............................................................. 11Chapter 3 Rectifiers for RFEH Systems.............................................................. 33Chapter 4 Rectennas for RFEH Systems............................................................. 51PART B Elements of Wireless Power Transfer (WPT) SystemsChapter 5 Antennas for WPT Systems................................................................69Chapter 6 Rectifiers for WPT Systems................................................................89Chapter 7 Rectennas for WPT Systems............................................................. 111Chapter 8 Matching Networks........................................................................... 123Chapter 9 Some Applications............................................................................ 143

Read more less

Book SynopsisThis book is intended to serve as a bridge in statistics for graduates and business practitioners interested in using their skills in the area of data science and analytics as well as statistical analysis in general. On the one hand, the book is intended to be a refresher for readers who have taken some courses in statistics, but who have not necessarily used it in their day-to-day work. On the other hand, the material can be suitable for readers interested in the subject as a first encounter with statistical work in Python. Statistics and Data Visualisation with Python aims to build statistical knowledge from the ground up by enabling the reader to understand the ideas behind inferential statistics and begin to formulate hypotheses that form the foundations for the applications and algorithms in statistical analysis, business analytics, machine learning, and applied machine learning. This book begins with the basics of programming in Python and data analysTable of Contents1. Data, Stats and Stories - An Introduction 2. Python Programming Primer 3. Snakes, Bears & Other Numerical Beasts: NumPy, SciPy & Pandas 4. The Measure of All Things - Statistics 5. Definitely Maybe: Probability and Distributions 6. Alluring Arguments and Ugly Facts - Statistical Modelling and Hypothesis Testing 7. Delightful Details - Data Visualisation 8. Dazzling Data Designs - Creating Charts A. Variance: Population v Sample B. Sum of First n Integers C. Sum of Squares of the First n Integers D. The Binomial Coefficient E. The Hypergeometric Distribution F. The Poisson Distribution G. The Normal Distribution H. Skewness and Kurtosis I. Kruskal-Wallis Test - No Ties

Read more less

Book SynopsisNew computational design tools have evolved rapidly and been increasingly applied in the field of design in recent years, complimenting and even replacing the traditional design media and approaches. Design as both the process and product are changing due to the emergence and adoption of these new technologies. Understanding and assessing the impact of these new computational design environments on design and designers is important for advancing design in the contemporary context. Do these new computational environments support or hinder design creativity? How do those tools facilitate designers' thinking? Such knowledge is also important for the future development of design technologies. Research shows that design is never a mysterious non-understandable process, for example, one general view is that design process shares a common analysis-synthesis-evaluation model, during which designers interact between design problem and solution spaces. Understanding designers' thinking in difTable of ContentsIntroduction. Emergent technologies in computational design. Understanding design cognition in computational and generative design. Cognitive impacts and computational design environments. Conclusion.

Read more less

Book SynopsisThe World Wide Web has a massive and permanent influence on our lives. Economy, industry, education, healthcare, public administration, entertainment - there is hardly any part of our daily lives which has not been pervaded by the Internet.Table of ContentsPreface xv Foreword xvii 1 An Introduction to Web Engineering 1Gerti Kappel, Birgit Pröll, Siegfried Reich, Werner Retschitzegger 1.1 Motivation 1 1.2 Categories of Web Applications 4 1.3 Characteristics of Web Applications 7 1.3.1 Product-related Characteristics 8 1.3.2 Usage-related Characteristics 12 1.3.3 Development-related Characteristics 14 1.3.4 Evolution 16 1.4 Objectives and Structure of the Book 17 2 Requirements Engineering for Web Applications 23Paul Grünbacher 2.1 Introduction 23 2.2 Fundamentals 24 2.2.1 Where Do Requirements Come From? 24 2.2.2 Requirements Engineering Activities 25 2.3 RE Specifics in Web Engineering 26 2.4 Principles for RE of Web Applications 30 2.5 Adapting RE Methods to Web Application Development 32 2.5.1 Requirement Types 32 2.5.2 Notations 34 2.5.3 Tools 36 2.6 Outlook 37 3 Modeling Web Applications 39Wieland Schwinger, Nora Koch 3.1 Introduction 39 3.2 Fundamentals 40 3.3 Modeling Specifics in Web Engineering 41 3.3.1 Levels 41 3.3.2 Aspects 42 3.3.3 Phases 42 3.3.4 Customization 43 3.4 Modeling Requirements 43 3.5 Content Modeling 45 3.5.1 Objectives 45 3.5.2 Concepts 45 3.6 Hypertext Modeling 46 3.6.1 Objectives 47 3.6.2 Hypertext Structure Modeling Concepts 47 3.6.3 Access Modeling Concepts 49 3.6.4 Relation to Content Modeling 50 3.7 Presentation Modeling 51 3.7.1 Objectives 51 3.7.2 Concepts 51 3.7.3 Relation to Hypertext Modeling 52 3.8 Customization Modeling 53 3.8.1 Objectives 54 3.8.2 Concepts 54 3.8.3 Relation to Content, Hypertext, and Presentation Modeling 58 3.9 Methods and Tools 58 3.9.1 Modeling Methods: An Overview 58 3.9.2 Model-Driven Development 61 3.9.3 Tool Support 61 3.10 Outlook 63 4 Web Application Architectures 65Christian Eichinger 4.1 Introduction 65 4.2 Fundamentals 66 4.2.1 What is an Architecture? 66 4.2.2 Developing Architectures 67 4.2.3 Categorizing Architectures 69 4.3 Specifics of Web Application Architectures 70 4.4 Components of a Generic Web Application Architecture 71 4.5 Layered Architectures 72 4.5.1 2-Layer Architectures 72 4.5.2 N-Layer Architectures 73 4.6 Data-aspect Architectures 79 4.6.1 Database-centric Architectures 80 4.6.2 Architectures for Web Document Management 80 4.6.3 Architectures for Multimedia Data 81 4.7 Outlook 84 5 Technology-aware Web Application Design 85Gerhard Austaller, Andreas Hartl, Markus Lauff, Fernando Lyardet, Max Mühlhaüser 5.1 Introduction 86 5.2 Web Design from an Evolutionary Perspective 89 5.2.1 Background 89 5.2.2 Information Design: An Authoring Activity 90 5.2.3 Software Design: A Programming Activity 92 5.2.4 Merging Information Design and Software Design 93 5.2.5 Problems and Restrictions in Integrated Web Design 94 5.2.6 A Proposed Structural Approach 95 5.3 Presentation Design 95 5.3.1 Presentation of Nodes and Meshes 96 5.3.2 Device-independent Development Approaches 97 5.4 Interaction Design 98 5.4.1 User Interaction 98 5.4.2 User Interface Organization 100 5.4.3 Navigation Design 101 5.4.4 Designing a Link Representation: The Anchor 101 5.4.5 Designing Link Internals: The URL 102 5.4.6 Navigation and Orientation 102 5.4.7 Structured Dialog for Complex Activities 103 5.4.8 Interplay with Technology and Architecture 104 5.5 Functional Design 105 5.5.1 Integration 105 5.5.2 Communication Paradigms and Middleware 105 5.5.3 Distributed Cross-corporate Web Applications 106 5.6 Outlook 107 5.6.1 Context-aware Applications 107 5.6.2 Device-independent Applications 108 5.6.3 Reusability 109 5.7 Summary 110 6 Technologies for Web Applications 111Martin Nussbaumer, Martin Gaedke 6.1 Introduction 111 6.2 Fundamentals 112 6.2.1 Markup 112 6.2.2 Hypertext and Hypermedia 112 6.3 Client/Server Communication on the Web 113 6.3.1 SMTP – Simple Mail Transfer Protocol. 113 6.3.2 RTSP – Real Time Streaming Protocol 113 6.3.3 HTTP – HyperText Transfer Protocol 113 6.3.4 Session Tracking 114 6.4 Client-side Technologies 116 6.4.1 Helpers and Plug-ins 116 6.4.2 Java Applets 116 6.4.3 ActiveX Controls 116 6.5 Document-specific Technologies 117 6.5.1 HTML – Hypertext Markup Language 117 6.5.2 SVG – Scalable Vector Graphics 117 6.5.3 SMIL – Synchronized Multimedia Integration Language 118 6.5.4 XML – eXtensible Markup Language 118 6.5.5 XSL – eXtensible Stylesheet Language 122 6.6 Server-side Technologies 126 6.6.1 URI Handlers 126 6.6.2 Web Services 129 6.6.3 Middleware Technologies 130 6.7 Outlook 132 7 Testing Web Applications 133Christoph Steindl, Rudolf Ramler, Josef Altmann 7.1 Introduction 133 7.2 Fundamentals 134 7.2.1 Terminology 134 7.2.2 Quality Characteristics 135 7.2.3 Test Objectives 136 7.2.4 Test Levels 136 7.2.5 Role of the Tester 137 7.3 Test Specifics in Web Engineering 138 7.4 Test Approaches 140 7.4.1 Conventional Approaches 140 7.4.2 Agile Approaches 140 7.5 Test Scheme 142 7.5.1 Three Test Dimensions 142 7.5.2 Applying the Scheme to Web Applications 143 7.5.3 Examples of Using the Test Scheme 145 7.6 Test Methods and Techniques 145 7.6.1 Link Testing 147 7.6.2 Browser Testing 147 7.6.3 Usability Testing 148 7.6.4 Load, Stress, and Continuous Testing 148 7.6.5 Testing Security 149 7.6.6 Test-driven Development 150 7.7 Test Automation 150 7.7.1 Benefits and Drawbacks of Automated Tests 150 7.7.2 Test Tools 151 7.7.3 Selecting Test Tools 152 7.8 Outlook 152 8 Operation and Maintenance of Web Applications 155Arno Ebner, Birgit Pröll, Hannes Werthner 8.1 Introduction 155 8.2 Challenges Following the Launch of a Web Application 156 8.3 Promoting a Web Application 157 8.3.1 Newsletters 158 8.3.2 Affiliate Marketing 158 8.3.3 Search Engine Marketing 159 8.3.4 Content-related Marketing 162 8.3.5 Domain Management 162 8.4 Content Management 163 8.4.1 Content Update Rate and Demand on Currency 164 8.4.2 Content Syndication 165 8.5 Usage Analysis 165 8.5.1 Usage Analysis Techniques 165 8.5.2 Statistical Indicators 167 8.5.3 User Behavior Analysis 168 8.6 Outlook 169 9 Web Project Management 171Herwig Mayr 9.1 From Software Project Management to Web Project Management 171 9.1.1 Objectives of Software Project Management 171 9.1.2 The Tasks of Software Project Management 172 9.1.3 Conflicting Areas in Projects 173 9.1.4 Specifics of Web Project Management 173 9.2 Challenges in Web Project Management 175 9.2.1 General Challenges in Software Development 175 9.2.2 Development-related Challenges in Web Projects 176 9.2.3 Product-related Challenges in Web Projects 179 9.3 Managing Web Teams 182 9.3.1 Software Development: A Human-centered Task 182 9.3.2 The Web Project Team 183 9.3.3 The Web Project Manager 184 9.4 Managing the Development Process of a Web Application 185 9.4.1 Deploying the Tools 185 9.4.2 Measuring Progress 188 9.4.3 Project Risks 190 9.4.4 Risk Management 193 9.5 Outlook 194 10 The Web Application Development Process 197Gregor Engels, Marc Lohmann, Annika Wagner 10.1 Motivation 197 10.2 Fundamentals 198 10.3 Requirements for a Web Application Development Process 201 10.3.1 Handling Short Development Cycles 201 10.3.2 Handling Changing Requirements 201 10.3.3 Releases with Fixed Deadlines and Flexible Contents 203 10.3.4 Parallel Development of Different Releases 203 10.3.5 Reuse and Integration 204 10.3.6 Adapting to Web Application’s Complexity Level 204 10.3.7 Summary 205 10.4 Analysis of the Rational Unified Process 205 10.4.1 Introduction 205 10.4.2 General Suitability for Web Application Development 208 10.4.3 Does RUP meet the Requirements of Web Applications? 209 10.5 Analysis of Extreme Programming 211 10.5.1 Introduction 211 10.5.2 Does XP meet the Requirements of Web Application Development? 214 10.6 Outlook 216 11 Usability of Web Applications 219Martin Hitz, Gerhard Leitner, Rudolf Melcher 11.1 Motivation 219 11.2 What is Usability? 220 11.3 What Characterizes the Usability of Web Applications? 222 11.4 Design Guidelines 225 11.4.1 Response Times 225 11.4.2 Interaction Efficiency 225 11.4.3 Colors 226 11.4.4 Text Layout 227 11.4.5 Page Structure 228 11.4.6 Navigation Structure 228 11.4.7 Multiculturality 230 11.4.8 Confidence-generating Measures 231 11.4.9 Other Design Criteria 232 11.5 Web Usability Engineering Methods 232 11.5.1 Requirements Analysis 234 11.5.2 Design 237 11.5.3 Implementation 238 11.5.4 Operation 238 11.6 Web Usability Engineering Trends 239 11.6.1 Usability Patterns 239 11.6.2 Mobile Usability 241 11.6.3 Accessibility 243 11.7 Outlook 245 12 Performance of Web Applications 247Gabriele Kotsis 12.1 Introduction 247 12.2 What Is Performance? 248 12.3 What Characterizes the Performance of Web Applications? 250 12.4 System Definition and Indicators 251 12.5 Characterizing the Workload 252 12.6 Analytical Techniques 254 12.6.1 Operational Analysis 254 12.6.2 Queuing Networks and Simulation Models 255 12.6.3 Measuring Approaches 257 12.7 Representing and Interpreting Results 258 12.8 Performance Optimization Methods 259 12.8.1 Acceleration Within a Web Application 260 12.8.2 Reducing Transmission Time 261 12.8.3 Server Tuning 263 12.9 Outlook 263 13 Security for Web Applications 265Martin Wimmer, Alfons Kemper, Stefan Seltzsam 13.1 Introduction 265 13.2 Aspects of Security 266 13.3 Encryption, Digital Signatures and Certificates 268 13.3.1 Symmetric Cryptography 268 13.3.2 Asymmetric Cryptography 270 13.3.3 Digital Signatures 271 13.3.4 Certificates and Public Key Infrastructure 272 13.4 Secure Client/Server-Interaction 272 13.4.1 Point-to-Point Security 272 13.4.2 End-to-End Security 274 13.4.3 User Authentication and Authorization 276 13.4.4 Electronic Payment Systems 278 13.5 Client Security Issues 279 13.5.1 Preserving Privacy 279 13.5.2 Mobile Code Security 281 13.5.3 Phishing and Web Spoofing 282 13.5.4 Desktop Security 283 13.6 Service Provider Security Issues 285 13.6.1 Cross-Site Scripting 285 13.6.2 SQL Injection 287 13.6.3 Security of CGI Programs 289 13.6.4 Service Availability 290 13.6.5 Host Security 291 13.7 Outlook 292 14 The Semantic Web – The Network of Meanings in the Network of Documents 293Wernher Behrendt, Nitin Arora 14.1 Fundamentals of the Semantic Web 293 14.1.1 The Role of Software Agents 294 14.1.2 The Role of Semantic Markup 296 14.1.3 The Role of Ontologies 297 14.2 Technological Concepts 298 14.2.1 Agents According to the FIPA Standard 298 14.2.2 Ontologies 300 14.2.3 Semantic Markup on the Web 303 14.3 Specifics of Semantic Web Applications 308 14.3.1 Semantic Markup 308 14.3.2 Agents 309 14.3.3 Ontologies 309 14.3.4 Semantic Web Services 310 14.3.5 Integration into Web Engineering 313 14.4 Tools 314 14.5 Outlook 315 Glossary 317 Author Biographies 329 Bibliography 337 Credits 357 Index 359

Read more less

Book SynopsisA hands-on guide to testing techniques that deliver reliable software and systems Testing even a simple system can quickly turn into a potentially infinite task. Faced with tight costs and schedules, testers need to have a toolkit of practical techniques combined with hands-on experience and the right strategies in order to complete a successful project. World-renowned testing expert Rex Black provides you with the proven methods and concepts that test professionals must know. He presents you with the fundamental techniques for testing and clearly shows you how to select and apply successful strategies to test a system with budget and time constraints. Black begins by discussing the goals and tactics of effective and efficient testing. Next, he lays the foundation of his technique for risk-based testing, explaining how to analyze, prioritize, and document risks to the quality of the system using both informal and formal techniques. He then clearly describes howTable of ContentsAcknowledgments. Introduction. Part I Goals, Strategies, and Tactics. Chapter 1 What Does It Mean to Be Pragmatic? What Do Effective and Efficient Mean? What Effects Do You Want? What Is the Right Level of Efficiency? Avoiding Redundancy. Reducing Cost. What Software Testing Isn’t…But Is Often Thought to Be. Five Phases of a Tester’s Mental Life. Other Founding Views on Testing. Testing as a Form of Quality Risk Management. So What Is the Test Team All About? What Does “Quality” Mean to You? Chapter 2 Triangle Test Exercise. Exercise: The Triangle Test. Your Solution for the Triangle Test. Your Solution for the Triangle Test (Continued). Author’s Triangle Test Solution. Chapter 3 Aligning Testing with the Project. Why Do Organizations Test? Perspectives on Testing. Testing in Context. Common Test Phases and Objectives. Testing Throughout the Organization. The V Model. Evolutionary and Incremental Models. The Spiral Model. Regrettably Common Model: Code and Fix. Testing Maintenance Releases. System Integration. Hardware/Software Development. The Test Process. Chapter 4 Understanding Test Strategies, Tactics, and Design. Aligning Mission, Strategies, and Tactics. Analytical Test Strategies. Model-Based Test Strategies. Methodical Test Strategies. Process-Oriented Test Strategies. Dynamic Test Strategies. Philosophical Test Strategies. Regression. Regression Strategy 1: Repeat All Tests. Regression Strategy 2: Repeat Some Tests. Three Other Regression Strategies. Tactics: Categories of Testing Techniques. Strategic and Tactical Considerations. The Test System. Classic Principles for Test Design. Phases of Test Development. Synopsis of Test Strategies, Tactics, and Design. Part II Risk-Based Testing. Chapter 5 Understanding Risks to System Quality. Categories of Quality Risks. Functionality. Performance and Reliability. Stress, Capacity, and Volume. States. Transactions. Installation and Deinstallation. Operations. Maintenance and Maintainability. Regression. Usability and User Interface. Data Quality. Error and Disaster Handling and Recovery. Date and Time Handling. Localization. Configuration and Compatibility. Networked, Internetworked, and Distributed. Standards and Regulatory Compliance. Security. Timing and Coordination. Documentation. Can You Think of Other Quality Risks? Chapter 6 Aligning Testing with Quality Risks. Prioritize Risks to System Quality. Testing, Customer Usage, and System Configurations. Approaches for Quality Risks Analysis. Informal Quality Risk Analysis. Tips for Risk Analysis. Challenges of Risk Analysis. Chapter 7 Quality Risk Analysis Exercise. My Solution. Comments on My Solution. A Funny Thing Happened to Me on the Way to the Quality Risks… . Bonus Exercise. Template. My Solution. Comments on My Solution. Bonus Example: Grays and Blues Quality Risk Analysis. Part III Static Testing. Chapter 8 Reviews and Other Static Tests. Testing Requirements and Designs. Reviews Costs and Benefits. Types of Reviews. Reviews for Verification and Validation. Reviews as a Way to Improve the Process, Improve the System, and Reduce Costs. Answers to the Three Questions about Static Testing. Reviews as a Way to Achieve Consensus and Understanding. The Review Process, Roles, and Responsibilities. Deliverables and Ground Rules from Reviews. Common Requirements and Design Bugs. Reviewing (and Testing) Documentation. Other Static Tests. Chapter 9 Review Exercise. Reviews. Your Solution. My Solution. Comments on My Solution. Bonus Exercise: Reviewing Triangle Requirements Title Page. Triangle Requirements Review Using Wiegers’s List. The Requirements Bugs You Found. My Solution: Requirements Bugs. Comments on My Solution. Part IV Behavioral Testing. Chapter 10 Equivalence Classes and Boundary Values. Equivalence Partitioning. Boundary Value Analysis. Integer. Real Numbers. Character and String. Date. Time. Currency. Beyond Functional Classes and Boundaries. Chapter 11 Equivalence Classes and Boundary Values Exercise. Functional Boundaries and Classes. My Solution and Comments. Nonfunctional Boundaries and Classes. Omninet Marketing Requirements Document (v0.3). Omninet System Requirements Document (v0.2). Chapter 12 Use Cases, Live Data, and Decision Tables. Use Cases and Scenario Tests. Nouns and Verbs, Adjectives and Adverbs. Live Data and Customer Tests. Decision Tables. Chapter 13 Decision Table Exercise. Decision Table Tests. My Solution and Comments. Decision Tables and Boundary Values. My Solution and Comments. Building a Decision Table for Testing. My Solution and Comments. Chapter 14 State Transition Diagrams. Describing Systems with States Using State Transition Diagrams. State Tables. Printer Server State Transition Diagram. Chapter 15 State Transition Diagram Exercise. Kiosk States. My Solution and Comments. ATM State Models. My Solution and Comments. Grays and Blues and State Transition Diagrams. My Solution and Comments. Chapter 16 Domain Testing. Combinatorial Explosions. A Domain Example Using Frequent-Flyer Programs. Possible Domain Test Values. An Aerospace Example. When Domain Rules Change. Domain Analysis Summary. Complex Domain Testing Example. A General Rule for Complex Domains. Chapter 17 Domain Testing Exercise. My Solution and Comments. Chapter 18 Orthogonal Arrays and All Pairs. Combinatorial Explosions. Orthogonal Arrays and All-Pairs Tables. Two Orthogonal Arrays. Selecting an Orthogonal Array. Applying Orthogonal Arrays to a Complicated Real-World Example. All-Pairs Tables. Other Thoughts on Configuration Testing. Chapter 19 Orthogonal Arrays Exercise. My Solution and Comments. Chapter 20 Reactive Testing. General Facts about Reactive Tests. Error Guessing, Attacks, and Bug Taxonomies. Bug Hunting. Exploratory Tests. Checklists. Other Sources of Inspiration for Reactive Testing. Advantages and Disadvantages. A Case Study of Exploratory Testing. Part V Structural Testing. Chapter 21 Control-Flow Testing. Code Coverage. McCabe Cyclomatic Complexity. Chapter 22 Control-Flow Testing Exercise. My Solution and Comments. Chapter 23 Data-Flow Testing. Chapter 24 Data-Flow Testing Exercise. My Solutions and Comments. Chapter 25 Integration Testing. Drivers and Stubs. Integration Techniques. Backbone Integration. McCabe Basis Paths for Integration. Enhanced Hex Converter Program. Call Flow. Chapter 26 Integration Basis Test Exercise. My Solution and Comments. Part VI Appendices. Appendix A Omninet: The Internet Everywhere Marketing Requirements Document. 1 Scope. 1.1 Terms, Acronyms, and Abbreviations. 1.2 Applicable Documents. 2 Required release date. 3 Description of requirements. 3.1 General technical requirements. 3.1.1 Welcome. 3.1.2 Payment. 3.1.3 Internet Browser. 3.1.4 Performance. 3.1.5 Localization. 3.1.6 Content Control. 3.1.7 Session Termination. 3.1.8 Confidentiality. 3.2 Administration. 3.2.1 Software Updates. 3.2.2 View Kiosks. 3.2.3 View Users. 3.2.4 Modify User. 3.2.5 Terminate User. Appendix B Omninet: The Internet Everywhere System Requirements Document. Functionality System Requirements. Reliability System Requirements. Usability System Requirements. Efficiency System Requirements. Maintainability System Requirements. Portability System Requirements. Design Models. Omninet System Architecture. Payment Processing Decision Table. Kiosk Module Flow. Kiosk State-Transition Diagram. Kiosk State-Transition Table. Kiosk OS/Browser/Connection Speed Configuration Orthogonal Array. Appendix C Bibliography and Other Recommended Readings. RBCS Company Profile. Index.

Read more less

Book SynopsisThe book is organized around basic principles of software project management: planning and estimating, measuring and controlling, leading and communicating, and managing risk. Introduces software development methods, from traditional (hacking, requirements to code, and waterfall) to iterative (incremental build, evolutionary, agile, and spiral).Trade Review"This book is readable, informative, and well organized.... The material presented is up to date with respect to documents that were published at the time the book was written." (Computing Reviews, May 15, 2009) "Mark it up and keep it on your bookshelf, and be sure to reference it frequently." (Computing Reviews, April 28, 2008)Table of ContentsPreface xv 1 Introduction 1 1.1 Introduction to Software Project Management, 1 1.2 Objectives of This Chapter, 2 1.3 Why Managing and Leading Software Projects Is Difficult, 2 1.4 The Nature of Project Constraints, 9 1.5 A Workfl ow Model for Managing Software Projects, 13 1.6 Organizational Structures for Software Projects, 16 1.7 Organizing the Project Team, 19 1.8 Maintaining the Project Vision and the Product Vision, 21 1.9 Frameworks, Standards, and Guidelines, 22 1.10 Key Points of Chapter 1, 23 1.11 Overview of the Text, 23 2 Process Models for Software Development 39 2.1 Introduction to Process Models, 39 2.2 Objectives of This Chapter, 42 2.3 A Development-Process Framework, 42 2.4 Tailoring the System Engineering Framework for Software-Only Projects, 52 2.5 Traditional Software Development Process Models, 54 2.6 Iterative-Development Process Models, 58 2.7 Designing an Iterative-Development Process, 72 2.8 The Role of Prototyping in Software Development, 74 2.9 Key Points of Chapter 2, 75 3 Establishing Project Foundations 85 3.1 Introduction to Project Foundations, 85 3.2 Objectives of This Chapter, 86 3.3 Software Acquisition, 87 3.4 Requirements Engineering, 88 3.5 Process Foundations, 109 3.6 Key Points of Chapter 3, 112 4 Plans and Planning 119 4.1 Introduction to the Planning Process, 119 4.2 Objectives of This Chapter, 120 4.3 The Planning Process, 121 4.4 The CMMI-DEV-v1.2 Process Area for Project Planning, 125 4.5 A Minimal Project Plan, 129 4.6 A Template for Software Project Management Plans, 130 4.7 Techniques for Preparing a Project Plan, 150 4.8 Key Points of Chapter 4, 154 5 Project Planning Techniques 173 5.1 Introduction to Project Planning Techniques, 173 5.2 Objectives of This Chapter, 174 5.3 The Scope of Planning, 175 5.4 Rolling-Wave Planning, 175 5.5 Scenarios for Developing a Project Plan, 176 5.6 Developing the Architecture Decomposition View and the Work Breakdown Structure, 177 5.7 Guidelines for Designing Work Breakdown Structures, 182 5.8 Developing the Project Schedule, 188 5.9 Developing Resource Profiles, 193 5.10 Resource-Gantt Charts, 199 5.11 Estimating Project Effort, Cost, and Schedule, 199 5.12 Key Points of Chapter 5, 201 6 Estimation Techniques 207 6.1 Introduction to Estimation Techniques, 207 6.2 Objectives of This Chapter, 208 6.3 Fundamental Principles of Estimation, 209 6.4 Designing to Project Constraints, 214 6.5 Estimating Product Size, 216 6.6 Pragmatic Estimation Techniques, 224 6.7 Theory-Based Estimation Models, 230 6.8 Regression-Based Estimation Models, 234 6.9 Estimation Tools, 249 6.10 Estimating Life Cycle Resources, Effort, and Cost, 249 6.11 An Estimation Procedure, 251 6.12 A Template for Recording Estimates, 256 6.13 Key Points of Chapter 6, 258 7 Measuring and Controlling Work Products 265 7.1 Introduction to Measuring and Controlling Work Products, 265 7.2 Objectives of This Chapter, 268 7.3 Why Measure?, 268 7.4 What Should Be Measured?, 269 7.5 Measures and Measurement, 270 7.6 Measuring Product Attributes, 276 7.7 Measuring and Analyzing Software Defects, 301 7.8 Choosing Product Measures, 309 7.9 Practical Software Measurement, 311 7.10 Guidelines for Measuring and Controlling Work Products, 311 7.11 Rolling-Wave Adjustments Based on Product Measures and Measurement, 313 7.12 Key Points of Chapter 7, 313 8 Measuring and Controlling Work Processes 333 8.1 Introduction to Measuring and Controlling Work Processes, 333 8.2 Objectives of This Chapter, 336 8.3 Measuring and Analyzing Effort, 336 8.4 Measuring and Analyzing Rework Effort, 339 8.5 Tracking Effort, Schedule, and Cost; Estimating Future Status, 342 8.6 Earned Value Reporting, 347 8.7 Project Control Panel, 353 8.8 Key Points of Chapter 8, 357 9 Managing Project Risk 363 9.1 Introduction to Managing Project Risk, 363 9.2 Objectives of This Chapter, 365 9.3 An Overview of Risk Management for Software Projects, 366 9.4 Conventional Project Management Techniques, 369 9.5 Risk Identifi cation Techniques, 373 9.6 Risk Analysis and Prioritization, 381 9.7 Risk Mitigation Strategies, 382 9.8 Top-N Risk Tracking and Risk Registers, 388 9.9 Controlling the Risk Management Process, 392 9.10 Crisis Management, 394 9.11 Risk Management at the Organizational Level, 395 9.12 Joint Risk Management, 396 9.13 Key Points of Chapter 9, 396 10 Teams, Teamwork, Motivation, Leadership, and Communication 407 10.1 Introduction, 407 10.2 Objectives of This Chapter, 408 10.3 Managing versus Leading, 408 10.4 Teams and Teamwork, 410 10.5 Maintaining Morale and Motivation, 417 10.6 Can't versus Won't, 418 10.7 Personality Styles, 420 10.8 The Five-Layer Behavioral Model, 427 10.9 Key Points of Chapter 10, 430 11 Organizational Issues 439 11.1 Introduction to Organizational Issues, 439 11.2 Objectives of This Chapter, 440 11.3 The Infl uence of Corporate Culture, 441 11.4 Assessing and Nurturing Intellectual Capital, 443 11.5 Key Personnel Roles, 444 11.6 Fifteen Guidelines for Organizing and Leading Software Engineering Teams, 449 11.6.3 Summary of the Guidelines, 463 11.7 Key Points of Chapter 11, 464 Glossary of Terms 471 Guidance for Term Projects 481 Index 487

Read more less

Book SynopsisFifty years after the birth of corporate computing, IT today is still characterized by 50-70% project failure rates. Which is pretty scary when you come to think of it: either a goblin has cast a spell on a whole profession or that profession is doing something fundamentally wrong. IT Success! challenges the widespread assumption that an IT department is like a building contractor whose project managers, architects and engineers (all construction industry terms) are supposed to deliver systems on schedule, within budget and to spec. Michael Gentle explains why this is not possible, and turns conventional wisdom on its head by showing that: you cannot define an IT project in terms of contractual budgets and schedules anything can change during the life of a project what is eventually delivered can never be what is actually needed He proposes a new model for IT in which the traditional client/vendor relationship, wTrade Review"...a clever synthesis of enlightened IT project management thinking over the last few years." (Financial Times, Wednesday 21st November 2007)Table of ContentsIntroduction ix Acknowledgements xiii Abbreviations xvii Part I Blinded by Specs 1 1 In Search of the Fundamentals 3 The more things change, the more they stay the same 3 A worldwide phenomenon 4 How the traditional IT model started 5 The construction industry trap 6 The free lunch trap 7 Houses of ill repute 8 A business problem rather than an IT problem 10 IT and original sin 12 No sacred cows 12 2 IT 101 – The Basics for Non-Specialists 15 The process breakdown for traditional IT activities 15 The process breakdown for business (i.e non-IT) activities 16 The fundamental difference between IT and non-IT activities 18 'That's not my problem!' – process ownership and behaviour 19 3 The Flaws of the Traditional Model 21 The unintended consequences of the waterfall method 21 In search of a pizza parlour manager 22 Who provides process expertise – client or vendor? 22 When standard client–vendor relationships are possible 24 When standard client–vendor relationships pose problems 25 Is a standard client–vendor relationship possible for IT? 26 The 'Statement of Requirements' (SoR) trap 26 A poor to non-existent pricing model 28 Should IT be run like a business (i.e an ESP)? 30 The limits of outsourcing 31 Current IT organizational trends 32 The ultimate litmus test to determine one's business model 33 What model would be appropriate for IT? 34 Part II Building a New Business Model for It 35 4 Managing Demand 37 Managing demand – traditional model 37 Managing demand – new model 39 Capturing demand and identifying opportunities 41 Prioritizing and approving demand 43 Planning approved demand 49 Linking demand to resource capability 49 Approving demand based on portfolios 50 The missing component in Project Portfolio Management 53 Business cases are in the eye of the beholder 54 Building the IT plan and budget 55 Demand from a customer perspective 56 Shaking off the chains of the construction industry 56 Funding approved demand 58 Roles and responsibilities 59 5 Managing Supply 61 Managing supply - traditional model 61 Managing supply - new model 63 Iterative development in practice 65 Why prototyping has never become mainstream 74 Is prototyping the answer to everything? 78 Project critical success factors 79 Maintenance - letting go of the M-word 79 Delivery and implementation 81 Service and support 81 6 Monitoring Costs and Benefits 83 Monitoring costs and benefits for traditional IT activities 83 Monitoring costs and benefits for business (non-IT) activities 84 Monitoring costs and benefits – new model 85 Ownership and accountability for costs and benefits 86 Cost–benefit analysis during the life of a project 87 It is normal for costs and benefits to change! 88 Portfolio performance monitoring 88 Cost–benefit analysis after project delivery 89 7 Financials 91 The main categories of IT costs 91 Ownership of IT costs for the regulation of supply and demand 92 Who has the final say for IT investments? 92 Allocations vs cross-charging 93 Capturing costs for allocations and cross-charging 94 Benefits as part of the P&L and annual planning 95 Ongoing cost–benefit analysis for applications 96 Reducing application lifetime costs 100 The limits of financial ROI when applied to IT 102 Part III the New Model in Practice 105 8 Players, Roles and Responsibilities 107 Players, roles and responsibilities – the business 107 Players, roles and responsibilities – IT 111 The new business–IT relationship 112 The changing role of the business analyst 113 The changing role of the developer 113 Towards the merging of the developer and analyst roles? 114 The changing role of the project manager 115 The changing role of the operations department 116 What role for PMOs? 117 The role of External Service Providers (ESPs) 119 9 Getting Started 121 The business challenge 121 The IT challenge 122 Where to start 123 How to start – from checklist to action plan 124 From the status quo to first results 128 From first results to asset management 133 The role of best-practice methodologies 136 How consulting companies can help 138 How tools can help 139 The costs of moving to the new model 140 In closing – addressing the three fundamental questions 142 Further reading 143 10 Case Study 145 The company 145 The business problem 146 The project context 146 Building an IT–business partnership 147 Kicking off the project 148 Feasibility study and defining a solution 149 Building the business case 150 Project approach 151 Product evaluation – buy or build decision 151 Building a prototype 152 Results 154 Timescales 155 Three months later 155 One year later 156 Two years later 156 Main lessons learnt (on the plus side) 156 Main lessons learnt (on the minus side) 157 Comments with respect to the new model 157 Reader feedback 158 Index 159

Read more less

Book SynopsisThe first volume of the POSA pattern series introduced a broad-spectrum of general-purpose patterns in software design and architecture. The second narrowed the focus to fundamental patterns for building sophisticated concurrent and networked software systems and applications.Table of ContentsForeword by Frank Buschmann. Foreword by Steve Vinoski. About This Book. About The Authors. Intended Audience. Structure of the Book. Guide to the Reader. Acknowledgements. About The Authors. 1. Introduction. 1.1 Overview of Resource Management. 1.2 Scope of Resource Management. 1.3 Usage of Patterns. 1.4 Patterns in Resource Management. 1.5 Related Work. 1.6 Pattern Form. 2. Resource Acquisition. Lookup. Lazy Acquisition. Eager Acquisition. Partial Acquisition. 3. Resource Lifecycle. Caching. Pooling. Coordinator. Resource Lifecycle Manager. 4. Resource Release. Leasing. Evictor. 5. Guidelines for Applying Resource Management. 6. Case Study: Ad Hoc Networking. 6.1 Overview. 6.2 Motivation. 6.3 Solution. 7. Case Study: Mobile Network. 7.1 Overview. 7.2 Motivation. 7.3 Solution. 8. The Past, Present, and Future of Patterns. 8.1 The Past Four Years at a Glance. 8.2 Where Patterns are Now. 8.3 Where Will Patterns Go Tomorrow? 8.4 A Brief Note about the Future of Patterns. 9. Concluding Remarks. Referenced Patterns. Notations. References. Acknowledgements. Index of Patterns. Index.

Read more less

Book Synopsis? C++ is one of the best languages for the development of financial engineering and instrument pricing applications. ? This book applies C++ to the design and implementation of classes, libraries and latest applications for option and derivative pricing models.Table of ContentsCHAPTER 1 A Tour of C++ and Environs 1 1.1 Introduction and Objectives 1 1.2 What is C++? 1 1.3 C++ as a Multiparadigm Programming Language 2 1.4 The Structure and Contents of this Book: Overview 4 1.5 A Tour of C++11: Black–Scholes and Environs 6 1.6 Parallel Programming in C++ and Parallel C++ Libraries 12 1.7 Writing C++ Applications; Where and How to Start? 14 1.8 For whom is this Book Intended? 16 1.9 Next-Generation Design and Design Patterns in C++ 16 1.10 Some Useful Guidelines and Developer Folklore 17 1.11 About the Author 18 1.12 The Source Code and Getting the Source Code 19 CHAPTER 2 New and Improved C++ Fundamentals 21 2.1 Introduction and Objectives 21 2.2 The C++ Smart Pointers 21 2.3 Using Smart Pointers in Code 23 2.4 Extended Examples of Smart Pointers Usage 30 2.5 Move Semantics and Rvalue References 34 2.6 Other Bits and Pieces: Usability Enhancements 39 2.7 Summary and Conclusions 52 2.8 Exercises and Projects 52 CHAPTER 3 Modelling Functions in C++ 59 3.1 Introduction and Objectives 59 3.2 Analysing and Classifying Functions 60 3.3 New Functionality in C++: std::function<> 64 3.4 New Functionality in C++: Lambda Functions and Lambda Expressions 65 3.5 Callable Objects 69 3.6 Function Adapters and Binders 70 3.7 Application Areas 75 3.8 An Example: Strategy Pattern New Style 75 3.9 Migrating from Traditional Object-Oriented Solutions: Numerical Quadrature 78 3.10 Summary and Conclusions 81 3.11 Exercises and Projects 82 CHAPTER 4 Advanced C++ Template Programming 89 4.1 Introduction and Objectives 89 4.2 Preliminaries 91 4.3 decltype Specifier 94 4.4 Life Before and After decltype 101 4.5 std::result_of and SFINAE 106 4.6 std::enable_if 108 4.7 Boost enable_if 112 4.8 std::decay()Trait 114 4.9 A Small Application: Quantities and Units 115 4.10 Conclusions and Summary 118 4.11 Exercises and Projects 118 CHAPTER 5 Tuples in C++ and their Applications 123 5.1 Introduction and Objectives 123 5.2 An std:pair Refresher and New Extensions 123 5.3 Mathematical and Computer Science Background 128 5.4 Tuple Fundamentals and Simple Examples 130 5.5 Advanced Tuples 130 5.6 Using Tuples in Code 133 5.7 Other Related Libraries 138 5.8 Tuples and Run-Time Efficiency 140 5.9 Advantages and Applications of Tuples 142 5.10 Summary and Conclusions 143 5.11 Exercises and Projects 143 CHAPTER 6 Type Traits, Advanced Lambdas and Multiparadigm Design in C++ 147 6.1 Introduction and Objectives 147 6.2 Some Building Blocks 149 6.3 C++ Type Traits 150 6.4 Initial Examples of Type Traits 158 6.5 Generic Lambdas 161 6.6 How Useful will Generic Lambda Functions be in the Future? 164 6.7 Generalised Lambda Capture 171 6.7.1 Living Without Generalised Lambda Capture 173 6.8 Application to Stochastic Differential Equations 174 6.9 Emerging Multiparadigm Design Patterns: Summary 178 6.10 Summary and Conclusions 179 6.11 Exercises and Projects 179 CHAPTER 7 Multiparadigm Design in C++ 185 7.1 Introduction and Objectives 185 7.2 Modelling and Design 185 7.3 Low-Level C++ Design of Classes 190 7.4 Shades of Polymorphism 199 7.5 Is there More to Life than Inheritance? 206 7.6 An Introduction to Object-Oriented Software Metrics 207 7.7 Summary and Conclusions 210 7.8 Exercises and Projects 210 CHAPTER 8 C++ Numerics, IEEE 754 and Boost C++ Multiprecision 215 8.1 Introduction and Objectives 215 8.2 Floating-Point Decomposition Functions in C++ 219 8.3 A Tour of std::numeric_limits 221 8.4 An Introduction to Error Analysis 223 8.5 Example: Numerical Quadrature 224 8.6 Other Useful Mathematical Functions in C++ 228 8.7 Creating C++ Libraries 231 8.8 Summary and Conclusions 239 8.9 Exercises and Projects 239 CHAPTER 9 An Introduction to Unified Software Design 245 9.1 Introduction and Objectives 245 9.1.1 Future Predictions and Expectations 246 9.2 Background 247 9.3 System Scoping and Initial Decomposition 251 9.4 Checklist and Looking Back 259 9.5 Variants of the Software Process: Policy-Based Design 260 9.6 Using Policy-Based Design for the DVM Problem 268 9.7 Advantages of Uniform Design Approach 273 9.8 Summary and Conclusions 274 9.9 Exercises and Projects 275 CHAPTER 10 New Data Types, Containers and Algorithms in C++ and Boost C++ Libraries 283 10.1 Introduction and Objectives 283 10.2 Overview of New Features 283 10.3 C++ std::bitset and Boost Dynamic Bitset Library 284 10.4 Chrono Library 288 10.5 Boost Date and Time 301 10.6 Forwards Lists and Compile-Time Arrays 306 10.7 Applications of Boost.Array 311 10.8 Boost uBLAS (Matrix Library) 313 10.9 Vectors 316 10.10 Matrices 318 10.11 Applying uBLAS: Solving Linear Systems of Equations 322 10.12 Summary and Conclusions 330 10.13 Exercises and Projects 331 CHAPTER 11 Lattice Models Fundamental Data Structures and Algorithms 333 11.1 Introduction and Objectives 333 11.2 Background and Current Approaches to Lattice Modelling 334 11.3 New Requirements and Use Cases 335 11.4 A New Design Approach: A Layered Approach 335 11.5 Initial ‘101’ Examples of Option Pricing 347 11.6 Advantages of Software Layering 349 11.7 Improving Efficiency and Reliability 352 11.8 Merging Lattices 355 11.9 Summary and Conclusions 357 11.10 Exercises and Projects 357 CHAPTER 12 Lattice Models Applications to Computational Finance 367 12.1 Introduction and Objectives 367 12.2 Stress Testing the Lattice Data Structures 368 12.3 Option Pricing Using Bernoulli Paths 372 12.4 Binomial Model for Assets with Dividends 374 12.5 Computing Option Sensitivities 377 12.6 (Quick) Numerical Analysis of the Binomial Method 379 12.7 Richardson Extrapolation with Binomial Lattices 382 12.8 Two-Dimensional Binomial Method 382 12.9 Trinomial Model of the Asset Price 384 12.10 Stability and Convergence of the Trinomial Method 385 12.11 Explicit Finite Difference Method 386 12.12 Summary and Conclusions 389 12.13 Exercises and Projects 389 CHAPTER 13 Numerical Linear Algebra: Tridiagonal Systems and Applications 395 13.1 Introduction and Objectives 395 13.2 Solving Tridiagonal Matrix Systems 395 13.3 The Crank-Nicolson and Theta Methods 406 13.4 The ADE Method for the Impatient 411 13.5 Cubic Spline Interpolation 415 13.6 Some Handy Utilities 427 13.7 Summary and Conclusions 428 13.8 Exercises and Projects 429 CHAPTER 14 Data Visualisation in Excel 433 14.1 Introduction and Objectives 433 14.2 The Structure of Excel-Related Objects 433 14.3 Sanity Check: Is the Excel Infrastructure Up and Running? 435 14.4 ExcelDriver and Matrices 437 14.5 ExcelDriver and Vectors 444 14.6 Path Generation for Stochastic Differential Equations 448 14.7 Summary and Conclusions 459 14.8 Exercises and Projects 459 14.9 Appendix: COM Architecture Overview 463 14.10 An Example 468 14.11 Virtual Function Tables 471 14.12 Differences between COM and Object-Oriented Paradigm 473 14.13 Initialising the COM Library 474 CHAPTER 15 Univariate Statistical Distributions 475 15.1 Introduction, Goals and Objectives 475 15.2 The Error Function and Its Universality 475 15.3 One-Factor Plain Options 478 15.4 Option Sensitivities and Surfaces 488 15.5 Automating Data Generation 491 15.6 Introduction to Statistical Distributions and Functions 499 15.7 Advanced Distributions 504 15.8 Summary and Conclusions 511 15.9 Exercises and Projects 511 CHAPTER 16 Bivariate Statistical Distributions and Two-Asset Option Pricing 515 16.1 Introduction and Objectives 515 16.2 Computing Integrals Using PDEs 516 16.3 The Drezner Algorithm 521 16.4 The Genz Algorithm and the West/Quantlib Implementations 521 16.5 Abramowitz and Stegun Approximation 525 16.6 Performance Testing 528 16.7 Gauss–Legendre Integration 529 16.8 Applications to Two-Asset Pricing 531 16.9 Trivariate Normal Distribution 536 16.10 Chooser Options 543 16.11 Conclusions and Summary 545 16.12 Exercises and Projects 546 CHAPTER 17 STL Algorithms in Detail 551 17.1 Introduction and Objectives 551 17.2 Binders and std::bind 554 17.3 Non-modifying Algorithms 557 17.4 Modifying Algorithms 567 17.5 Compile-Time Arrays 575 17.6 Summary and Conclusions 576 17.7 Exercises and Projects 576 17.8 Appendix: Review of STL Containers and Complexity Analysis 583 CHAPTER 18 STL Algorithms Part II 589 18.1 Introduction and Objectives 589 18.2 Mutating Algorithms 589 18.3 Numeric Algorithms 597 18.4 Sorting Algorithms 601 18.5 Sorted-Range Algorithms 604 18.5.5 Merging 608 18.6 Auxiliary Iterator Functions 609 18.7 Needle in a Haystack: Finding the Right STL Algorithm 612 18.8 Applications to Computational Finance 613 18.9 Advantages of STL Algorithms 613 18.10 Summary and Conclusions 614 18.11 Exercises and Projects 614 CHAPTER 19 An Introduction to Optimisation and the Solution of Nonlinear Equations 617 19.1 Introduction and Objectives 617 19.2 Mathematical and Numerical Background 618 19.3 Sequential Search Methods 619 19.4 Solutions of Nonlinear Equations 620 19.5 Fixed-Point Iteration 622 19.6 Aitken’s Acceleration Process 623 19.7 Software Framework 623 19.8 Implied Volatility 632 19.9 Solvers in the Boost C++ Libraries 632 19.10 Summary and Conclusions 633 19.11 Exercises and Projects 633 19.12 Appendix: The Banach Fixed-Point Theorem 636 CHAPTER 20 The Finite Difference Method for PDEs: Mathematical Background 641 20.1 Introduction and Objectives 641 20.2 General Convection–Diffusion–Reaction Equations and Black–Scholes PDE 641 20.3 PDE Preprocessing 64520.3.2 Reduction of PDE to Conservative Form 646 20.4 Maximum Principles for Parabolic PDEs 649 20.5 The Fichera Theory 650 20.6 Finite Difference Schemes: Properties and Requirements 654 20.7 Example: A Linear Two-Point Boundary Value Problem 655 20.8 Exponentially Fitted Schemes for Time-Dependent PDEs 659 20.9 Richardson Extrapolation 663 20.10 Summary and Conclusions 665 20.11 Exercises and Projects 666 CHAPTER 21 Software Framework for One-Factor Option Models 669 21.1 Introduction and Objectives 669 21.2 A Software Framework: Architecture and Context 669 21.3 Modelling PDEs and Finite Difference Schemes: What is Supported? 670 21.4 Several Versions of Alternating Direction Explicit 671 21.5 A Software Framework: Detailed Design and Implementation 673 21.6 C++ Code for PDE Classes 674 21.7 C++ Code for FDM Classes 679 21.8 Examples and Test Cases 690 21.9 Summary and Conclusions 693 21.10 Exercises and Projects 694 CHAPTER 22 Extending the Software Framework 701 22.1 Introduction and Objectives 701 22.2 Spline Interpolation of Option Values 701 22.3 Numerical Differentiation Foundations 704 22.4 Numerical Greeks 710 22.5 Constant Elasticity of Variance Model 715 22.6 Using Software Design (GOF) Patterns 715 22.7 Multiparadigm Design Patterns 720 22.8 Summary and Conclusions 721 22.9 Exercises and Projects 721 CHAPTER 23A PDE Software Framework in C++11 for a Class of Path-Dependent Options 727 23.1 Introduction and Objectives 727 23.2 Modelling PDEs and Initial Boundary Value Problems in the Functional Programming Style 728 23.3 PDE Preprocessing 731 23.4 The Anchoring PDE 732 23.5 ADE for Anchoring PDE 739 23.6 Useful Utilities 746 23.7 Accuracy and Performance 748 23.8 Summary and Conclusions 750 23.9 Exercises and Projects 751 CHAPTER 24 Ordinary Differential Equations and their Numerical Approximation 755 24.1 Introduction and Objectives 755 24.2 What is an ODE? 755 24.3 Classifying ODEs 756 24.4 A Palette of Model ODEs 757 24.5 Existence and Uniqueness Results 760 24.6 Overview of Numerical Methods for ODEs: The Big Picture 763 24.7 Creating ODE Solvers in C++ 770 24.8 Summary and Conclusions 776 24.9 Exercises and Projects 776 24.10 Appendix 778 CHAPTER 25 Advanced Ordinary Differential Equations and Method of Lines 781 25.1 Introduction and Objectives 781 25.2 An Introduction to the Boost Odeint Library 782 25.3 Systems of Stiff and Non-stiff Equations 791 25.4 Matrix Differential Equations 796 25.5 The Method of Lines: What is it and what are its Advantages? 799 25.6 Initial Foray in Computational Finance: MOL for One-Factor Black-Scholes PDE 801 25.7 Barrier Options 806 25.8 Using Exponential Fitting of Barrier Options 808 25.9 Summary and Conclusions 808 25.10 Exercises and Projects 809 CHAPTER 26 Random Number Generation and Distributions 819 26.1 Introduction and Objectives 819 26.2 What is a Random Number Generator? 820 26.3 What is a Distribution? 821 26.4 Some Initial Examples 825 26.5 Engines in Detail 827 26.6 Distributions in C++: The List 830 26.7 Back to the Future: C-Style Pseudo-Random Number Generation 831 26.8 Cryptographic Generators 833 26.9 Matrix Decomposition Methods 833 26.10 Generating Random Numbers 845 26.11 Summary and Conclusions 848 26.12 Exercises and Projects 849 CHAPTER 27 Microsoft .Net, C# and C++11 Interoperability 853 27.1 Introduction and Objectives 853 27.2 The Big Picture 854 27.3 Types 858 27.4 Memory Management 859 27.5 An Introduction to Native Classes 861 27.6 Interfaces and Abstract Classes 861 27.7 Use Case: C++/CLI as ‘Main Language’ 862 27.8 Use Case: Creating Proxies, Adapters and Wrappers for Legacy C++ Applications 864 27.8.1 Alternative: SWIG (Simplified Wrapper and Interface Generator) 871 27.9 ‘Back to the Future’ Use Case: Calling C# Code from C++11 872 27.10 Modelling Event-Driven Applications with Delegates 876 27.11 Use Case: Interfacing with Legacy Code 886 27.12 Assemblies and Namespaces for C++/CLI 889 27.13 Summary and Conclusions 895 27.14 Exercises and Projects 896 CHAPTER 28 C++ Concurrency, Part I Threads 899 28.1 Introduction and Objectives 899 28.2 Thread Fundamentals 900 28.3 Six Ways to Create a Thread 903 28.4 Intermezzo: Parallelising the Binomial Method 909 28.5 Atomics 916 28.6 Smart Pointers and the Thread-Safe Pointer Interface 924 28.7 Thread Synchronisation 926 28.8 When should we use Threads? 929 28.9 Summary and Conclusions 929 28.10 Exercises and Projects 930 CHAPTER 29 C++ Concurrency, Part II Tasks 935 29.1 Introduction and Objectives 935 29.2 Finding Concurrency: Motivation 936 29.3 Tasks and Task Decomposition 937 29.4 Futures and Promises 941 29.5 Shared Futures 945 29.6 Waiting on Tasks to Complete 948 29.7 Continuations and Futures in Boost 950 29.8 Pure Functions 952 29.9 Tasks versus Threads 953 29.10 Parallel Design Patterns 953 29.11 Summary and Conclusions 955 29.12 Quizzes, Exercises and Projects 955 CHAPTER 30 Parallel Patterns Language (PPL) 961 30.1 Introduction and Objectives 961 30.2 Parallel Algorithms 962 30.3 Partitioning Work 967 30.4 The Aggregation/Reduction Pattern in PPL 971 30.5 Concurrent Containers 977 30.6 An Introduction to the Asynchronous Agents Library and Event-Based Systems 978 30.7 A Design Plan to Implement a Framework Using Message Passing and Other Approaches 986 30.8 Summary and Conclusions 989 30.9 Exercises and Projects 990 CHAPTER 31 Monte Carlo Simulation, Part I 993 31.1 Introduction and Objectives 993 31.2 The Boost Parameters Library for the Impatient 995 31.3 Monte Carlo Version 1: The Monolith Program (‘Ball of Mud’) 1000 31.4 Policy-Based Design: Dynamic Polymorphism 1003 31.5 Policy-Based Design Approach: CRTP and Static Polymorphism 1011 31.6 Builders and their Subcontractors (Factory Method Pattern) 1013 31.7 Practical Issue: Structuring the Project Directory and File Contents 1014 31.8 Summary and Conclusions 1016 31.9 Exercises and Projects 1017 CHAPTER 32 Monte Carlo Simulation, Part II 1023 32.1 Introduction and Objectives 1023 32.2 Parallel Processing and Monte Carlo Simulation 1023 32.3 A Family of Predictor–Corrector Schemes 1033 32.4 An Example (CEV Model) 1038 32.5 Implementing the Monte Carlo Method Using the Asynchronous Agents Library 1041 32.6 Summary and Conclusions 1047 32.7 Exercises and Projects 1050 Appendix 1: Multiple-Precision Arithmetic 1053 Appendix 2: Computing Implied Volatility 1075 References 1109 Index 1117

Read more less

Book SynopsisSoftware testing is a critical stage in software development that ensures that a program meets required specifications and is free of bugs. In this handbook, Cem Kaner and James Bach, two of the world's leading testing experts help you avoid testing errors without the trial and error it normally takes to do so.Trade Review"If testing is something that is going to be an important part of your career buy this book and read it carefully." (CVu - Jnl of the Association C & C++ Users, February 2002) "...a real gem?for me, this book is one that I shall find useful?each and every test department should have several copies available...be prepared to be inspired, or at the very least to have your ideas challenged..." (Professional Tester, September 2002) "...a refreshing and enjoyable book?it will not be 'shelf-ware', but a well-used reference..." (Software Testing, Verification & Reliability, March 2003) "...will make fascinating reading?highly recommended..." (CVu, Dec 03)Table of ContentsLessons. Foreword. Preface. Acknowledgments. The Role of the Tester. Thinking Like a Tester. Testing Techniques. Bug Advocacy. Automating Testing. Documenting Testing. Interacting with Programmers. Managing the Testing Project. Managing the Testing Group. Your Career in Software Testing. Planning the Testing Strategy. Appendix: The Context-Driven Approach to Software Testing. Bibliography. Index.

Read more less

Book SynopsisPatterns are popular in software development and used to identify different types of procedures, designs, or codes that work. AntiPatterns are the exact opposite, targeting common errors and issues that can cause a project to fail. This book provides practical guidelines on detecting AntiPatterns and the refactored solutions that correct them.Table of ContentsINTRODUCTION TO ANTIPATTERNS. Introduction to Patterns and AntiPatterns. AntiPatterns Reference Model. Templates for Patterns and AntiPatterns. Advice for Using AntiPatterns. ANTIPATTERNS Software Development AntiPatterns. Software Architecture AntiPatterns. Software Project Management AntiPatterns. CONCLUSIONS AND RESOURCES. Appendices. Index.

Read more less