Neal Ford  |
  • Author, Thoughtworker, & Meme Wrangler

My books

I have both written books as the primary (or sole author) and contributed to several anthologies. I also edited and contributed to the two No Fluff, Just Stuff Anthologies. The books on this page are arranged more or less reverse chronologically by publication date.

Building Evolutionary Architectures

Support Constant Change

Neal Ford, Rebecca Parsons, Patrick Kua

Paperback, Kindle, ePub
Publisher:O'Reilly Media Inc
ISBN-13: 978-1491986363
ISBN-10: 1491986360

For a variety of reasons, parts of software systems defy change, becoming more brittle and intractable over time. However, the world we inhabit has exactly the opposite characteristic. Business constantly changes, but so does the software development ecosystem. New tools, techniques, approaches, and frameworks constantly impact that equilibrium in unanticipatable ways. While this creates a headache for brittle systems, it also provides the ultimate solution. Over the last few years, incremental developments in core engineering practices for software development created the foundations for us to rethink how architecture changes over time, along with ways to protect important architectural characteristics as it evolves. This book ties those parts together with a new way to think about architecture and time.

Along the way, we also answer the questions How is long term planning possible when everything changes all the time? and Once I've built an architecture, how can I prevent it from gradually degrading over time?.

This book is about evolutionary architectures, building systems that allow architects and developers to make sweeping changes to the most important parts of their systems with confidence. It covers practices that allow developers to build continual architectures, which evolve cleanly without the need for a crystal ball.

Our Definition:

An evolutionary architecture supports guided, incremental change across multiple dimensions.

Our book consists of three parts, reflecting each portion of the definition.

Incremental change

Incremental change relies on continuous delivery practices like deployment pipelines, mature DevOps, good testing culture, and other current agile engineering best practices. When combined with a granular, modular architecture, incremental change allows developers to make small modifications at the architectural level without breaking unrelated pieces. Incremental change is the machinery that enables evolutionary architectures to evolve.

Multiple dimensions

Architects commonly focus on a narrow dimension of a software project, the technical architecture: frameworks, dependencies, integration architecture, and so on. But real software projects contain numerous orthogonal concerns: data architecture, security, scalability, testability, and a host of others. Modern architectures that support evolution must accommodate all these important dimensions of architecture--continuously.

When building an evolutionary architecture, architects must consider each dimension affected. For example, it isn't useful to build an evolvable technical architecture with an intractable data schema, or evolve in a way that harms security.

Fitness Functions

Evolutionary architecture allows different parts of the system to evolve in the ways most sensible to solve a problem. However, we don't want the system to evolve in a way that harms some architectural dimension. For example, improving performance with caching might accidentally harm security in the process. How can we build guidelines within the architecture to support change but guard specific characteristics?

An architectural fitness function provides an objective integrity assessment of some architectural characteristic(s).

Fitness functions employ a wide variety of implementation mechanisms: tests, metrics, monitoring, logging, and so on, to protect one or more architectural dimensions. We define a variety of categories of fitness functions: triggered versus continual, atomic versus holistic, and a variety of others.

When we identify a dimension in architecture affected by change, we define fitness functions to protect against undesirable breakage.

Evolutionary Architecture

We offer a new perspective on evolving architecture, making "evolvability" a first-class "-ility" in software projects. We provide a logical framework for identifying and protecting parts of the architecture that evolve: identify the important dimensions, define fitness functions to ensure compliance, and use incremental change engineering practices such as deployment pipelines to automatically verify fitness.

The concepts of evolutionary architecture also help automate previously underserved constituents ("non-functional requirements") by providing a framework for identifying important dimensions, with their critical characteristics, and the mechanism (via fitness functions) for verifying the veracity of those attributes continually. This in turn allows architects to build systems that support ongoing change with confidence that important qualities won't degrade. Identification of architecture dimension and fitness function occurs at both project inception and as an ongoing concern, building continual architecture.


This book is packed with nomenclatures and deliberate practices that will significantly benefit anyone in the role of an architect. Wish I had this in my hands decades ago, glad its here now.
--Dr. Venkat Subramaniam, award winning author and founder of Agile Developer, Inc.

