The Essence of Software Engineering: Applying the SEMAT Kernel

Book description

SEMAT (Software Engineering Methods and Theory) is an international initiative designed to identify a common ground, or universal standard, for software engineering. It is supported by some of the most distinguished contributors to the field. Creating a simple language to describe methods and practices, the SEMAT team expresses this common ground as a kernel–or framework–of elements essential to all software development.

The Essence of Software Engineering introduces this kernel and shows how to apply it when developing software and improving a team’s way of working. It is a book for software professionals, not methodologists. Its usefulness to development team members, who need to evaluate and choose the best practices for their work, goes well beyond the description or application of any single method.

“Software is both a craft and a science, both a work of passion and a work of principle. Writing good software requires both wild flights of imagination and creativity, as well as the hard reality of engineering tradeoffs. This book is an attempt at describing that balance.”

—Robert Martin (unclebob)

“The work of Ivar Jacobson and his colleagues, started as part of the SEMAT initiative, has taken a systematic approach to identifying a ‘kernel’ of software engineering principles and practices that have stood the test of time and recognition.”

—Bertrand Meyer

“The software development industry needs and demands a core kernel and language for defining software development practices—practices that can be mixed and matched, brought on board from other organizations; practices that can be measured; practices that can be integrated; and practices that can be compared and contrasted for speed, quality, and price. This thoughtful book gives a good grounding in ways to think about the problem, and a language to address the need, and every software engineer should read it.”

—Richard Soley

