Better Software Faster

Rating:
Summary: Clear and pragmatic, an excellent companion.
Review: Better Software Faster provides an excellent, clear and pragmatic approach to developing complex systems. Not only is the book the most useful tool companion that I have ever read, it also identifies and explores the key issues that face software development teams today without overloading the reader with academic process.

BSF challenges each unit of process to prove it's value before it is accepted into the team's software development environment - following the school of "build it up" with the essentials, rather than "strip down" that many process users are accustomed to.

Along with a truly in-depth guide to using Together, and a pragmatic development process, BSF explores issues of domain modeling, requirements modeling (functional and non-functional), cost estimation, and quality from a base of practical experience.

A true informational heavyweight, each chapter is littered with experiential pop-ups where the authors share some great insight. Clearly a lot of thought has gone into this - a sit-down read.

Rating:
Summary: Clear and pragmatic, an excellent companion.
Review: Better Software Faster provides an excellent, clear and pragmatic approach to developing complex systems. Not only is the book the most useful tool companion that I have ever read, it also identifies and explores the key issues that face software development teams today without overloading the reader with academic process.

BSF challenges each unit of process to prove it's value before it is accepted into the team's software development environment - following the school of "build it up" with the essentials, rather than "strip down" that many process users are accustomed to.

Along with a truly in-depth guide to using Together, and a pragmatic development process, BSF explores issues of domain modeling, requirements modeling (functional and non-functional), cost estimation, and quality from a base of practical experience.

A true informational heavyweight, each chapter is littered with experiential pop-ups where the authors share some great insight. Clearly a lot of thought has gone into this - a sit-down read.

Rating:
Summary: A Reference Book for System Development Teams
Review: I had great pleasure and interest reading "Better Software Faster". The great value and uniqueness of this book is that it presents in a comprehensive way a development process, the tool that supports it and the main techniques to accomplish each step. The presentation is made easy to read through an example which is clear, complete and which works.

The book also addresses some key technical points that I have never seen addressed elsewhere.

It should be the reference book of each system development team.

Rating:
Summary: Something worthwhile on nearly every page
Review: I have read good books about how to develop software, but this one goes to another level. It gives a lucid explanation of the principles that are needed to understand and manage the reality of iterative and evolutionary software development. That's right - this book doesn't ask you to learn some new methodology for software development. Rather it gives you principles that will make sense whatever process you are working.

While identifying key ideas behind good software processes, it is also eminently practical - the authors obviously enjoy making software that works. The book includes a significant application, complete with requirements model and a full suite of tests. This is an example that teaches.

As an added bonus the book demonstrates how to put these principles to good use with Together ControlCenter. As far as I know, it it is the ONLY book out there to deal with the single-source, single model approach that Together allows.

Finally, as an experienced Together user I was pleased to find the book uses side bars and appendices to share plenty of advanced tips and tricks too.

Rating:
Summary: Down-to-eath, pragmatic, readable
Review: This book felt like a fresh breeze on a subject that has been dragged ad infinitum through a morass of books on this methodology or that process. It is not another methodology, nor is it merely a process (though there are solid roots in proven methodologies and processes).

The book impresses most with its down-to-earth practicality. Developers should quickly recognize the authors as two of their own who have spent a lot of time out there in the trenches. I helped review the manuscript for the publisher, and I found myself constantly distracted from the task of looking for problems in the text because I kept on highlighting interesting stuff that I wanted to go back to. I learned much then, and I am still learning.

The work is jam-packed with highly pragmatic advice, based on long experience, on how to tackle object-based, distributed development projects using a readily available development environment. (TogetherSoft's Together ControlCenter is the authors' weapon of choice... as far as I know it's the first third-party book to focus on this killer development platform. For TCC users, the book is probably worth it's price for the expert tips and tricks alone.)

Example abounds. The authors have built a reasonably robust distributed application (for an auto servicing shop), with both local and internet-based clients, around which the text revolves. (You can download the source code free from the book's website.) The language is Java, and the focus is on building distributed applications in a team setting.

Anyone relatively new to distributed apps (as I am), especially corporate developers and project managers, will probably benefit most from this book, though I think even the most seasoned veterans could find some interesting tidbits (artifact management and ControlCenter tips, for example).

Rating:
Summary: How to write quality software with the Together CASE tool
Review: This is a great book. Ever since I first evaluated the Together case tool I have thought it was a powerful tool, but this book has shown me many other useful features it has and practical ways to develop top quality software.

In the recent past, CASE tools have received a bad name because their return on investment has seemed poor. Project managers see the developers discarding the detailed UML diagrams painstakingly developed by the analysts and have, by default, encouraged a hack and slash methodology where the resulting code may be rapidly developed but is poorly tested and ultimately disappoints the end users who have to use it. The maintenance team is also horrified with the lack of quality and documentation.

Many companies are slowly discovering Together's big advantage over other CASE tools; that the source code is always fully synchronised with the UML Model. This means that the class diagrams and other UML diagrams used by the analyst never get left to gather dust on the shelf and the documentation will never get out of date. No longer is there a Chinese wall between the architects and analysts and the developers who write the code. The authors demonstrate the power of this code synchronisation feature with their case study.

You have to download the case study available from the accompanying web site. It's very detailed, more detailed in fact than many similar models that I've come across for other tools. There is much to be learnt by following the discussions, examining the code, running and testing the application. It's like suddenly finding yourself in the middle of a real project.

It's all too common to find object-oriented development projects managed by project managers who are not familiar with the iterative and incremental approach that is used. They often fear the continual changes and refactoring of the same classes over several iterations, especially when they thought the class coding was 'one and done'! This book will help them understand what the authors call the 'Perturbation Change Model'. The word perturbation is a bit of a tongue twister, but the authors make the principle simple and elegant. I've always wondered why every software project doesn't already do this. Project managers will be convinced that quality software doesn't cost money but will actually save money and time in the long run.

The focus on making evolutionary changes to the code so that a fully tested and high quality application emerges is described in detail in the sections on the built in Patterns, JUnit testing framework, Metrics, Audit reports and documentation.

In the appendix, the authors describe many useful modules they have developed to extend the functionality of the Together tool. I can't wait to try these out. The only feature the authors haven't written about is the new User Interface Builder that is now part of Together version 6.0. I guess this will be covered in their next book.

I recommend you read this book and be inspired.