• Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other Pie Elite all forums
this forum made possible by our volunteer staff, including ...
  • Campbell Ritchie
  • Ron McLeod
  • Liutauras Vilda
  • Paul Clapham
  • paul wheaton
  • Tim Cooke
  • Devaka Cooray
  • Rob Spoor
Saloon Keepers:
  • Stephan van Hulst
  • Tim Holloway
  • Tim Moores
  • Carey Brown
  • Mikalai Zaikin
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Image from Goodreads
Title: Essential Skills for the Agile Developer: A Guide to Better Programming and Design
Author(s): Alan Shalloway, Scott Bain, Ken Pugh, and Amir Kolsky
Publisher: Addison-Wesley Professional
Category: Design Patterns, UML, and Refactoring


Addison-Wesley Professional wrote:Agile has become today’s dominant software development paradigm, but agile methods remain difficult to measure and improve. Essential Skills for the Agile Developer fills this gap from the bottom up, teaching proven techniques for assessing and optimizing both individual and team agile practices.

Written by four principals of Net Objectives—one of the world’s leading agile training and consulting firms—this book reflects their unsurpassed experience helping organizations transition to agile. It focuses on the specific actions and insights that can deliver the greatest design and programming improvements with economical investment.

The authors reveal key factors associated with successful agile projects and offer practical ways to measure them. Through actual examples, they address principles, attitudes, habits, technical practices, and design considerations—and above all, show how to bring all these together to deliver higher-value software. Using the authors’ techniques, managers and teams can optimize the whole organization and the whole product across its entire lifecycle.

Essential Skills for the Agile Developer shows how to

* Perform programming by intention
* Separate use from construction
* Consider testability before writing code
* Avoid over- and under-design
* Succeed with Acceptance Test Driven Development (ATDD)
* Minimize complexity and rework
* Use encapsulation more effectively and systematically
* Know when and how to use inheritance
* Prepare for change more successfully
* Perform continuous integration more successfully
* Master powerful best practices for design and refactoring

Book Preview (when available)

From the publisher
  • Chapter 8: Avoid Over- and Under-Design (HTML or PDF)

  • Where to get it?
  • Amazon.com
  • InformIT

  • Related Websites
  • Website: Net Objectives
    Posts: 4568
    • Mark post as helpful
    • send pies
      Number of slices to send:
      Optional 'thank-you' note:
    • Quote
    • Report post to moderator
    Rating: I give this book 9 out of 10 horseshoes

    This book is aimed at developers beginning to work in an agile way, and lays out a set of principles and practices for design and programming that will help them succeed. Although really, most of them are more generally applicable than that: this is all about "good design", with an emphasis producing code that is easy to change. As a developer with relatively little experience of agile methods, I was a bit surprised how much of this was relevant to my own work. The main difference that the agile focus seems to make is when to do things, not how.

    Key subjects covered include: programming by intention, separating use from construction, and acceptance-test driven development. Encapsulation is a theme running through the book, and they take a wide view of what this actually means, interpreting established design patterns as encapsulations of some particular concept so that it is easier to adapt. The book isn't tightly coupled to a particular programming language, although it's usually considering an object-oriented approach. Examples are generally Java/C#, with occasional comments about other languages, but most of the time it's talking about more general principles. The examples are clear and easy to understand.

    It's certainly readable and useful. My one real criticism is that it's occasionally a bit repetitive. Sometimes that's simply a natural result of way the different concepts under discussion interact, but there are times it seems unnecessary (one small example: a comment about the origin of the "extends" keyword in Java appears twice). Perhaps that's a danger in a multi-authored book? But that's a small fault in an otherwise excellent book.

    Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.
    Posts: 3225
    IntelliJ IDE Oracle Spring Chrome Java
    • Mark post as helpful
    • send pies
      Number of slices to send:
      Optional 'thank-you' note:
    • Quote
    • Report post to moderator
    Rating: I give this book 9 out of 10 horseshoes

    This book does justice to its title and subtitle- it clearly tells you the basic design principles to write good code which is easy to read, debug and extend. At first glance the title may seem misleading as it uses the word "Agile Developer" but there isn't much specific to agile in the book, though familiarity with terms like Scrum or Kanaban or TDD would be an added advantage.

    Salient features of the book:
    - Emphasis is on the basic design principles like Cohesion, Coupling, Encapsulation, Redundancy, Coding to Interface. These are further built upon to introduce/redefine the ideas.
    - Covers each concept in depth and with the aid of repetition of concepts helps in grooving them into the developers mind.
    - References to other Books which cover a referred concept in depth which can help in in-depth study.
    - Appendices with extra information to aid in better understanding.
    - Concepts explained with simple examples to drive home the concept.

    Few gotchas:
    - People not familiar with coding/new to it might not find the book very appealing, hence I would recommend the book to someone who has worked on a large codebase and may be some legacy code (not dating back to 80s).
    - Suggestion would be to read the Appendix first, might help for people who are not familiar with UML notation. Basic design principles are also explained there.
    - Familiarity with GoF design patterns is a PLUS, as these have been referred all over the book.
    - One can visit the references provided in each chapter to read up more.

    So, if you are thinking of picking this book- I would say go ahead, you can always re-read it to refresh the concepts.

    Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.
    Posts: 9704
    Android Google Web Toolkit Hibernate IntelliJ IDE Spring Java
    • Mark post as helpful
    • send pies
      Number of slices to send:
      Optional 'thank-you' note:
    • Quote
    • Report post to moderator
    Rating : I give this book 8 out of 10 horseshoes

    This is a very good book for anyone who has to makes design decisions in development. It describes different approaches to design and development and the pros and cons of each approach. For example the book tells you where to use inheritance and where to use delegation. Its not a design patterns book, rather it describes different programming methodologies and techniques which are required in Agile development. The book covers a wide variety of topics which will increase your knowledge by many folds. If you have been in development for some time, you might be familiar with some topics covered in the book as you might already be following them. The techniques described in the book are extremely practical and useful.

    The book is easy to follow on most places. There are however some chapters which are a little confusing. Specifically the examples in the Needs vs Capabilities interface are not easy to follow and relate to in real life scenario. It also took me some time to figure out what Shalloway's Law described in a chapter meant. Other than that all other chapters are easy to understand with the examples and diagrams. The Appendixes are also useful for beginners.

    Overall this is a very good book and is a very good read for any developer who has some experience in development.

    Disclosure: I received a review copy of this book from the publisher for reviewing it on behalf of CodeRanch.
    There is no greater crime than stealing somebody's best friend. I miss you tiny ad:
    a bit of art, as a gift, the permaculture playing cards
      Bookmark Topic Watch Topic
    • New Topic