Software development has changed in recent years, from long release cycles characterised by up-front planning, to the development of software in small valuable increments that deliver value quickly, allowing changes in direction in response to the experience gained from early delivery. In this book, Neal, Rebecca and Pat draw on their extensive experience to explain how to create architectures that can enable constant change, by evolving throughout the lifetime of the system. It is a valuable guide for any software architect who needs to support the rapid delivery of valuable software.
--Eoin Woods, Endava

The timely "Building Evolutionary Architectures" sits at the intersection of two key trends in the software industry. At one hand software engineers face increasing demand for delivery and quality at 'Internet' pace and scale. The only way to address this is to build evolving architectures. We do not have all the answers at the beginning, nor do we have time to find all the answers. At the same time, the role of the software architect is changing. They are increasingly becoming hands on members of highly effective product teams, instead of a separate group making the 'big decisions'. The book not only addresses these points, but is also full of pragmatic and insightful advice. A great read for all software engineers and architects.
--Murat Erder

Functional Thinking

Paradigm over Syntax

Neal Ford

Paperback, Kindle, ePub
Publisher:O'Reilly Media Inc
ISBN: 978-1-449-36551-6

If you want to take advantage of functional programming features in Java and other languages, this in-depth guide takes you beyond syntax and demonstrates how you need to think in a new way. Software architect Neal Ford shows intermediate to advanced developers how functional coding allows you to step back a level of abstraction so you can see your programming problem with greater clarity.

Each chapter shows you various examples of functional thinking, using numerous code examples from Java 8 and other JVM languages that include functional capabilities. This book may bend your mind, but you’ll come away with a good grasp of functional programming concepts.

  • Understand why many imperative languages are adding functional capabilities
  • Compare functional and imperative solutions to common problems
  • Examine ways to cede control of routine chores to the runtime
  • Learn how memoization and laziness eliminate hand-crafted solutions
  • Explore functional approaches to design patterns and code reuse
  • View real-world examples of functional thinking with Java 8, and in functional architectures and web frameworks
  • Learn the pros and cons of living in a paradigmatically richer world


The animal on the cover of Functional Thinking is a thick-tailed greater galago (of the Otolemur genus), also known as a thick-tailed bushbaby. These primates are native to southern and eastern Africa. Galagos are mostly arboreal, and prefer tropical and subtropical forest habitat, though they can occasionally be found in woodland savannah.These animals have thick brown or gray fur, large ears and eyes, and long tails to help with balance as they travel through the trees. They are also equipped with long fingers and toes tipped with thickened skin pads to grasp limbs. On average, they are a foot long (not including the tail) and weigh 2–3 pounds.The thick-tailed greater galago is nocturnal; during the day, it rests 5–12 meters above the ground, concealed within a dense nest of vines in a tree hollow. They are generally solitary, and mark their territories with a scent gland in their chest as well as urine (though male territories often overlap with those of females).At night, galagos come out to forage for food. They are agile and able to make short jumps from tree to tree, though they usually just walk unless alarmed. They eat fruit, seeds, acacia gum, flowers, and insects. Biologists have observed that each individual animal spends nearly half of each evening traveling and only 20% foraging, and often patrols the same route each night.The cover image is from Cassell's Natural History.

Available at O'Reilly, Amazon, and other fine book sellers.

Presentation Patterns

Techniques for Crafting Better Presentations

Neal Ford, Matthew McCullough, Nathaniel Schutta

Paperback, Kindle, ePub: 265 pages
Publisher: Addison-Wesley Professional; 1st edition (August 27, 2012)
ISBN-10: 0321820800
ISBN-13: 978-0321820808

Companion website:

Presentation Patterns is the first book on presentations that categorizes and organizes the building blocks (or patterns) that you’ll need to communicate effectively using presentation tools like Keynote and Powerpoint.

Patterns are like the lower-level steps found inside recipes; they are the techniques you must master to be considered a master chef or master presenter. You can use the patterns in this book to construct your own recipes for different contexts, such as business meetings, technical demonstrations, scientific expositions and keynotes, just to name a few.

Although there are no such things as antirecipes, this book shows you lots of antipatterns, things you should avoid doing in presentations. Modern presentation tools often encourage ineffective presentation techniques, but this book shows you how to avoid them.

