|Essential Skills for the Agile Developer|
Author: Alan Shalloway, Scott L. Bain, Amir Kolsky & Ken Pugh
A "stop-gap" title that forms part of the Net Objectives Lean-Agile Series. Who should read it?
If this book's cover strikes you as familiar, it's because its part of a series of titles written by Net Objectives trainers and consultants. In the foreword to this title Alan Shalloway, the CEO of Net Objectives and the book's lead author explains that it was written to assist teams that have just started to do lean, kanban, scrum or agile and that its a "stop gap measure" in that it is a means to an end that
offers a minimal set of skills that developers need to help them on their way towards becoming adept at incremental development.
More of the skills needed are covered in other books and there are plenty of references to further reading throughout this volume.
People often skip the preambles to a book. But unless you read both the Preface and the Acknowledgments in this one you may be mystified by the title of Part I - The Core Trim Tabs. According to the preface trim tabs are structures on airplanes and ships that reduce the amount of energy needed to control the flaps on an plane or the rudder of a ship however in the context of this book it is used in a way inspired by the inventor and visionary Buckminster Fuller that mean they can be thought of as the insights and activities that give the most understanding with the least investment.
Part I has seven chapters and they introduce ideas at a fast rate. Chapter 1: Programming by Intention introduces what used to be called "Top-down programming" where you break down a problem into functional steps and assume the use of methods - sometimes called helper methods but here termed private methods - before you have actually created them. You simply have the intention of creating them hence the new name for this methodology. The advantages of this are approach, discussed in this chapter, are that code is more cohesive, more readable and expressive, easier to debug, easier to refactor or expand and easier to unit test.
The second chapter explore a single principle - Separate Use from Construction with a series of "perspectives. Then in Chapter 3: Define Tests Up Front explores the trim tab of testing and testability.
Chapter 4 introduces Shalloway's Law, which is:
When N things need to change and N>1, Shalloway [the author of this chapter] will find at most N-1 of these things.
Given this he proposes the associated Shalloway's Principle which is:
Avoid situations where Shalloway's Law apply.
This leads to looking at eliminating redundancy.
The advice in the next chapter is stated in it's title - Encapsulate That! - and after an examination of the "true meaning" of encapsulation looks at patterns that make code easier to maintain, debug, enhance and scale.
Chapter 6 on Interface-Oriented Design and Chapter 7 on acceptance Test-Driven Development round out this section of the book.
There are two chapters in Part II: General Attitudes. The first of them presents this five-point mantra for development:
The second advocates Continuous Integration (CI) and looks at how it eliminates the need for branching with its negative consequences.
Part III is on Design Issues and opens with a chapter on Commonality and Variability Analysis. It argues for the need to move away from the object-oriented approach of finding the nouns and verbs in the problem domain and use instead the inherent variations, identifying what is in common across it and where and how this vary. It goes on to introduce the Analysis Matrix method for tracking requirements.
Chapter 11:Refactor to the Open-Closed addresses the implications of the fact that systems have to accommodate change and goes on to rethink the OO Open-Closed principle - that classes, module, functions etc should be open for extension but closed for modification. After discussing refactoring it advocates Just-In-Time design in order to avoid over-design.
Chapter 12: Needs versus Capabilities Interfaces introduces the Law of Demeter and discusses coupling and dependencies. It looks at the advantages of Adapter Pattern, an interface that focuses on what the client needs.
The final chapter in this part looks at When and How to Use Inheritance and applies lessons from the Gang of Four to agile development.
The book has one more section. Part IV contains three Appendixes that supplement what has already been covered. First comes an overview of UML (Unified Modeling Language) and the use of the class diagram. Then we have a summary of Code Qualities which looks at Cohesion; Coupling; Redundancy and Encapsulation; in each case giving a description, principles, practices, pathologies and indications in testing. Finally there's a highly practical section on encapsulating primitives.
If you are relatively new to agile methodologies this book will fill its intended role of providing a set of fundamental principles. It has a readable style and uses diagrams and code to good effect. It is worth reading in its entirety - the appendixes as well as the prelims. And at the end of it you will probably want to carry on reading other titles in the series.
|Last Updated ( Friday, 22 June 2018 )|