|
|
|
|
|
|
|
Implementation Patterns
Kent Beck
|
|
Addison-Wesley Professional
Published: 2007-11-02 |
|
"Implementation Patterns" is a great book to make better Java developers. The focus is to make us think about writing more
readable and maintainable code. Kent Beck accomplishes this by going thru WHY we write things a certain way.
The audience is Java developers who know the basics of the language. If you have more experience, you will understand points
on a deeper level. If you are newer to Java, you will form good habits.
There were just too many things I liked about this book, so here's a list:
- clear, concise and short snippets
- simple, bare-bones diagrams
- discussion on caveats and tradeoffs
- over 100 pages of patterns
- over 75 patterns
- about concepts and OO; not a style guide
- focus on values like communication and simplicity
- section on cross cutting principles like minimizing repetition
- short sections (Kent says some chapters long, but 30 patterns in 30 pages has great subdivision)
- how JUnit 4 design decisions follow theses patterns
- Kent even got in a dig about Sun never removing deprecated code
- bibliography with a blurb from Kent on each title
- pattern index on inside back cover in addition to traditional index
The book can be read straight thru or used as a reference. It's short, light and easy enough that it can be read on an airplane.
(and in this case, it was.) It's also organized enough to go back and read about the pattern relevant at the time.
(Jeanne Boyarsky - Sheriff,
November 2007)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Continuous Integration
Paul Duvall, Steve Matyas, Andrew Glover
|
|
Addison-Wesley Professional
Published: 2007-07-09 |
|
"Continuous Integration" is part of Addison Wesley series. This series includes books like "Refactoring to Patterns". "Continuous
Integration" definitely meets the standards of this series.
Each chapter describes CI related practices. There is a chapter dedicated to risks reduced by CI including anti-patterns like
"It works on my machine." Each chapter ends with questions to get you thinking about CI in YOUR process. I particularly like
how the authors address the "CI is good by my project is special" problem.
The authors give examples in different languages including Java, .NET and Ruby. The appendices on resources and tools are
very useful. The book goes beyond CI and addresses continuous inspection and deployment. My only problem when reading the
book is that I forgot I was supposed to be writing a review. It was so good, I just got caught up in the book!
Do check out the companion website integratebutton.com. It currently contains video examples of three practices described in the book. The materials are presented in slide and
diagram format. It reinforced the book nicely because it was like a guru explaining his experiences. It also goes into much
more detail than the book has room for on each topic.
This is an excellent book and the website adds to it!
* For the JavaRanchers reading this, the first sentence in the book is a quote from Kathy Sierra.
(Jeanne Boyarsky - Sheriff,
August 2007)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Release It!
Michael Nygard
|
|
Pragmatic Bookshelf
Published: 2007-03-30 |
|
Many of the texts on software engineering discuss following some methodology to produce an ideal design. Working developers
quickly learn that the ideal is rarely reality and things happen once we release software out into the wild. Michael Nygard's
"Release It!" picks up where these other books leave off.
Nygard talks about all the things that can and will go wrong in the finely crafted software we were sure was ready for production.
A full two-thirds of the book is focused on capacity and stability issues including patterns and anti-patterns for both.
The remainder of the book deals with general design issues as well as maintaining health and status in an operational system.
"Release It!" provides many first hand accounts to illustrate his points, beginning with the Exception that grounded an airline,
and these stories serve as excellent motivators. It's better to learn from the mistakes of others, and I really appreciated
the detail Nygard went into addressing some of these horror stories.
The Pragmatic Programmers have a few "must read" books and "Release It!" is another one. After reading it and heeding its
advice, you'll feel a bit better knowing that your software is better prepared for the rigors of production.
(Jason Menard - Sheriff,
June 2007)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Time Management for System Administrators
Thomas A. Limoncelli
|
|
O'Reilly Media, Inc.
Published: 2005-11-22 |
|
How many times do you get interrupted from your *main* task in a day? "Time Management for Techies who get Interrupted Frequently"
could have been the title of this book. While the real title of this book is "Time Management for System Administrators,"
it is really useful for any techie who faces interruptions. And that's most of us!
In the preface, the author states: "This book is not for programmers. Beta readers told me that programmers should find this
book extremely useful, but ... deserve their own book." I agree with the beta readers -- developers benefit from this book
plenty. We support production applications, have emergency issues and are frequently called on to answer tech questions.
The book introduces readers to traditional time management concepts in case they are unfamiliar with them. Then the author
adapts those techniques to work well when your priorities change throughout the day. There are also chapters are reducing
stress, e-mail management and automation.
I found the techniques on prioritizing to be much more relevant than the typical time management book. Since the book is not
teaching a technology, it was easier to read than the typical white book with an animal on the cover. The quality is high
as you would expect.
I read this 200 page book in four days. It was hard to put down! How much would you pay to have a better handle on your
time and responsibilities? At $25, this book pays for itself in no time!
(Jeanne Boyarsky - Bartender,
July 2006)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Software Architect Bootcamp
Raphael Malveau, Thomas J. Mowbray
|
|
Prentice Hall PTR
Published: 2003-12-20 |
|
Do you know what an architect does? In the programming world, this title Architect is defined in many different ways, some
that are too low level that they are really just designers, and not architects, in the traditional sense of the word. An Architect
not only looks at technologies and decides which will work best for their project, but they must also define process and standards.
They must understand about human behavior, build teams, and learn to learn quickly. There are many different Architectural
models out there that many aren't aware of like the Zachman Framework or 4+1 Architect.
But most think an architect just draws UML collaboration diagrams.
This is the first time I have read a book on being an architect that surpassed my definitions of what an architect is. I want
to be an architect and this book has taught me much more than I could have thought of.
There are a few rare breed of books that are the top of its class, this book is one of them. If you dream of becoming an Architect
then you must buy this book.
(Mark Spritzler - Sheriff,
November 2005)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Behind Closed Doors: Secrets of Great Management
Johanna Rothman, Esther Derby
|
|
Pragmatic Bookshelf
Published: 2005-09-19 |
|
"Behind Closed Doors: Secrets of Great Management" is a small book with a remarkably big punch. In the book, the authors describe
how a manager can help her team achieve great things by doing the little things well.
The book follows the manager, Sam, of an imaginary IT department in his day to day actions with which he helps his direct
reports overcome -- and sometimes learn about -- issues they're facing in their teams and the organization. These day-to-day
actions are a mixture of techniques for handling difficult conversations, facilitating effective meetings, coaching your coworkers,
and generally working with and for the people you are managing.
I thoroughly enjoyed reading the book and, even though I'm currently working as a consultant, have already been able to apply
some of the techniques at work. For an acting manager, I'd say this book is a must read. Now if only it'd fit in a back pocket...
(Lasse Koskela - Sheriff,
November 2005)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Just Enough Requirements Management
Alan M. Davis
|
|
Dorset House Publishing Company, Incorporated
Published: 2005-05-30 |
|
The primary goal of an information system is to provide a solution to a business problem. The development of such systems
usually involves people from several sectors, such as the IT sector as the solution provider and the business sectors for
which the software solution is being devised. Since the needs are usually expressed by the customer, it becomes immediately
clear that one of the most critical phases of the software development lifecycle is the requirements phase. Failing to efficiently
manage that phase can have disastrous consequences as the implemented solution might not correctly fulfill the customer's
needs.
Alan M. Davis, an award-winning professor, author and entrepreneur, contributes very useful requirements management techniques
for effectively performing and managing requirements elicitation, triage, specification and change. Davis argues that one
of the main points to focus on when managing requirements is to allow computer-savvy IT actors and computer agnostic business
actors to understand each other by using a language that can be understood by both parties and that can be easily adapted
to the relative complexity of the problem and to the available resources.
If you repeatedly find yourself having troubles managing requirements for your information system development projects, or
if you have a hard time communicating with your marketing or business departments or even with your customers, this book will
undoubtedly make your day. If successfully applied, Davis' techniques will definitely have a highly positive impact on both
your budgets and the quality of the delivered solutions.
(Valentin Crettaz - Sheriff,
June 2005)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Subversion in Action
Jeffrey Machols
|
|
Manning Publications
Published: 2004-12-31 |
|
Version control and configuration management is a topic that most software developers know just enough to get by. Branching,
tagging releases, merging changes, etc. are all things people rarely feel comfortable with doing, largely because every version
control system has different ways of doing these tasks. If you're one of those people (like me) and you happen to be using
Subversion, this book should be high up on your shopping list.
Jeffrey Machols does a great job in explaining the fundamental concepts of version control and has injected plenty of tips
for how to accommodate configuration management in a software development process. That's something many tool-oriented books
have lacked, in my experience. In addition to that, Machols gives the most thorough walkthrough of Subversion tools and features
I've seen. File permissions, repository-wide revisions, client commands, administrating the repository, taking backups, setting
up authentication, configuring the standalone server process as well as the Apache module, wiring up commit hooks. There's
very few things missing from this book and the topics that are covered are covered well!
(Lasse Koskela - Sheriff,
February 2005)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Extreme Programming Explained
Kent Beck, Cynthia Andres
|
|
Addison-Wesley Professional
Published: 2004-11-26 |
|
The release 1st edition of this book is still considered by many to be the kick start for the growing adoption of a software
development process called Extreme Programming. After 5 years, the 2nd edition faces a much different world but also with
much different content and approach. The world has learned much and so has the author. I'm glad to see that this 2nd edition
reflects that development.
Beck has revised his thinking throughout the book. Some obvious examples include his current preference towards using ideal
time over abstract time units in estimating, the fifth value among the initial four, the new set of principles, and the rehash
of the practices.
Extreme Programming Explained is not a detailed how-to for adopting the process it describes. Actually, it doesn't really
describe a process at all. What it does describe is a system of values and principles and a set of practices to support these.
Even though Beck does give each practice (divided into primary and corollary practices in the 2nd edition) their share of
explanation, the focus is still strongly on the "what" and "why" instead of the "how".
As someone who has read a dozen books on the topic already, I was delighted to find almost every page to provide something
intriguing that either created or challenged my own thoughts. Especially the latter half of the book, dealing with topics
such as TOC, scaling, Taylorism, the Toyota Production System, and hot potato itself, offshoring, offered a lot to think about.
This is what a 2nd edition should be like, every single chapter reflecting new insight gathered over the years.
(Lasse Koskela - Bartender,
December 2004)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Working Effectively with Legacy Code
Michael Feathers
|
|
Prentice Hall PTR
Published: 2004-10-02 |
|
"Working Effectively with Legacy Code" is a very valuable resource. The author defines "legacy code" as "code without tests."
It doesn't matter whether the code was written last week or ten years ago. There is more emphasis on old code that nobody
understands, mainly because it is messier and harder to work with.
The examples in the book are mainly in C, C++ and Java, but there are a couple in C# and Ruby. While it is essential to
know one of these languages, the author provides enough information to understand the others. When a technique only applies
to a certain language, it is clearly indicated.
The author shows how different diagrams can help you learn how to understand code. In addition to UML, there are dependency
and effect sketches. The author uses these to show how to think about understanding and refactoring. Other tools, such as
refactoring browsers and mocks are explained.
Speaking of refactoring, there are "dependency breaking techniques" (aka refactorings) with step-by-step instructions (Martin
Fowler style) throughout the book. There are also explanations of why patterns and design rules exist. Most importantly,
there are lots and lots of cross-references and an excellent index.
Working with legacy code isn't fun, but this book helps make it as painless as possible. With the split emphasis between
psychological/understanding/techniques and refactoring, this book is both a great read and an excellent reference.
(Jeanne Boyarsky - Bartender,
November 2004)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Hiring the Best Knowledge Workers, Techies and Nerds
Johanna Rothman
|
|
Dorset House Publishing Company, Incorporated
Published: 2004-09-30 |
|
This book is the B-52 of hiring management. Fully loaded with tons of great tips and piloted by the very talented Johanna
Rothman, it will parachute numerous boxes packed with smart and effective tips on the head of hiring officers struggling on
the battlefield. The well organized flight plan will take you through stopovers dealing with recurrent hiring management topics,
such as defining hiring strategies; writing job descriptions; sourcing, selecting and interviewing candidates; creating fool-proof
phone-screens; checking references; hiring technical managers and many more. During the trip, Johanna will hand out numerous
check lists that will help you organize your work more efficiently and prevent you from going too deep into the mud. What's
more, she will share the most common dos and don'ts that you can follow when creating your own job descriptions and offers.
She will also embellish your journey with invaluable and true war stories that she actually experienced during the past twenty
years. If you still manage to be hungry after this reading, you will find plenty of excellent references to other books whose
content nicely complements Johanna's masterpiece.
This 300-pages book enclosing a mountain of priceless information is definitely one of the best books on hiring management
available on the market today. Whether you are a hiring manager in need of some guidance/improvements or a job seeker willing
to put together outstanding job applications to maximize your chances, don't wait any further, get this book NOW!
(Valentin Crettaz - Sheriff,
October 2004)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Pragmatic Project Automation
Mike Clark
|
|
The Pragmatic Programmers
Published: 2004-08 |
|
If you're involved in any type of commercial Java projects, you owe yourself to pick up this book. I'm not kidding.
"Pragmatic Project Automation", the third book in the Pragmatic Programmers' Starter Kit series, authored by Mike Clark,
is an invaluable asset for automating the grunt work of your Java development projects and raising your standards regarding
quality, lead times in bug fixing, and eventually, the motivation of your whole team.
I read the book over a weekend in two sittings and enjoyed every minute of it. Mike has put together a series of high quality
tutorials for setting up a repeatable build process using Ant, scheduling the build process using shell scripts, cron/at,
and eventually CruiseControl, while keeping in the spirit of pragmatic thinking. He then continues by showing how to automate
your release process and software deployment -- with both simple shell scripts and an open source graphical installer tool.
To finish, he talks about different techniques for monitoring your software for errors.
I honestly couldn't find anything to complain about this book -- except that I wouldn't have minded reading another 150 pages
of it.
(Lasse Koskela - Bartender,
September 2004)
|
|
|
The Pragmatic Programmers
Published: 2004-08 |
|
|
This little book could double your productivity by showing you how to make computers actually help you do your job. Do you
spend too much time chasing configuration bugs, following checklists, and performing repetitive tasks that take time away
from your coding and design duties? Then "Pragmatic Project Automation" is for you.
This isn't the kind of "software process" book that tries to sell you on following a methodology. There's no preaching, and
there are no outlandish claims of productivity increases. Instead of selling snake oil, Mike Clark just wants to explain,
in a clear, effective way, how to use open-source tools to automate your builds, release process, and application monitoring.
Java tools like Ant, CruiseControl, and JUnit are the centerpieces of this book, but shell scripts and batch files also make
cameo appearances.
There's even a section on assembling novel monitoring devices. Admit it -- wouldn't it be cool to have red and green Lava
Lamps that light up according to the status of your project build?
The beginning programmer might wonder what all the fuss is about, but anyone tasked with delivering software on a schedule
will appreciate the many ways in which this book will help them.
(Ernest Friedman-Hill - Sheriff,
August 2004)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
The Pragmatic Starter Kit
David Thomas, Andrew Hunt
|
 |