Each pattern is introduced with a memorable name, a definition, and a brief explanation of motivation. Readers learn where the pattern applies, the consequences of applying it, and how to apply it. The authors also identify critical antipatterns: clichés, fallacies, and design mistakes that cause presentations to disappoint. These problems are easy to avoid—once you know how.

Presentation Patterns will help you:

  • Plan what you'll say, who you'll say it to, how long you'll talk, and where you'll present
  • Perfectly calibrate your presentation to your audience
  • Use the storyteller's “narrative arc” to full advantage
  • Strengthen your credibility—and avoid mistakes that hurt it
  • Hone your message before you ever touch presentation software
  • Incorporate visuals that support your message instead of hindering it
  • Create highly effective “infodecks” that work when you're not present
  • Construct slides that really communicate and avoid “Ant Fonts,” “Floodmarks,” “Alienating Artifacts,” and other errors
  • Master 13 powerful techniques for delivering your presentation with power, authority, and clarity

Whether you use this book as a handy reference or read it from start to finish, itwill be a revelation: an entirely new language for systematically planning, creating, and delivering more powerful presentations. You'll quickly find it indispensable—no matter what you're presenting, who your audiences are, or what you want them to do.

Available at Amazon and other fine book sellers.

ThoughtWorks Anthology Volume 2

More Essays on Software and Technology

Compiled by Neal Ford

Edited by: Michael Swaine

Paperback: 250 pages
Publisher: Pragmatic Press; 1st edition (August 2012)
ISBN: 978-1-93778-500-0

When you hit a rough spot in software development, it's nice to know that someone has been there before. The domain experts at ThoughtWorks share what they've learned in this anthology, bringing together the best field-tested insights in IT and software development. You'll benefit from their experience in areas from testing to information visualization, from object oriented to functional programming, from incremental development to driving innovation in delivery. You'll find yourself referring to this collection of solved problems whenever you need an expert's insight.

97 Things Every Software Programmer Should Know: Collective Wisdom from the Experts

Compiled by Kevlin Henney

Paperback: 258 pages
Publisher: O'Reilly Media (February 2010)
ISBN: 978-0-596-80948-5

Tap into the wisdom of experts to learn what every programmer should know, no matter what language you use. With the 97 short and extremely useful tips for programmers in this book, you'll expand your skills by adopting new approaches to old problems, learning appropriate best practices, and honing your craft through sound advice.

With contributions from some of the most experienced and respected practitioners in the industry--including Michael Feathers, Pete Goodliffe, Diomidis Spinellis, Cay Horstmann, Verity Stob, and many more--this book contains practical knowledge and principles that you can apply to all kinds of projects.

A few of the 97 things you should know:

  • "Code in the Language of the Domain" by Dan North
  • "Write Tests for People" by Gerard Meszaros
  • "Convenience Is Not an -ility" by Gregor Hohpe
  • "Know Your IDE" by Heinz Kabutz
  • "A Message to the Future" by Linda Rising
  • "The Boy Scout Rule" by Robert C. Martin (Uncle Bob)
  • "Beware the Share" by Udi Dahan
  • "Testing Is the Engineering Rigor of Software Development" by Neal Ford

97 Things Every Project Manager Should Know: Collective Wisdom from the Experts

Compiled by Barbee Davis

Paperback: 252 pages
Publisher: O'Reilly Media (August 2009)

If the projects you manage don't go as smoothly as you'd like, 97 Things Every Project Manager Should Know offers knowledge that's priceless, gained through years of trial and error. This illuminating book contains 97 short and extremely practical tips -- whether you're dealing with software or non-IT projects -- from some of the world's most experienced project managers and software developers. You'll learn how these professionals have dealt with everything from managing teams to handling project stakeholders to runaway meetings and more.

While this book highlights software projects, its wise axioms contain project management principles applicable to projects of all types in any industry. You can read the book end to end or browse to find topics that are of particular relevance to you. 97 Things Every Project Manager Should Know is both a useful reference and a source of inspiration.

