Foreword to the Chinese translation of
How to Engineer Software
By Steve McConnell
It is both a pleasure and a privilege to write the foreword to How to Engineer Software: A Model-Based Approach by Steve Tockey. My connection to this book is not simply academic or professional—it’s personal. I’ve had the good fortune of knowing Steve for over two decades. For more than 20 years, we’ve worked side by side, collaborated on challenging problems, debated ideas, shared insights, and—most importantly—built a deep and lasting professional respect for one another.
From the very first project we tackled together, it was evident that Steve brought something extraordinary to the table. He’s not just a software engineer; he’s a systems thinker, a disciplined problem-solver, and a passionate educator. He possesses a rare combination of analytical rigor and clarity of thought, paired with an ability to communicate complex ideas in ways that are both comprehensible and compelling. Over the past 20+ years, Steve and I have dissected legacy systems, coached teams, developed curricula, and shared countless hours of discussion on everything from requirements modeling to design verification to the perennial debate over how to realize a vision of engineered software. Through all of it, Steve has consistently demonstrated a level of rigor, thoughtfulness, and integrity that is exceedingly rare—not just in software, but in any professional discipline.
For the entire time I have known him, Steve has maintained an unwavering commitment to doing things right. He has always advocated for approaches that are grounded in engineering discipline. For Steve, software isn’t merely written—it’s engineered. It’s not about hacking together code that happens to work. It’s about deliberately crafting solutions that are understandable, maintainable, testable, and economically viable.
That philosophy runs through every page of this book.
How to Engineer Software is more than a reference—it’s a framework. It provides a structured, model-based methodology for software development that is as intellectually robust as it is practically applicable. This is not a book about trendy technologies or fleeting practices. Rather, it is a thoughtful and thorough exposition of enduring principles that can guide both novice and veteran practitioners through the complexities of software creation.
At its core, the book embodies three key values that define Steve’s approach: clarity, consistency, and conscientiousness.
Clarity is evident in the way concepts are introduced and developed. Whether Steve is unpacking the semantic nuances of a state model or explaining the economics of error handling, he does so with a precision that helps the reader not only understand what is being said, but also why it matters. He makes distinctions that are too often blurred—between phases and activities, between specification and implementation, between correctness and completeness—and in doing so, he illuminates the terrain of software engineering in a way that is both logical and enlightening.
Consistency pervades the methodology itself. Steve does not advocate a one-size-fits-all solution, nor does he propose rigid dogma. Instead, he lays out a coherent framework that can be adapted intelligently to different contexts. He champions a meta-process—a process for selecting and tailoring processes—that reflects his belief in engineering as a discipline that must be simultaneously principled and pragmatic. The approach is model-based not for the sake of formality, but because models help manage complexity, clarify intent, and support verification. It’s a method designed for those who take their craft seriously.
Conscientiousness comes through in the tone of the writing and the depth of the content. This is a book written by someone who cares—about the reader, about the discipline, and about the future of software engineering. Steve doesn’t gloss over challenges. He acknowledges them, addresses them, and equips readers with the tools they need to confront them. Whether discussing agile vs. waterfall methods, formal correctness proofs, or estimation techniques, he approaches each topic with honesty, nuance, and a wealth of experience.
One of the things I most appreciate about this book is that it meets the reader wherever they are in their journey. For those early in their careers, it provides a solid foundation in how software should be built—an anchor against the chaos of ad hoc development. For seasoned professionals, it offers structure and validation—a mirror that reflects what’s been learned through years of trial and error, now organized into a methodical, reusable form. And for educators, it serves as a resource that bridges the often wide gap between academic theory and industry practice.
What also stands out is the breadth and integration of topics. Requirements engineering, modeling techniques, interface design, detailed coding practices, formal verification, error handling, estimation models—it’s all here. And yet, Steve manages to thread a narrative that ties these components together in a unified vision of software development. While recognizing the unique aspects of each knowledge area, he doesn’t treat them as isolated silos but as interlocking parts of an engineering discipline.
This integrated view of software engineering is especially important in today’s world. Software systems have become ubiquitous, and the cost of failure—whether financial, ethical, or human— has grown accordingly. In such a landscape, the call for professionalism in software development is louder than ever. Steve answers that call with this book. He makes the case, both implicitly and explicitly, that software development should be held to the same standard of engineering excellence as any other domain that shapes the world we live in.
Over the course of our two-decade collaboration, I’ve seen Steve hold that standard in every piece of work he touches. He has a passion for doing things right—not just for the sake of correctness, but for the people who rely on the systems we build. That same care and passion are reflected in this book. It is the distillation of decades of experience, the result of countless hours of deep thinking, real-world application, and hard-won lessons.
This book distills a career’s worth of experience, insight, and hard-won lessons into a form that others can learn from, build on, and extend. It is a contribution to the profession, a roadmap for those who want to elevate their practice, and a call to action for those who believe that software can—and must—be done better.
To those of you reading this foreword before diving into the book itself, I encourage you to do so with curiosity, openness, and a willingness to be challenged. There are no gimmicks here, no hand-waving, no hype. What you will find instead is substance—clear, actionable, thoughtful substance—delivered with care by someone who has spent a lifetime mastering his craft.
In closing, I want to reiterate how deeply I respect Steve—not only as a colleague and co- conspirator in the art and science of software, but as a person. He is thoughtful, generous with his insights, and unfailingly principled. This book reflects those qualities. It is rigorous but accessible, structured yet flexible, and above all, honest. It doesn’t promise shortcuts. It promises understanding. And that, in the world of software engineering, is the most valuable promise one can make.
—Steve McConnell
Chairman, Construx Software