The Pragmatic Programmers, LLC
Published: Sep 2003 |
|
Authors, David Thomas and Andrew Hunt, smashed a home run with their book, "Pragmatic Version Control Using CVS" - the first
volume in the three part "The Pragmatic Starter Kit" series. Using easy to read explanations, examples and stories, this
book clearly explains what version control is, how it works, why folks are using it, how CVS works, and what commands developers
are using during the life of their projects. "Pragmatic Version Control Using CVS" provides the semantics and idioms behind
the syntax found in the CVS Manual. Before reading this book, I was a timid CVS user, willing to do little more than check
code out. Now, after reading the book, I check code out and in, branch, merge and resolve conflicts with confidence. I'd
recommend this book to any developer using a version control system that wouldn't already describe themselves as Zen masters
in the craft, and to any developer not already using a version control system.
"Pragmatic Unit Testing - In Java with JUnit" - the second volume in the three part "The Pragmatic Starter Kit" series" -
from authors, Andrew Hunt and David Thomas, is an excellent introduction to the practice of unit testing - proving that a
piece of code does what the developer intended it to do. If you're a new developer, hopefully you've asked yourself and others
questions about how to establish that your code really works, how to feel confident that it keeps working after scores of
changes have been made, what types of common problems and bugs should you be looking for, where are these problems likely
to be, and what makes a good test. While answering those questions, this book also introduces the practice of testing with
Mock Objects, how to organize the test code in a project, how to better design code for testability, and how to make use of
JUnit for running all these tests. I'd recommend this book as a strong introduction to any developer new to or uncertain about
the art of unit testing.
The third and final volume of "The Pragmatic Starter Kit" series, "Pragmatic Project Automation" by Mike Clark, is an excellent
guide on automating repetitive tasks that increase the quality of a software project, and the productivity and confidence
of the team creating it. (Who wouldn't feel good around a glowing green lava lamp?) If you don't currently employ a system
that automatically checks out your project from a version control system, compiles it, tests it, and reports back to the team
the status of the build, after reading the first three chapters of this book, you'll have all the information you need and
no excuses left not to create such a system. The remaining three chapters of the book are dedicated to teaching creating
push-button releases - facilitating the practice of releasing early and often, to automating installation and deployment,
and to introducing a potpourri of tools and recipes for monitoring and reporting the health of a running system. I'd recommend
this book to any software developer.
These three volumes that comprise "The Pragmatic Starter Kit" are well-written gems that now hold prominent positions on
my bookshelf. The version control, unit testing, and automation practices these books describe are being done by many developers
world-wide for a good reason: they are good things to do. By reading these books, you'll save yourself the cost of learning
invaluable lessons the hard way through years of experience, and learn them from those that have already traveled the web
of software development roads.
(Dirk Schreckmann - Sheriff,
September 2004)
|
|
|
Buy this book
|
|
Agile Project Management: Creating Innovative Products
Jim Highsmith
|
|
Addison-Wesley Professional
Published: 2004-04-16 |
|
Jim Highsmith has managed to write quite a piece of work. "Agile Project Management" contains a valuable catalog of simple
practices that combine to support Highsmith's vision of an agile project's phases: Envision, Speculate, Explore, Adapt, and
Close. Furthermore, as the book's title suggests, these practices can readily be applied to practically any agile project,
be it software, electronics, or airplanes.
The book follows the "APM Framework" through each of the phases, illustrating what the phase is all about and enumerates
through the practices in the APM toolbox. Also, the beginning of each chapter carries a nice little conversation between two
fictional characters which asks the tough questions just when you are about to ask them and gives you a rough answer to guide
your thoughts to the right direction -- with the chapters themselves discussing the topic in detail.
This is one of those must-read titles for someone who's serious about improving on his craft.
I have to confess that Highsmith's award-winning "Adaptive Software Development" has been waiting on my bookshelf untouched
for a long time. Having read APM -- and thoroughly enjoyed every aspect of it -- I can't help but pick it up soon.
(Lasse Koskela - Bartender,
July 2004)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Pragmatic Unit Testing in Java with JUnit
Andy Hunt, Dave Thomas
|
 |
The Pragmatic Programmers, LLC
Published: Sep 2003 |
|
"Pragmatic Unit Testing", the second volume of "The Pragmatic Starter Kit", teaches the developer to code smartly by practicing
a regime of disciplined unit testing. Most books on this subject don't really go too far beyond how to write unit tests.
Where this book stands head and shoulders above the rest though, is the great depth the book goes into showing us exactly
what tests need to be written. Through a series of helpful mnemonics, the reader is taught exactly what to test, how to correctly
test boundary conditions, and what the properties of good tests are. We are also given general testing principles to keep
in mind, as well as questions to ask ourselves about our code while testing. The concepts given herein are invaluable, and
if the book ended with just this, it would be well worth the money.
The book doesn't stop there however. The authors offer excellent advice for integrating unit testing within the scope of
a project in a team environment, and we are given a look at how unit testing can influence design. Exercises are presented
to help the reader practice key concepts throughout the book.
This book is concise, weighing in at around 159 pages. The book is a very quick and pleasant read. It is appropriate for
the novice as well as the developer who's been around the block a couple of times. If you write unit tests, and particularly
if you are new to the game, this book is a cornucopia of wisdom. "Pragmatic Unit Testing" is to the practice of unit testing,
what Joshua Bloch's "Effective Java" is to the Java programming language. That's certainly high praise indeed.
Full version of this review is posted in the "Book reviews" forum.
(Jason Menard - Bartender,
January 2004)
|
|
|
Buy this book
|
|
Facilitator's Guide to Participatory Decision-Making
Sam Kaner
|
|
New Society Publishers
Published: 1996-04 |
|
If you ever attended a meeting about a tough topic, you probably know what an unpleasant experience it can be; doubly so
when the goal of the meeting is to come to a decision.
This book discusses tools and techniques to help a group to find a solution to the problem at hand every attendee can subscribe
to.
The first two chapters explain group dynamics of decision finding meetings and discuss the values of participation. Their
pages can easily be used as slides in a presentation.
After an introduction to the role of the facilitator, there are 15 chapters addressing topics ranging from designing realistic
agendas and chartwriting techniques to dealing with difficult dynamics.
But the value of the book does not come from the individual techniques, but from how they form a coherent whole - from the
underlying theme of fostering diverse thinking and mutual understanding.
It will probably take me years and several rereads to grasp all the wisdom and apply it in practice. I can only recommend
everyone interested in making meetings more effective follows suite.
(Ilja Preuss - Bartender,
January 2004)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Software by Numbers
Mark Denne, Jane Cleland-Huang
|
|
Prentice Hall PTR
Published: 2003-10-18 |
|
"Software by Numbers" is yet another book I would like any manager involved in my working life to read and re-read.
The authors describe an Incremental Funding Method (IFM) for scheduling incremental development of software which optimizes
the Return on Investment (ROI) by having the requirements engineered into Minimum Marketable Features (MMF) with concrete,
monetary value.
The book is very light (less than 200 pages) but packed with interesting material. I read most of the book during a flight
from Finland to Germany and finished the book on my way home. Despite the minimal page count, the authors manage to explain
why their method is desperately needed and how it fits to existing software processes such as RUP and XP. They also describe
the business case for incremental architecture and different strategies for sequencing MMFs and Architectural Elements (AE)
for maximum ROI over the project's lifetime.
The only reason for not giving a full 10 for this book is that I would've needed some more baby-steps support for the actual
calculations (sequence-adjusted net present values etc.). I'm sure others will be hoping to see some more real world examples
of feature deconstruction and sequencing as well. On the other hand, I really appreciate the fact that the authors made the
effort of putting up a spreadsheet online for supporting their method.
Overall, an excellent book. Highly recommended.
(Lasse Koskela - Bartender,
June 2004)
|
|
|
Prentice Hall PTR
Published: 2003-10-18 |
|
|
Finally, a book that applies a solid financial methodology to iterative software development. The basis of this book is
the Incremental Funding Methodology. IFM is not a new software development methodology. It is a funding methodology that
can be applied to your chosen development methodology to maximize ROI through the release of minimum marketable features.
This book starts with the assumption that you are using a methodology such as RUP or XP and builds a case for incremental
funding. It moves on to teach you the tools to maximize the ROI on your project. Methods for moving up the self-funding
date are also in this book. The book ends with 3 application chapters. The first is on how to apply IFM to RUP. The 2nd
is on applying IFM to an agile software methodology. The final chapter is a case study on using IFM. The glossary is excellent
and there is a quick reference guide to IFM as well.
Before reading this book, I was never completely convince that an agile methodology was the way to go. This is the book
I was looking for to complement agile development.
(Matthew Phillips - Bartender,
January 2004)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Pragmatic Version Control Using CVS
David Thomas Andrew Hunt
|
 |
The Pragmatic Programmers, LLC
Published: Sep 2003 |
|
This was such a refreshing tech book to read and use. Being new to CVS myself, I couldn't have asked for a better book.
David Thomas and Andrew Hunt really nailed it with this book which is Volume I of a 3 volume series of "Pragmatic" books.
Pragmatic Version Control begins by telling us what CVS is and why developers should use it. And then it jumps right into
using it beginning with the installation and setting up your first repository and project. 10 minutes after opening the book,
I had setup a repository with my first project. That is what I call useful.
The book continues in this manner by showing you how to use all the commonly used CVS commands to get your work done. There
is no 20 page explanation of how it works or obscure commands you probably will never use. This book takes care of what you
need to know right now to get the job done. There is also a handy CVS command reference at the end of the book.
This book caters to developers who have never used CVS before. But the way it shows you how to use CVS effectively can cater
to even the seasoned CVS veteran.
Pragmatic Version Control Using CVS stands to be the most useful book on my bookshelf, short of the Bible.
(Gregg Bolinger - Bartender,
December 2003)
|
|
|
Buy this book
|
|
The Rational Unified Process Made Easy
Kroll and Kruchten
|
|
Addison-Wesley Professional
Published: 2003-04-18 |
|
This book helps you understand RUP and how to apply it to your projects. Authoritative authors: Kruchten and Kroll are the
top technical and management guys in Rational respectively.
Read chapter 2, which captures the "Spirit of the RUP", the 8 tenets of the RUP philosophy. Master these core concepts, since,
to apply the RUP, it is not sufficient that you know the product components, but you have to understand which ones to apply
and how.
Chapter 3 is most useful. It charts the territory of processes out there (XP, agile processes, heavyweight assessment standards
like CMM), and helps you understand where RUP falls in the picture.
Skip chapter 4, which explains RUP phases in the context of a one-man project.
Chapters 5-9 expound on the 4 RUP phases. Chapter 10 is product-specific. Chapter 11 is extremely important; talks about
adopting RUP in your organization and proposes treating RUP's adoption as a project of its own, applying some sort of "meta-RUP"
on it. Chapter 12 discusses planning an iterative project. Ch. 13 covers "antipatterns" - important reading; some stuff (e.g.
the discussion on what constitutes a bad use case) are useful in a context broader than RUP.
Following are chapters discussing each role's (PM, Architect, Analyst, Developer, Tester) RUP perspective. I liked the discussion
on "Good Enough Quality" in the Tester chapter. A "must-read"!
All in all, a good and useful read. Get it if only for chapters 3, 13, and 18.
(Panagiotis Varlagas - RanchHand,
August 2003)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Peopleware / Productive Projects and Teams
by Tom DeMarco & Timothy Lister
|
|
Dorset House Publishing Company, Incorporated
Published: 1999-02-01 |
|
This is my all-time favorite software engineering book. Peopleware accurately recognizes that software engineering is about
people, not technology. It looks at the many facets of human issues in the software development process, and shows why people
aren't simply cogs in a software development machine.
The book spends a lot of time focusing on teams, and making you appreciate the value of teams. It is not the usual 'teams
are good' BS in a generic management book. Instead it focuses on what makes a good team, and just how hard it is. For managers
trying to build or run a team, this book will help you recognize the skills and techniques you need to do so successfully.
It won't teach you about a development process. It will teach you how to make your development process work by getting you
to recognize the value of people in software development. (But it's not just for managers, I strongly recommend this book
to everyone, from the most junior engineer to the CEO.)
The book also contains large section on the office environment, and provides a lot of strong evidence as to why conventional
wisdom doesn't work. I turn down jobs based on what I've learned from this section alone!
Oh yeah, this book is a little different from most books out there, it provides hard evidence based on years of research.
This book fundamentally changed my views on software engineering!
(Mark A. Herschberg - bartender,
April 2002)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Agile Software Development
by Alistair Cockburn
|
|
Addison-Wesley Professional
Published: 2001-10-22 |
|
Like so many blind men around an elephant, we each have views of Software Development based on our own limited experiences.
In this one of two anchors to the Agile Software Development Series, Alistair Cockburn presents his view: Software Development
is a cooperative game.
From this perspective, Cockburn builds a vocabulary that we can use to identify with and learn from experiences and observations
that he and other practitioners of agile methodologies such as XP, Crystal, Adaptive, Scrum, and FDD have shared throughout
their careers. He shares these experiences and his thoughts about them and how they support his view.
Written for experienced developers and managers, the book makes you reflect on what should be valued for any software development
effort to be successful. Still, less experienced developers would do well to read it if only to gain the vocabulary. The vocabulary
will help you see things that you would have otherwise not noticed. And if you don't notice something, you can't learn from
it.
The appendices are particularly interesting. One discusses the Agile Manifesto and the values it sets forth. Cockburn adds
his own reflections on those values. Another presents three articles that have influenced Cockburn's view and includes, of
all things, the writings of a 17th-century samurai.
This book has me convinced that Cockburn's view comes very close to describing the true nature of the huge and complex beast
that is Software Development. This book should prove useful for many years to come.
(Junilu Lacar - Bartender,
March 2002)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
The Pragmatic Programmer - from journeyman to master
by Andrew Hunt, et al
|
|
Addison-Wesley Professional
Published: 1999-10-30 |
|
One of a very small number of general software development books which disdain the ivory tower of theoretical methodology,
and deal with real, practical issues. It covers a broad sweep of the craft of software development, with examples for a variety
of languages and systems, in a light yet detailed style. I cannot recommed this book highly enough. If you are just embarking
on a career in software development this is a great way to get to the heart of what it's all about. Even if you have been
developing software for years you will find yourself nodding in agreement at some points, smiling at others and wondering
why you never thought of the rest. The pull-out card of 70 "tips" is worth the price alone. Keep this book where you work,
and dip into it. Often.
(Frank Carver - Sherriff,
November 2000)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Software Teamwork: Taking Ownership for Success
Jim Brosseau
|
|
Addison-Wesley Professional
Published: 2007-11-10 |
|
"Software Teamwork: Taking Ownership for Success" isn't just about teams. The book provides tips on the individual, group,
team and stakeholder levels. (A group is defined as interacting with others without being a team.)
I particularly liked the inside cover references. Each of four tables (individual/group/team/stakeholder) that cross reference
the chapter number and four areas (trouble signs, success indicators, questions to ask and tools for support.) These combine
to form 16 icons. The icons are used within the chapters to highlight key concepts or find them later. While this sounds
complicated trying to describe it, it's a case where a picture is worth a thousand words and the concept works very well in
reading/navigating/referencing the book.
I also particularly liked the "how is this relevant?" section that ends each chapter. After the chapter summary, the author
picks key concepts and asks questions to get you thinking about how it applies in your workplace.
I'm always a bit sceptical of books that claim to address everyone involved in the software development process including
managers, developers and stakeholders. This book manages the task impressively.
And finally, the book resonates with problems and phrases used in industry. My favorites are the problem with "and then a
miracle happens" and the repeated emphasis on what "done" means throughout the book. There are good analogies, stories and
examples throughout the book. It was a great read and very informative. I highly recommend this book.
(Jeanne Boyarksy - Sheriff,
December 2007)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Practices of an Agile Developer
Venkat Subramaniam, Andy Hunt
|
|
Pragmatic Bookshelf
Published: 2006-04-04 |
|
"Agility" remains a popular buzzword in the industry. Methodologies, tools, and even programming languages have had the adjective
applied to them. But what does it mean to be an "agile developer"? How do we know if we're "agile"? Should I expect the
ladies to saunter over at parties and say, "I couldn't help noticing that you're agile, how about coming back to my place"?
To answer these questions, a good place to start would be to read "Practices of an Agile Developer".
This book, which could have easily been titled "Forty-five Habits of Highly Agile People", starts out by defining agility
and what it means for something to be agile. It then proceeds to layout forty-five agile practices grouped into seven areas:
Beginning Agility, Feeding Agility, Delivering What Users Want, Agile Feedback, Agile Coding, Agile Debugging, and Agile Collaboration.
Your companions on your journey are a demon whose taunts remind you of how not to do things, and a guardian angel eager to
steer you onto the path of righteous agility. Each practice is well motivated and adequately described. Additionally, each
has sections letting you know what it should feel like if you are following the practice correctly, and how to strike a balance
to keep from going overboard or not far enough when following a particular practice.
While the focus of this book is agility, the practices described really lend themselves well to all developers, even the agility
impaired. Practices such as "Question until you understand" and "Write cohesive code", to name only a couple, are just plain
old good advice for anyone who writes code. So even if you don't aspire to reach the summits of agility, you can look at
this book as a self-help book for developers. Read it, soak in some of the good sense it offers, and be better for it.
(Jason Menard - Sheriff,
May 2006)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Fit for Developing Software
Rick Mugridge, Ward Cunningham
|
|
Prentice Hall PTR
Published: 2005-07-09 |
|
Even though Ward and Rick's book on Fit is the first book available on Fit -- perhaps the most popular acceptance testing
tool among the whole agile community -- and one might be tempted to think it's selling well because of that alone, I'm saying
this book is a hit on its own merits.
I read the beta drafts of the book like many others at the time and was instantly gratified as I read through the table of
contents. Ward and Rick didn't make the mistake of writing a pure tool book. They wrote a book that focuses not just on the
tool itself but also on using the tool. I ordered a hardcopy as soon as it was released. I devoured it, loved it, and am still
using it as a reference today on projects using Fit.
The first part is all about expressing tests with Fit's tables in a way that communicates well. The built-in fixtures are
introduced one by one from the perspective of a test engineer wanting to test different kinds of aspects of a system. The
first time the authors actually show how to run the tests is in chapter 7. This approached proved to be an excellent choice,
as far as I'm concerned. The focus really stays on creating tests without digressions into technical implementation.
After a brief tour through FitNesse, a display of Fitlibrary's power and flexibility, and some miscellaneous topics, Part
2 takes the reader to another level -- the process of turning requirements into Fit tables and the strenghts and benefits
of using a tool like Fit in developing software. This is delivered using an imaginary software project as a vehicle in illustrating
the communication between people while they're honing their acceptance tests.
Part 3 turns the table and puts the developer hat on. In an action-packed 70 pages, the authors show how to write the Java
code backing up all those different kinds of fixture tables we saw in Parts 1 and 2. The discussion is concise and to the
point, covering the fixtures rather well. Having said that, I was left with some open questions regarding extending the built-in
(and Fitlibrary) fixtures, mostly regarding Fit's internal API. That, however, has been a problem with me and Fit since day
one so it's probably just my wiring that's incompatible. Besides, there's more on the internals in the last part of the book.
Part 4 is two-fold. First, we see how the fixtures created in Part 2 look like in Java. There's not too much explanation involved
but I didn't feel like that was an issue. The rest of Part 4 is a mixture of topics such as mocking certain aspects of a system,
making the system's architecture more testing-friendly, and such. I have to say I was a bit disappointed by the mocking section,
having hoped for a more elaborate example rather than sticking to faking system time.
Part 5 starts with a very brief description of Fit's internal API (introducing concepts of Parse object, "more", and so forth,
if you've already taken a peek at Fit's source code) and how to develop custom fixtures. Personally, I would've liked to have
a lot more material on this exact topic but even the brief overview helped solidify some of the things I had picked up here
and there while reading the Fit source code, trying to figure out how to write custom fixtures.
Trying to summarize all that, I'd claim that "Fit for Developing Software" is a must read for anyone involved in using Fit.
It's a tremendous resource, especially considering how little documentation on Fit is available online. The book does have
its deficiencies as well, though. Whereas the (arguably most important) aspect of creating tests is covered extremely well,
the poor fixture developer still has to figure out a lot of stuff out on her own as the custom development topic is not covered
as thoroughly. Still, a great book and a warm recommendation from me.
(Lasse Koskela - Sheriff,
October 2005)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Software Project Secrets: Why Software Projects Fail
George Stepanek
|
|
Apress
Published: 2005-09-01 |
|
How many times have you asked yourself what went wrong in your past software projects? How many times have you successfully
managed to identify the key factors that made these projects derail? Have you noticed anything wrong at all? Have you asked
yourself why software development projects are so difficult to manage and so hard to bring to successful completion?
To answer these questions, Stepanek first enumerates twelve fundamental facts (software is complex, change is inevitable,
etc.) that make software development look so different than any other engineering fields. Secondly, the author lists ten wrong
assumptions (scope can be completely defined, all developers are equivalent, etc.) that are often made by software project
managers. Building on this, Stepanek analyzes three modern project management methodologies (Crystal, XP and RUP) and shows
how they can be used for solving some of the identified issues as well as how they fail to address some of the problems. To
cope with this, Stepanek delivers seven techniques to help you finish your projects on time and on budget. Finally, the author
introduces a case study (made up of real facts) that demonstrates how things can usually go bad and how to make them go well.
If you have already found yourself helpless when answering any of the above questions, this book will definitely provide you
with clear and definite answers as well as a couple useful techniques. Armed with that knowledge and your past experience,
you will become a successful and highly respected project manager.
(Valentin Crettaz - Sheriff,
September 2005)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Five Core Metrics
Lawrence H. Putnam, Ware Myers
|
|
| |