Among the 97 practical tips:

  • "Clever Code Is Hard to Maintain...and Maintenance Is Everything" -- David Wood, Partner, Zepheira
  • "Every Project Manager Is a Contract Administrator" -- Fabio Teixeira de Melo, Planning Manager, Construtora Norberto Odebrecht
  • "Can Earned Value and Velocity Coexist on Reports?" -- Barbee Davis, President, Davis Consulting
  • "How Do You Define 'Finished'"? -- Brian Sam-Bodden, author, software architect
  • "The Best People to Create the Estimates Are the Ones Who Do the Work" -- Joe Zenevitch, Senior Project Manager, ThoughtWorks
  • "How to Spot a Good IT Developer" -- James Graham, independent management consultant
  • "One Deliverable, One Person" -- Alan Greenblatt, CEO, Sciova
  • "Developer Productivity: Skilled Versus Average" -- Neal Ford, Meme Wrangler, ThoughtWorks

97 Things Every Software Architect Should Know: Collective Wisdom from the Experts

Compiled by Richard Monson-Haefel

Paperback: 220 pages
Publisher: O'Reilly (February 2009)
ISBN: 059652269X

From the Amazon Description: In this truly unique technical book, today's leading software architects present valuable principles on key development issues that go way beyond technology. More than four dozen architects -- including Neal Ford, Michael Nygard, and Bill de h ra -- offer advice for communicating with stakeholders, eliminating complexity, empowering developers, and many more practical lessons they've learned from years of experience. Among the 97 principles in this book, you'll find useful advice such as:

  • Don't Put Your Resume Ahead of the Requirements (Nitin Borwankar)
  • Chances Are, Your Biggest Problem Isn't Technical (Mark Ramm)
  • Communication Is King; Clarity and Leadership, Its Humble Servants (Mark Richards)
  • Simplicity Before Generality, Use Before Reuse (Kevlin Henney)
  • For the End User, the Interface Is the System (Vinayak Hegde)
  • It's Never Too Early to Think About Performance (Rebecca Parsons)

To be successful as a software architect, you need to master both business and technology. This book tells you what top software architects think is important and how they approach a project. If you want to enhance your career, 97 Things Every Software Architect Should Know is essential reading.

The Productive Programmer

Neal Ford

Paperback: 222 pages
Publisher: O'Reilly (July 2008)
Series: Theory in Practice ISBN: 0-596-51978-8

Anyone who develops software for a living needs a proven way to produce it better, faster, and cheaper. The Productive Programmer offers critical timesaving and productivity tools that you can adopt right away, no matter what platform you use. Master developer Neal Ford not only offers advice on the mechanics of productivity-how to work smarter, spurn interruptions, get the most out your computer, and avoid repetition-he also details valuable practices that will help you elude common traps, improve your code, and become more valuable to your team. You'll learn to:

  • Write the test before you write the code
  • Manage the lifecycle of your objects fastidiously
  • Build only what you need now, not what you might need later
  • Apply ancient philosophies to software development
  • Question authority, rather than blindly adhere to standards
  • Make hard things easier and impossible things possible through meta-programming
  • Be sure all code within a method is at the same level of abstraction
  • Pick the right editor and assemble the best tools for the job

This isn't theory, but the fruits of Ford's real-world experience as an Application Architect at the global IT consultancy ThoughtWorks. Whether you're a beginner or a pro with years of experience, you'll improve your work and your career with the simple and straightforward principles in The Productive Programmer.

ThoughtWorks Anthology

Edited by Rebecca Parsons

Paperback: 240 pages
Publisher: Pragmatic Press (March 2008)
ISBN: 9781934356142

