Product Description

Ship It! is a collection of tips that show the tools and techniques a successful project team has to use, and how to use them well. You'll get quick, easy-to-follow advice on modern practices: which to use, and when they should be applied. This book avoids current fashion trends and marketing hype; instead, readers find page after page of solid advice, all tried and tested in the real world.

Aimed at beginning to intermediate programmers, Ship It! will show you:

• Which tools help, and which don't
• How to keep a project moving
• Approaches to scheduling that work
• How to build developers as well as product
• What's normal on a project, and what's not
• How to manage managers, end-users and sponsors
• Danger signs and how to fix them

Few of the ideas presented here are controversial or extreme; most experienced programmers will agree that this stuff works. Yet 50 to 70 percent of all project teams in the U.S. aren't able to use even these simple, well-accepted practices effectively. This book will help you get started.

Ship It! begins by introducing the common technical infrastructure that every project needs to get the job done. Readers can choose from a variety of recommended technologies according to their skills and budgets. The next sections outline the necessary steps to get software out the door reliably, using well-accepted, easy-to-adopt, best-of-breed practices that really work.

Finally, and most importantly, Ship It! presents common problems that teams face, then offers real-world advice on how to solve them.

Product Details

• Amazon Sales Rank: #167159 in Books
• Published on: 2005-06-01
• Format: Illustrated
• Original language: English
• Number of items: 1
• Binding: Paperback
• 200 pages

About the Author
Jared Richardson and Will Gwaltney have worked in the industry over 20 years, from small startups to the largest privately-held software company in the world.

Customer Reviews

Delivers reflexion for experienced developers.
The book contains 36 practices, which can be applied throughout the development process. The practices are grouped into Techniques, Infrastructure and Process. Each practice ends with a list of checks: warning signs and signs of success are listed. These lists are very valuable in helping to steer and measure the success of a single practice.

The practices are peppered with tips. The book is a quick read and not unnecessarily long, still the practices are explained well and often start with an anecdote encountered by the two authors.

The book might not deliver that much innovation for an experienced developer. Nevertheless it is a good source for reflexion for advanced developers. It has quite some overlap with the The Pragmatic Programmer: From Journeyman to Master book.

My favorite practice is the first one: it says to choose and abandon habits. If a habit does not work, it might be good practice to question it and look for an alternative.

Highy Recommended
If you are familiar with the "The Pragmatic Programmer"(written by Andy Hunt and Dave Thomas) then you will probably recognise the Pragmatic Bookshelf series of books, set up by Hunt and Thomas, in which Ship It! is included. This series of books sets itself apart by emphasising the practical aspects of delivering software, and also doing it well.

The book is split into the following chapters:

* Introduction
* Tools and Infrastructure
* Pragmatic Project Techniques
* Tracer Bullet Development
* Common Problems and How to Fix Them

From the very first chapter, the authors make it clear `Ship It!' is not another methodology, "There is no single, right way to develop software. There are a lot of wrong ways...". Instead, they have gathered together the `best' bits' of various styles and methodologies they have been directly involved with, and combined them into a practical approach with the focus on delivering a project. The authors do not expect you to necessarily implement everything they suggest all at once. Adopt one or two at time and determine if they work in your environment. This practical stance is reinforced throughout the book. A selection of the topics examined can be broadly listed as follows:

* Use source control (for anything you want to keep)
* Automate your build (one click)
* Use continuous integration
* Track issues and features
* Write tests and automate them
* Use mocking
* Build end-to-end stubbed systems (Tracer Bullet Development)
* Build teams and foster communication

It is easy to read and feels fresh. As another reviewer pointed out, "It's a rare book that speaks convincingly to both developers and managers, but this one does a good job". There is a definite emphasis on the positive; it is about how to make projects succeed rather than a post-mortem of why they fail. The chapter "Common Problems and How to Fix Them" is a gem, with practical advice for developers, managers and customers.

In Appendix E: Issue Tracking Systems, I was surprised to see that Gemini from CounterSoft (http://www.countersoft.com/) was not mentioned. I have implemented it at several sites with minimal effort and it has been used by developers and users with great success.

In Tracer bullet development, I agree with the approach to the end-to-end working `stubbed` systems, but I would also add that methods should also be written in such a way that the release version will throw an exception in any method that has not been implemented (rather than just returning a dummy value). Otherwise, years from now, you might find yourself mentioned on the DailyWTF! In some ways, it would have been nice to have had a worked code example for this section, but I realise the authors did not want to limit themselves to one particular language and restrict the reach of this book; I think they made the right decision.

If you are an experienced developer, then you probably will not find anything revolutionary or truly new amongst its 200 pages, but you might find something that your current routine is missing. Is this book worth reading? Absolutely. I would not hesitate for a moment in saying go out and buy it. Highly recommended.

I rather choose joel
I liked the book and It is not expensive at all. It is really useful as a check list on things you need to deploy in your software development process. It will not be easy but for sure it payoff.

However, If you want a more tangential and funny approach to the same issues It could be interesting to read "Joel on Software".