Software Engineering Books

Book SynopsisMike Cohn is the founder of Mountain Goat Software, a process and project management consultancy and training firm. With more than twenty years of experience, Mike has been a technology executive in companies ranging from start-ups to Fortune 40s, and is a founding member of the Agile Alliance. He frequently contributes to industry-related magazines and presents regularly at conferences. He is the author of User Stories Applied (Addison-Wesley, 2004).Table of Contents Foreword. Acknowledgments. Introduction. I: GETTING STARTED. 1: An Overview. What Is a User Story? Where Are the Details? “How Long Does It Have to Be?” The Customer Team. What Will the Process Be Like? Planning Releases and Iterations. What Are Acceptance Tests? Why Change? Summary. Questions. 2: Writing Stories. Independent. Negotiable. Valuable to Purchasers or Users. Estimatable. Small. Testable. Summary. Developer Responsibilities. Customer Responsibilities. Questions. 3: User Role Modeling. User Roles. Role Modeling Steps. Two Additional Techniques. What If I Have On-Site Users? Summary. Developer Responsibilities. Customer Responsibilities. Questions. 4: Gathering Stories. Elicitation and Capture Should Be Illicit. A Little Is Enough, or Is It? Techniques. User Interviews. Questionnaires. Observation. Story-Writing Workshops. Summary. Developer Responsibilities. Customer Responsibilities. Questions. 5: Working with User Proxies. The Users' Manager. A Development Manager. Salespersons. Domain Experts. The Marketing Group. Former Users. Customers. Trainers and Technical Support. Business or Systems Analysts. What to Do When Working with a User Proxy. Can You Do It Yourself? Constituting the Customer Team. Summary. Developer Responsibilities. Customer Responsibilities. Questions. 6: Acceptance Testing User Stories. Write Tests Before Coding. The Customer Specifies the Tests. Testing Is Part of the Process. How Many Tests Are Too Many? The Framework for Integrated Test. Types of Testing. Summary. Developer Responsibilities. Customer Responsibilities. Questions. 7: Guidelines for Good Stories. Start with Goal Stories. Slice the Cake. Write Closed Stories. Put Constraints on Cards. Size the Story to the Horizon. Keep the UI Out as Long as Possible. Some Things Aren't Stories. Include User Roles in the Stories. Write for One User. Write in Active Voice. Customer Writes. Don't Number Story Cards. Don't Forget the Purpose. Summary. Questions. II: ESTIMATING AND PLANNING. 8: Estimating User Stories. Story Points. Estimate as a Team. Estimating. Triangulate. Using Story Points. What If We Pair Program? Some Reminders. Summary. Developer Responsibilities. Customer Responsibilities. Questions. 9: Planning a Release. When Do We Want the Release? What Would You Like in It? Prioritizing the Stories. Mixed Priorities. Risky Stories. Prioritizing Infrastructural Needs. Selecting an Iteration Length. From Story Points to Expected Duration. The Initial Velocity. Creating the Release Plan. Summary. Developer Responsibilities. Customer Responsibilities. Questions. 10: Planning an Iteration. Iteration Planning Overview. Discussing the Stories. Disaggregating into Tasks. Accepting Responsibility. Estimate and Confirm. Summary. Developer Responsibilities. Customer Responsibilities. Questions. 11: Measuring and Monitoring Velocity. Measuring Velocity. Planned and Actual Velocity. Iteration Burndown Charts. Burndown Charts During an Iteration. Summary. Developer Responsibilities. Customer Responsibilities. Questions. III: FREQUENTLY DISCUSSED TOPICS. 12: What Stories Are Not. User Stories Aren't IEEE 830. User Stories Are Not Use Cases. User Stories Aren't Scenarios. Summary. Questions. 13: Why User Stories? Verbal Communication. User Stories Are Comprehensible. User Stories Are the Right Size for Planning. User Stories Work for Iterative Development. Stories Encourage Deferring Detail. Stories Support Opportunistic Development. User Stories Encourage Participatory Design. Stories Build Up Tacit Knowledge. Why Not Stories? Summary. Developer Responsibilities. Customer Responsibilities. Questions. 14: A Catalog of Story Smells. Stories Are Too Small. Interdependent Stories. Goldplating. Too Many Details. Including User Interface Detail Too Soon. Thinking Too Far Ahead. Splitting Too Many Stories. Customer Has Trouble Prioritizing. Customer Won't Write and Prioritize the Stories. Summary. Developer Responsibilities. Customer Responsibilities. Questions. 15: Using Stories with Scrum. Scrum Is Iterative and Incremental. The Basics of Scrum. The Scrum Team. The Product Backlog. The Sprint Planning Meeting. The Sprint Review Meeting. The Daily Scrum Meeting. Adding Stories to Scrum. A Case Study. Summary. Questions. 16: Additional Topics. Handling NonFunctional Requirements. Paper or Software? User Stories and the User Interface. Retaining the Stories. Stories for Bugs. Summary. Developer Responsibilities. Customer Responsibilities. Questions. IV: AN EXAMPLE. 17: The User Roles. The Project. Identifying the Customer. Identifying Some Initial Roles. Consolidating and Narrowing. Role Modeling. Adding Personas. 18: The Stories. Stories for Teresa. Stories for Captain Ron. Stories for a Novice Sailor. Stories for a Non-Sailing Gift Buyer. Stories for a Report Viewer. Some Administration Stories. Wrapping Up. 19: Estimating the Stories. The First Story. Advanced Search. Rating and Reviewing. Accounts. Finishing the Estimates. All the Estimates. 20: The Release Plan. Estimating Velocity. Prioritizing the Stories. The Finished Release Plan. 21: The Acceptance Tests. The Search Tests. Shopping Cart Tests. Buying Books. User Accounts. Administration. Testing the Constraints. A Final Story. V: APPENDICES. Appendix A: An Overview of Extreme Programming. Roles. The Twelve Practices. XP's Values. The Principles of XP. Summary. Appendix B: Answers to Questions. Chapter 1, An Overview. Chapter 2, Writing Stories. Chapter 3, User Role Modeling. Chapter 4, Gathering Stories. Chapter 5, Working with User Proxies. Chapter 6, Acceptance Testing User Stories. Chapter 7, Guidelines for Good Stories. Chapter 8, Estimating User Stories. Chapter 9, Planning a Release. Chapter 10, Planning an Iteration. Chapter 11, Measuring and Monitoring Velocity. Chapter 12, What Stories Are Not. Chapter 13, Why User Stories? Chapter 14, A Catalog of Story Smells. Chapter 15, Using Stories with Scrum. Chapter 16, Additional Topics. References. Index.

