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 non this page are arranged more or less reverse chronologically by publication date.
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 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.
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.
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.
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
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.
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.
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: presentationpatterns.com.
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:
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.
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.
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:
Compiled by Barbee Davis
Paperback: 252 pages
Publisher: O'Reilly Media (August 2009)
ISBN:978-0-596-80416-9
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:
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:
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.
Neal Ford Paperback: 222 pages
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:
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.
Edited by Rebecca Parsons Paperback: 240 pages 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.
The Productive Programmer
Publisher: O'Reilly (July 2008)
Series: Theory in Practice
ISBN: 0-596-51978-8
ThoughtWorks Anthology
Publisher: Pragmatic Press (March 2008)
ISBN: 9781934356142
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.
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.
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.
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 Amazon.com
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.
Edward C. Weber, J. Neal Ford, Christopher Weber
Prentice Hall Computer Books; Book and Disk edition (January 1996)
ISBN: 0133781186 (Out of Print)
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.