ThoughtWorks is a well-known global consulting firm; ThoughtWorkers are leaders in areas of design, architecture, SOA, testing, and agile methodologies. This collection of essays brings together contributions from well-known ThoughtWorkers such as Martin Fowler, along with other authors you may not know yet. While ThoughtWorks is perhaps best known for their work in the Agile community, this anthology confronts issues throughout the software development life cycle. From technology issues that transcend methodology, to issues of realizing business value from applications, you'll find it here.

  • Solving the Business Software Last Mile by Roy Singahm and Michael Robinson
  • One Lair and Twenty Ruby DSLs by Martin Fowler
  • The Lush Landscape of Languages by Rebecca J. Parsons
  • Polyglot Programming by Neal Ford
  • Object Calisthenics by Jeff Bay
  • What Is an Iteration Manager Anyway? by Tiffany Lentz
  • Project Vital Signs by Stelios Pantazopoulos
  • Consumer-Driven Contracts: A Service Evolution Pattern by Ian Robinson
  • Domain Annotations by Erik Coernenburg
  • Refactoring Ant Build Files by Julian Simpson
  • Single-Click Software Release by Dave Farley
  • Agile vs. Waterfall Testing for Enterprise Web Apps by Kristan Vingrys
  • Pragmatic Performance Testing by James Bull

  • No Fluff, Just Stuff Anthology, Volume II
    What Every Software Developer Shound Know

    Compiled by Neal Ford

    Paperback: 320 pages
    Publisher: Pragmatic Press (April 2007)
    ISBN: 9780978739287

    These essays are a summary of the latest thinking in the industry, and range from the philosophical to the tutorial, covering the topics that the writers felt were the most important for readers today. If you feel like the neatest technology and latest ideas are passing you by, this book can help bring you back you to speed.

    It's all good stuff, without any fluffy filler, as these essays are based on pre sentations given at the incredibly popular "No Fluff, Just Stuff" symposium series. Twenty-six times a year, the symposium visits a city and the speakers and attendees share ideas and perspectives. The speakers are all internationally known experts in their field.

    Twenty-seven weekends a year, the No Fluff, Just Stuff conference rolls into another town, featuring the world's best technical speakers and writers. Up until now, you had to go to one of the shows to soak up their collective wisdom. Now, you can hold it in the palm of your hand. The No Fluff, Just Stuff Anthology represents topics presented on the tour, written by the speakers who created it. This book allows the authors the chance to go more in depth on the subjects for which they are passionate. It is guaranteed to surprise, enlighten, and broaden your understanding of the technical world in which you live.

    The No Fluff, Just Stuff Symposium Series is a traveling conference series for software developers visiting 27 cities a year. No Fluff has put on over 75 symposia throughout the U.S. and Canada, with more than 12,000 attendees so far. Its success has been a result of focusing on high quality technical presentations, great speakers, and no marketing hype. Now this world-class material is available to you in print for the first time.

    No Fluff, Just Stuff Anthology, Volume I
    The 2006 Edition

    Compiled by Neal Ford

    Paperback: 256 pages
    Publisher: Pragmatic Press (June 2006)
    ISBN: 0-9776166-6-5

    Take 13 of the world's best trainers and speakers and ask them to write a chapter on something they care passionately about. The result? A book on software development unlike any other. Fifteen chapters covering the range of modern software development topics, from Domain-Specific Languages through Aspect-Oriented CSS to learning from the past.
    These essays are a summary of the latest thinking in the industry, and range from the philosophical to the tutorial, covering the topics that the writers felt were the most important for readers today. If you feel like the neatest technology and latest ideas are passing you by, this book can help bring you back you to speed.
    It's all good stuff, without any fluffy filler, as these essays are based on presentations given at the incredibly popular "No Fluff, Just Stuff" symposium series. Twenty-six times a year, the symposium visits a city and the speakers and attendees share ideas and perspectives. The speakers are all internationally known experts in their field.

    As a bonus, many of the authors have contributed to an appendix listing their favorite recent reads, and tools that they find most useful. The book also contains a substantial bibliography of recommended further reading.

    Art of Java Web Development:
    Struts, Tapestry, Commons, Velocity, JUnit, Axis, Cocoon, InternetBeans, WebWork

    Neal Ford

    Paperback: 450 pages
    Publisher: Manning Publications Company; (November 1, 2003)
    ISBN: 1932394060

    A guide to the topics required for state of the art web development, this book covers wide-ranging topics, including a variety of web development frameworks and best practices. Beginning with coverage of the history of the architecture of web applications, highlighting the uses of the standard web API to create applications with increasingly sophisticated architectures, developers are led through a discussion on the development of industry accepted best practices for architecture.

    Described is the history and evolution towards this architecture and the reasons that it is superior to previous efforts. Also provided is an overview of the most popular web application frameworks, covering their architecture and use. Numerous frameworks exist, but trying to evaluate them is difficult because their documentation stresses their advantages but hides their deficiencies. Here, the same application is built in six different frameworks, providing a way to perform an informed comparison. Also provided is an evaluation of the pros and cons of each framework to assist in making a decision or evaluating a framework on your own. Finally, best practices are covered, including sophisticated user interface techniques, intelligent caching and resource management, performance tuning, debugging, testing, and Web services.

    JBuilder 3 Unleashed

    Neal Ford, Ed Weber, Talal Azzouka, Terry Dietzler, Jennifer Streeter, Casey Williams

    Paperback: 1072 pages
    Publisher: SAMS; Book and CD-ROM edition (September 1999)
    ISBN: 0672315483

    Editorial Review from
    JBuilder 3 Unleashed does an excellent job of explaining how to write Java programs in Borland's newest Integrated Development Environment (IDE) for the language. With plenty of code (all of which ships on the accompanying CD-ROM) and lots of documentation on Java classes, this book enables the intermediate-level Java programmer to become more capable with JBuilder and the language as a whole. You'll find good information if you want to write servlets, interface with databases, or do any of dozens of other software development tasks.

    JBuilder 3 Unleashed naturally covers the JBuilder user interface, but the authors don't explain interface elements for their own sake. Rather, they explain the JBuilder interface in the context of doing certain Java programming jobs. Subjects include some fairly exotic aspects of the Java language, including elaborate user interface design, multithreading, internationalization, and client/server architecture.

    Coverage of programming JavaBeans (and especially serialization as it applies to Beans) with JBuilder is exemplary, as are the sections on Remote Method Invocation (RMI) and CORBA. In addition to their coverage of the mechanics of JBuilder and Java, the authors include quite a bit of management and engineering information on using Borland's development environment as the centerpiece of a development team, including versioning, testing, and object-oriented analysis and design. --David Wall

    Topics covered: JBuilder user interface, multithreading, internationalization, client/server architecture, programming JavaBeans, RMI, and CORBA.

    From the Back Cover

    JBuilder 3 Unleashed is designed to help intermediate to advanced level Java developers obtain the information and techniques needed to create mission critical JBuilder applications. The book picks up where most JBuilder books leave off and provides the information needed by developers to create robust and maintainable JBuilder Client/Server and multi-tier applications. Topics covered include: Advanced object-oriented design and programming techniques in Java, Enterprise JavaBeans,... read more

    Book Description

    JBuilder 3 Unleashed is designed to help intermediate to advanced level Java developers obtain the information and techniques needed to create mission critical JBuilder applications. The book picks up where most JBuilder books leave off and provides the information needed by developers to create robust and maintainable JBuilder Client/Server and multi-tier applications. Topics covered include: Advanced object-oriented design and programming techniques in Java, Enterprise JavaBeans, Serialization, Threading, NMI, Multi-tier development: implementation of applications and applets, RMI, CORBA, Enprise's MIDAS technology, N-tier, Application Development, Source code control, Deployment.

    Developing with Delphi: Object-oriented Techniques

    Edward C. Weber, J. Neal Ford, Christopher Weber

    Prentice Hall Computer Books; Book and Disk edition (January 1996)
    ISBN: 0133781186 (Out of Print)

    Publisher Blurb:

    This text shows how to apply object-oriented programming techniques using Delphi, Borland's second generation, visual, client/server development tool. It includes insights into creating large applications in a team development environment, and covers advanced topics such as version control, reusable components and client/server connectivity. A toolkit is included on the accompanying disk which contains common application components that can be used immediately saving developers time and money.

    The complete guide to creating large mission-critical applications with Delphi. The authors, all experienced developers, cover the object-oriented concepts underlying Delphi, present examples including a comprehensive case study, and show how Delphi can be used with other technologies, such as OLE 1.0/2.0, DDE, Windows DLLS, and database-related tools.

    The Real Skinny:

    This book was written about Delphi 1.0, which caused a lot of breathless enthusiam in the programming world when it came out. Our publisher was Prentice Hall, which was essentially a publisher of text books. We got the book done, which provided a reasonable overview of Delphi. It was not particularly about Object-oriented Techniques, but the publisher insisted on that title. We sent the book off to the publisher and waited, and waited, and waited...11 months (!) after we had sent them the final manuscript, the book was published, about two months before Delphi 2.0 (the 32-bit version) came out. Needless to say, our book had a short shelf life. Our publisher thought this was OK because no one gets in a hurry for a text book. I found out later, ironically enough, that the California Polytechnic University at Pomona actually used it as a text book!

       Follow Neal on Twitter music image opera image reading image

    Neal Ford  |
    • Author, Thoughtworker, & Meme Wrangler