Read more less

Book SynopsisYou need to get value from your software project. You need it "free, now, and perfect." We can't get you there, but we can help you get to "cheaper, sooner, and better." This book leads you from the desire for value down to the specific activities that help good Agile projects deliver better software sooner, and at a lower cost. Using simple sketches and a few words, the author invites you to follow his path of learning and understanding from a half century of software development and from his engagement with Agile methods from their very beginning. The book describes software development, starting from our natural desire to get something of value. Each topic is described with a picture and a few paragraphs. You're invited to think about each topic; to take it in. You'll think about how each step into the process leads to the next. You'll begin to see why Agile methods ask for what they do, and you'll learn why a shallow implementation of Agile can lead to only limited improvement. This is not a detailed map, nor a step-by-step set of instructions for building the perfect project. There is no map or instructions that will do that for you. You need to build your own project, making it a bit more perfect every day. To do that effectively, you need to build up an understanding of the whole process. This book points out the milestones on your journey of understanding the nature of software development done well. It takes you to a location, describes it briefly, and leaves you to explore and fill in your own understanding. What You Need: You'll need your Standard Issue Brain, a bit of curiosity, and a desire to build your own understanding rather than have someone else's detailed ideas poured into your head.

Read more less

Book SynopsisThe authors share their insights on how to lead a team effectively, navigate an organization, and build a healthy relationship with the users of your software. This is valuable information from two respected software engineers whose popular series of talks-including "Working with Poisonous People"-has attracted hundreds of thousands of followers.

Read more less

Book SynopsisThis book takes a deep dive into the use of text within SVG to explore the creative possibilities as well as the potential pitfalls. You'll start with SVG's text basics, and then learn methods for using SVG to generate complex layouts.

Read more less

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