Table of contents

  1. Title Page
  2. Copyright Page
  3. Dedication Page
  4. Contents
  5. Foreword by Robert Martin
  6. Foreword by Bertrand Meyer
  7. Foreword by Richard Soley
  8. Preface
    1. Inspiration
    2. The Power of the Common Ground
    3. The Big Idea
    4. The Kernel Is Actionable
    5. The Kernel Is Extensible
    6. The Kernel Is Practical
    7. The Kernel in Action
    8. How Does the Kernel Relate to Agile and Other Existing Approaches?
    9. How the Kernel Will Help You
    10. How to Read This Book
    11. Further Reading
  9. Acknowledgments
  10. Part I: The Kernel Idea Explained
    1. 1. A Glimpse of How the Kernel Can Be Used
      1. 1.1. Why Is Developing Good Software So Challenging?
      2. 1.2. Getting to the Essence of Software Engineering: The Kernel
      3. 1.3. Using the Kernel to Address Specific Challenges: An Example
      4. 1.4. Learning How to Address Development Challenges with the Kernel
    2. 2. A Little More Detail about the Kernel
      1. 2.1. How to Use the Kernel to Address a Specific Challenge: An Example
      2. 2.2. Introducing the Alphas
      3. 2.3. Alphas Have States to Help a Team Achieve Progress
      4. 2.4. There Is More to the Kernel
    3. 3. A 10,000-Foot View of the Full Kernel
      1. 3.1. Organizing the Kernel
      2. 3.2. The Essential Things to Progress and Evolve: The Alphas
      3. 3.3. The Essential Things to Do: The Activities
      4. 3.4. Competencies
      5. 3.5. Finding Out More about the Kernel
    4. 4. The Kernel Alphas Made Tangible with Cards
      1. 4.1. Using Cards As Aids to Address a Specific Challenge: An Example
      2. 4.2. Making the Kernel Come Alive
    5. 5. Providing More Details to the Kernel through Practices
      1. 5.1. Making a Practice Explicit
      2. 5.2. How Explicit Should Practices Be?
      3. 5.3. Building Methods from Practices
      4. 5.4. Learning Methods and Practices
    6. 6. What the Kernel Can Do for You
      1. 6.1. Developing Great Software
      2. 6.2. Growing
      3. 6.3. Learning
      4. 6.4. Evolving
      5. Further Reading
  11. Part II: Using the Kernel to Run an Iteration
    1. 7. Running Iterations with the Kernel: Plan-Do-Check-Adapt
      1. 7.1. Terminology Used
      2. 7.2. Plan-Do-Check-Adapt
      3. 7.3. Setting the Scene
      4. 7.4. The Focus for the Next Few Chapters
    2. 8. Planning an Iteration
      1. 8.1. Planning Guided by Alpha States
      2. 8.2. Determining the Current State in Our Story
      3. 8.3. Determining the Next State in Our Story
      4. 8.4. Determining How to Achieve the Next States in Our Story
      5. 8.5. How the Kernel Helps You in Planning Iterations
    3. 9. Doing and Checking the Iteration
      1. 9.1. Doing and Checking the Iteration with the Kernel
      2. 9.2. Doing and Checking the Iteration in Our Story
      3. 9.3. How the Kernel Helps You in Doing and Checking the Iteration
    4. 10. Adapting the Way of Working
      1. 10.1. Adapting the Way of Working with the Kernel
      2. 10.2. Adapting the Way of Working in the Story
      3. 10.3. How the Kernel Helps You in Adapting the Way of Working
    5. 11. Running an Iteration with Explicit Requirement Item States
      1. 11.1. Working with Explicit Requirement Items
      2. 11.2. Planning an Iteration in Our Story
      3. 11.3. Doing Another Iteration in Our Story
      4. 11.4. Adapting the Way of Working in Our Story
      5. 11.5. Discussion
      6. Further Reading
  12. Part III: Using the Kernel to Run a Software Endeavor
    1. 12. Running a Software Endeavor: From Idea to Production
      1. 12.1. The People in Our Story and Challenges along the Way
      2. 12.2. Understanding the Organizational Context
    2. 13. Building the Business Case
      1. 13.1. Getting Ready to Start in Our Story
      2. 13.2. Understanding the Opportunity and the Stakeholders
      3. 13.3. Understanding the Solution
      4. 13.4. Preparing to Do the Work
      5. 13.5. Establishing a High-Level Plan
      6. 13.6. Building the Schedule
      7. 13.7. How the Kernel Helps You in Getting Started
    3. 14. Developing the System
      1. 14.1. Building the Skinny System—Getting Things Working
      2. 14.2. Engaging the Stakeholders
      3. 14.3. Starting Development
      4. 14.4. Establishing an Agreed-on Way of Working
      5. 14.5. Making the Skinny System Usable—Getting Things Working Well
      6. 14.6. Keeping the Stakeholders Involved
      7. 14.7. Evolving a Usable System
      8. 14.8. Getting to a Good Way of Working
      9. 14.9. Evolving a Deployable Solution—Concluding the Work
      10. 14.10. Gaining Acceptance
      11. 14.11. Getting to Delivery
      12. 14.12. Done! Completing Development Work
      13. 14.13. How the Kernel Helps You Develop Great Software
    4. 15. Operating the Software
      1. 15.1. Setting the Scene
      2. 15.2. Going Live—Successfully Deploying the System
      3. 15.3. Deploying the System
      4. 15.4. Handing Over between the Two Teams
      5. 15.5. Supporting the System until Retirement
      6. 15.6. Our Story Ends
      7. Further Reading
  13. Part IV: Scaling Development with the Kernel
    1. 16. What Does It Mean to Scale?
    2. 17. Zooming In to Provide Details
      1. 17.1. Making Practices Precise for Inexperienced Members
      2. 17.2. An Example: A Requirements Elicitation Practice
      3. 17.3. An Example: An Acceptance Testing Practice
      4. 17.4. Understanding How Practices Work Together
      5. 17.5. Value of Precise Practices
    3. 18. Reaching Out to Different Kinds of Development
      1. 18.1. Agreeing on the Practices to Use
      2. 18.2. Adapting to Your Development Life Cycle
      3. 18.3. Building a Method Incrementally during Development
      4. 18.4. Methods in Large Organizations
      5. 18.5. Putting Teams in Control of Their Methods
    4. 19. Scaling Up to Large and Complex Development
      1. 19.1. An Example of Large Development
      2. 19.2. Organizing Work Using the Alphas
      3. 19.3. Visualizing Development with the Alphas
      4. 19.4. Coordinating the Development Teams through Alphas
      5. 19.5. Empowering Teams to Scale
      6. Further Reading
  14. Part V: How the Kernel Changes the Way You Work with Methods
    1. 20. Thinking about Methods without Thinking about Methods
      1. 20.1. You Think about Methods All the Time
      2. 20.2. Doing Rather Than Discussing
    2. 21. Agile Working with Methods
      1. 21.1. The Full Team Owns Their Method, Rather Than a Select Few
      2. 21.2. Focus on Method Use Rather Than Comprehensive Method Description
      3. 21.3. Evolve Your Team’s Method, Rather Than Keeping Your Method Fixed
  15. Part VI: What’s Really New Here?
    1. 22. Refounding Methods
      1. 22.1. Not a Lack of Methods, but a Lack of a Foundation—a Kernel
      2. 22.2. The Kernel Values Practicality
      3. 22.3. The Kernel Is Actionable and Extensible
    2. 23. Separation of Concerns Applied to Methods
      1. 23.1. Separating the Kernel from Practices
      2. 23.2. Separating Alphas from Work Products
      3. 23.3. Separating the Essence from the Details
    3. 24. The Key Differentiators
      1. 24.1. Innovations with Methods
      2. 24.2. Practical Tools for Software Teams and Professionals
  16. Part VII: Epilogue
    1. 25. This Is Not the End
    2. 26. ... But Perhaps It Is the End of the Beginning
    3. 27. When the Vision Comes True
      1. 27.1. The Software Professional
      2. 27.2. The Industry
      3. 27.3. The Academic World
      4. 27.4. An Exciting Future
      5. Further Reading
  17. Appendixes
    1. Appendix A. Concepts and Notation
    2. Appendix B. What Does This Book Cover with Respect to the Kernel?
      1. B.1. Inside the Kernel, and Inside This Book
      2. B.2. Outside the Kernel, but Inside This Book
      3. B.3. Inside the Kernel, but Outside This Book
    3. Appendix C. Bibliography
      1. C.1. SEMAT Working Documents
      2. C.2. SEMAT: Other Documents and References
      3. C.3. Other References
    4. About the Authors
    5. What People Are Saying about This Book
  18. Index
  19. Ad Pages

Product information

  • Title: The Essence of Software Engineering: Applying the SEMAT Kernel
  • Author(s):
  • Release date: January 2013
  • Publisher(s): Addison-Wesley Professional
  • ISBN: 9780133153156