Suggested Books
Index to Book Recommendations
| Publications | SCM Patterns | Suggested Books | Community | Software Development | About this site |
|
berczuk.com Home
Suggested Books
Index to Book Recommendations
|
Manage It! will help you understand how to manage projects effectively, taking into account the needs of the people working on the project as well as the needs of the business sponsors. In this regard Johanna Rothman follows in the steps of authors like Jerry Weinberg by showing you how to set up a project environment that helps software developers be more effective and thus be better able to deliver value to their customers. This book has pragmatic advice on how to make progress and issues visible, how to plan a project, and most everything else you need to help a project come to a good conclusion. This book is unique in that while it discusses the benefits of agile lifecycles, it shows you how to make progress in a variety of software lifecycles, and gives advice on when to use the various lifecycles she discusses. Buy this book if you want to be a more effective project manager (or technical lead who works with project managers), or if you want to be more agile but are not sure how.
This a classic book that anyone who build computer systems should read. Some of the specific examples are dated, though many caused me to nod in acknowledgment, especially his observations about alarm clocks and TV remotes, Inmates describes goal directed design, the concept of Pesonas, ideas which, whether they make sense for your project are not, are ones that you should be aware of. This book also explains what "polite software" is and emphasizes the market advantages to good interaction design. Even if this book doesn't change the way you work, it will help you think about the relationship between interaction design and programming. Among the interesting points Cooper makes are Customer Driven isn't aways the best model (customer influenced is better), and neither is Engineering Driven; software designers should go beyond customers say they want and help them to understand what they need. There were a few things towards the end of the book that struck me as just wrong. For example Cooper says that most developers don't believe that they are the best people to test their code. Most Agile software developers would challenge that point. Agile developers would also challenge the recurring theme that the engineering team can't make the leap to understanding the customer enough to build good interaction design. He ignores the value of a specializing generalist, which is an important concept in today's projects. Regardless, this is a book that anyone building software systems should read, if only to understand the concepts underlying interaction design.
Implementing Lean Software Development is an essential resource if you want to understand the value of lean software development. It explains the theory of lean manaufacturing and how it applies to software development. It contains practical advice for implementing Lean and anecdotes to help you to understand the value of Lean. This is a great addition to the library of any agile developer or project manager.
A Wicked Problem is a problem where some of the solution space lies within the problem space; the problem is only fully understood after it is solved. Thsi book describes how many programming problems fall into the catgegory of wicked problems and how waterfall softwarae development practices are not well suited to these kinds of problems.This book explains how agille approaches are more suited for many software development projects. In addition to all of this, this book had many excellent references.
This is a how-to guide for doing Software Configuration Management with Perforce. In addition to describing hpw the various commands work this book helps you understand how to structure your version control system to use Perforce effectively. This book describes not only how to create branches, but why, and what policy to have on the branch. The Channelling the Flow of Change chapter is a great introduction to change management concepts in general. Buy this book if you are using Perforce as your SCM solution, or even if you are evaluating multiple solutions, and Perforce is a candidate, as this book will help you understand how to structure your environment for effective development.
This book is an excellent overview of why Continuous Integration is important and about more than just compiling frequently. The book helps you to understand why to do CI, what you can do beyond building, and how to do it. In addition to general principles, the book points you to some excellent tools and resources. This book is an excellent companion to Software Configuration Management Patterns; it provides teriffic information that support the build patterns in that book.
This book helps you to understand why creating production ready code requires work at many levels: creating the deployment architecture, operations scenarios, and just plain writing code and testing. The book covers issues that every architect, developer and release engineer should know. The book has principles, patterns, and resources to help you identify production problems, prevent them, and survive them when all else fails.
One of the better features of the book is the stories that help you to understand issues and demonstrate that Nygard's lessons are based in experience. The lessons are (as the name of the series suggests) pragmatic, and each chapter leaves you with enough information to make changes to improve your application.
In books of this sort there is a balance between "principles" that are timeless and "how to" techniques that you can use immediately. This book is biased slightly towards Java, and contains a few references to current tools, there are enough general principles that there is little in the book that will date it.
As I read the book I found information about many topics that arose in each project that I have worked on, as well as things that I felt that I needed to learn more about.
After I finished the book I felt energized to do things better. If you build enterprise applications buy this book to learn how to build more production-ready applications. If you already know the lessons in the book, buy a copy or two for your colleagues who may not so that your life will be easier and you can get fewer late-night phone calls about a system you helped build.
If you need a good overview of what it takes to deliver software, give this book a look. It is easy to read, clearly written, and covers the important stuff. The book is geared at people who are less than experts, and as such covers some of the topics very briefly, but the book has some excellent pointers to other sources. The authors do a great job of collecting pointers to resources where you can learn more; you will want to keep the book around as a reference for them. The authors talk about a form of agile development that emphasizes tracer bullet development and a feature-based (as opposed to time boxed) approach to setting a delivery schedule. I tend to think that time boxed approaches are more useful, but the other good information in the book still makes sense if you use any approach to developing software. The authors also have some very practical advice on tool selection. The tools and infrastructure section of the book have pragmatic advice on how to implement the patterns in the Software Configuration Management Patterns book, and I wish that the authors had referenced the SCM Patterns book, if for no other reason than to help establish a common vocabulary in our domain. Over all, this is worth a read to learn (or reenforce) some of the basics about keeping a project running well. And if you already know everything in the book, buy a copy for your colleagues who don't!
People and cultures seem to many things that don't make sense in retrospect. This book asks and attempts to answer the question of why once successful societies disappeared. Diamond combines an historical perspective with a discussion of modern day comunities so that we can see the parallels, and perhaps make better decisions in the future. While not an easy read, Diamond makes a complicated subject very approachable. This is a thought-provoking book that you should read if you are interested in society, the environment, or even just general decision making processes (if whole cultures can make decisions that cause them to fail, what can we expect from organizations!).
Robinson's books are imaginative stories which have their roots in fact and then explore what-if scenarios. Fourty Signs of Rain is part of a trilogy that explores the consequences of global warming. The story line has global implications, but the story is told from the perspective of a few characters who are leading somewhat ordinary lives in the midst of a changing world. The book combines fact, humor, and a lively style for a great read.
This is the second book in a trilogy that starts with Fourty Signs of Rain. This book is even more compelling and entertaining that the first book in the trilogy. Robinson again combines fact, humor, and real characters to entertain and educate.
This clearly written book provides insights into some common and vexing problems about how to do estimation and planning. This book helps you to prioritize what you want to build as well as as how long it will take to build it. The facts are complimented with stories from Mike Cohn's experience, which makes this book entertaining as well as informative. Much of the information in the book sounds obvious, but since few projects get estimation, scoping and planning right, it's pretty clear that it's only obvious in retospect. This book is a must have for people who are running agile teams and those who play the role of product owners. It will remain a useful reference througout the project. Even those on non-agile teams will find the chapters on selecting and prioritizing features useful.
Like the other Pragmatic Programmer books, this is an excellent resource for getting started using subversion
This book explains, in detail, the value of having a tester role on an XP project. Much of what is written on XP focuses on the role of developers in writing tests, and this book will help you understand the value that testing professionals can add to an XP, or other agile, project. The function of a tester changes when a team applies XP; In the spirt of lean software development, this book shows you how to apply the skills of testers in a new environment. One minor flaw in the book is that it is targeted at testers. While testers need to understand how to apply their skills to an XP environment, others such as Coaches, programmers and project managers also need to understand the value of testers. Get this book to understand how testers can improve your XP project.
This is an excellent book about how to develop software
quickly in the face of changing requirements, and the definitive
description of what Extreme Programming is. The second edition
reflects the experience of doing XP for the 5 years since the
first edition came out. This edition clearly explains the
relationships between principles, practices and values, which is a
frequent topic of discussion in the XP community. Extreme
Programming Explained, 2nd Edition is really about the human side
of programming; With this book Kent Beck has earned a seat next to
Jerry Weinberg as someone who understands how to apply an
understanding of human nature to the problem of how to build
software effectively. Get this book if you want to apply XP in
your organization, or even if you simply want to improve your
practices; there is much to learn from the XP approach, even if
you can not, or will not, apply it fully.
This book shows you how to apply patterns and
refactorings to the task of untangling legacy code so that you can
apply effective techniques like test driven development as you
change the code. Since there will always be legacy code, this is a
very practical book. The author emphasises the role of testing as
a change enabler in a way that echos the the ideas in the SCM
Patterns book.
The material in this book is excellent, having been developed over a
number of years. In addition to wonderful, well written, patterns that
advise you on how to spread ideas, this books is full of stories that
help you to understand how to use the patterns effectively to influence people,
overcome roadblocks, and spread new ideas. Anyone who has new ideas to
share will benefit from this book including: Managers and Team
members, Professionals and Volunteers, people in industry and those in
community organizations.
If you work with or live with other people you should read this book. It is filled with information on understanding how communication gaps happen, and practical advice for resolving commuunications issues with other people. Most of the advice seems obvious, yet it if often the obvious that one needs to be reminded of. Among the extremely practical bits of information in the book is are dicussions of communication models (so that you can understand why communication might break down), and a chapter on how to write Service Level Agreements.
Get this book both as an introduction to what JUnit
can do for you and also as a reference when you are looking
for information on how to solve a particular testing
problem. The book covers the basics of using JUnit as well as issues around database and J2EE testing. It is filled with pointers to many frameworks and resources that can simplify your testing experience. This is not just a testing cookbook. J.B. also discusses issues such as how to design for testing (and how that can improve your architecture) as well as what to do when you need to test legacy code. This is an excellent guide to the details of how to use JUnit effectively. 
This book explains why lean manufacturing
works. There is much you can learn about lean software development by
learning about lean thinking in this, more concrete, domain. Read this
book to learn the more general concepts of lean production so that you
can better understand them and better explain them to your software
development colleagues and management.
Developing a language to enable communication
between team memembers and with domain experts seems like a
common enough idea. Most teams do not do this and start their
application by solving technology problems. This book
describes the utility of a domain-driven approach to building
systems and shows you how to apply this approach
effectively. This book makes excellent use of patterns to
demonstrate how design, architecture and development practices
such as continuous integration interact with each other to
determine how good your application will be. Like all good
patterns books, the information in this book seems obvious
once you read it. But it is material most people overlook. Buy
this books to understand the value of a domain driven
approach, or if you already understand that, use it as a guide
for teaching others.
People build software systems in organizations, and
the interesting problems often occur at the places where
technology issues and people issues intersect. An
understanding of how software organizations work is
essential to building good software systems. Coplien and
Harrison are two of the pioneers in writing patterns about software
organizations, and this book is a useful guide to helping you
understand how to build effective software development
organizations. 
This book is about running requirements workshops and
more. Requirements workshops are an important tool for understanding
what you need to build. The techniques in this book will be useful in
many other group discussion settings, and will help you have more
productive meetings. The book discusses, among other things, roles in
workshops and decision rules (deciding how to decide). Each chapter
ends with a list of excellent references that you can use to probe
further on techniques. Anyone who is involved in group decision making
should own a copy of this book, read it, and refer back to it
often.
This book helped me understand more details about how to implement
Scrum. The combines some simple overviews of Scrum rules and practices
with case studies. The rules of Scrum are simple. Apply these rules in
your context can be tricky. I found that the case studies that thread
throughout the book really helped me to understand some of the nuances
of the Scrum process. And if you want a checklist, there is a appendix
that summarizes the rules of Scrum. This is a great book if you want to learn about Scrum as a project management tool, or if you have been trying to use Scrum and want a chance to renew your understanding.
Prag Auto is an excellent companion to the Scm patterns book if you are doing Java Dev. It uses simple examples to show you how to set up a private workspace, integration build , release line among others. using open source tools. I wish that the book had referenced the patterns by name so as to set up a common vocabulary.
Dave Thomas and Andy Hunt have written an excellent book, Pragmatic Version Control which explains how to use CVS in a basic and effective way. This book is an excellent companion to the SCM Patterns Book.
This is an excellent summary of the UML, and a great guide to how to
express OO models using the UML. If you buy only one UML book, get this one.
It The third edition is updated to the UML 2.0 spec. Fowler explains that
the book is best for people who want to sketch UML diagrams to explain their
designs, rather than who want to use UML for formally, but that may well be
all you need to do with UML. This book also explains some key concepts
of OO design. Every software developer should have a copy of
this book on their shelves!
This is an excellent guide to writing User Stories. In addition to explaining what user stories are and how to write them, the book shows you how user stories fit into the development process and answers many of the common questions that arise when one starts writing stories. If you want to start using stories as part of your development process, buy this book; you'll want to read it and have it around for reference later.
This is a good book to learn about how to use JSTL. It has an excellent reference section, and the body of the book explains how to use the JSTL tags with many good example. On the whole, a very useful, readable book. One negative: The author has a sense of humor which some might find odd, and he interjects it throughout the book; at times it's distracting. But if you can get past that, you'll find this to be a good resource.
I read this book after working on Struts
applications for a few months, and it added understanding to
my knowledge about Struts applications. I marked many pages
that illustrated approaches that I wanted to use on my
projects, either because my team had problems with that aspect
of Struts, or because the approach in the book seemed
better. In addition to explaining how to build Struts
applications, it also provides good, practical, advice about
structuring your Struts applications so that they are
maintainable and understandable. I refer to this book often,
and it is an excellent complement to the online
documentation.
This book will serve you well whether you know
Patterns and are trying to learn C# or know C# and are trying to
understand Patterns better. It is not a replacement for the Design
Patterns Book or a good C+ reference, but it is an excellent companion
for both. 
Finding the path to the right process for your project
and organization is tricky, and this book provides a map of the
terrain that can guide you to the implementation appropriate for
your project. This book will guide you through the steps that you
need to take if you need to implement an SCM process for your
organization at an organization, application, or project level.
It includes customizable templates and examples to more quickly
get you to your SCM goals.
This book answers many common questions about Pair Programming and supports the answers with data and stories. This is a very readable book, and will be an excellent resource for anyone trying to implement pair programming, or convince others of its usefulness in appropriate situations.
SQL for Smarties is a book that you should own if you work with relational databases. It has good practical advice and good examples. It is useful both for improving your SQL skills and as a reference.
Project Retrospectives is a must have for anyone who wants(or needs)to understand what happened on their last project. If you plan to conduct a retrospective, the book will show you how with exercises to use with your group. Even if you do not run formal retrospectives, the techniques in this book will help you get a more candid view of how things on your project work.
In this book McBreen gives a well reasoned
discussion of what XP is and is not, when it works and when it
might not work. The book is positive about the merits of XP,
when used in the right setting. This book will be valuable to
anyone who is considering changing their development approach,
even is they are not considering Extreme Programming. Both
enthusiast and skeptics alike will find the material in the
book thought provoking.
Planning Extreme Programming gives you advice on how
to fit the XP Planning game, and related aspects into the
larger context. This book will be particularly useful if you
have had to reconcile the XP approach of incremental
development and planning with an organization that takes a
master plan approach.
Extreme Programming Installed describes how to
implement XP practices with practical advice based on
experience. Buy this book when you are ready to implement XP
for your team.
This is one of the most useful books on software architecture that I have read. It discusses the qualities of a good architecture, and how the organization and process relates to the architecture.
This book has a good discussion of various types of codelines, as well as branching and merging strategies. It is clearly written and is a good resource if you want to go into more depth about branching strategies.
The principles that this book discusses: Release,
Collaboration Ensemble and Play are extremely relevant to
creating effective software teams. The principles are inspired
by observing how theatre companies work, but they also have a
basis in lean manufacturing. If you work as a
software developer or manager and have ever worked on a
theatre production (community theatre or at school) a light
will go on immediately. If you haven't The data that the
authors provide about lean manufacturing practices and
software development will convince you that there is a lot
that we can learn from this metaphor. The theatre examples will be
helpful in explaining how the principles work if you need to
communicate them to a manager who does not understand software
development. Buy this book and place it along side your books
on agile software development; you will want to read it and refer
back to it frequently.
Through examples and a collection of patterns, this
book explains what test driven development is, and what it is
for. Every agile developer should read this book.
This is an
excellent discussion of how the principles of Lean
Manufacturing apply to Software Development. The authors
explain why the usual metaphor of software as manufacturing is
not quite right, and why the metaphor of Lean Manufacturing
is. It is well written and will be useful to refer to as a
reference.
Bok discusses the role of violence in popular culture. Aside from having a great title, this book is a very good discussion of the issues and how we can address them.
This book discusses the psychology of optimal
experience, in other words, happiness. This books is
not a how-to book, but rather a why book. Reading this book
may give you great insights into how to enjoy all aspects of
your work and private life.
Excellent book that explains Scrum, one of the more
popular agile development techniques. The approach in this
book is very pragmatic. The authors discuss what Scrum is and
how to apply it in various environments.
All you ever wanted to know about product
management, but were afraid to ask. This book discusses the
relationship between technical-architecture and
marketing-architecture. This is an oft-neglected subject, but
it is important as marketing and technology are both important
for a successful product. This is a great book to read if you
design software systems, or are involved in product
management.
You should buy this book if you have any role in
making decisions about your project. It discusses how how
manage risks and explains why some corporate cultures
discourage risk management, often to their disadvantage. The
writing is very clear. This is a quick and informative
read.
This book is less about how to do SCM than about
what SCM is. It is a great resource to read and to have on
your shelf if you want to understand the scope of SCM. It is
not entirely clear to me why this book is in AW's Agile
series, but it is a worthwhile read so that you can understand
what aspects of more formal SCM that you may be (justifiably)
skipping on your project after you have implemented the
techniques in the SCM Patterns book.
This is a classic book. Everyone involved with software systems: developers, managers, and customers, should read this book.
This is a unique book. It tells you about the
writers workshop process. The writers workshop process has its
origins in the creative writing community, and has been used
in the software patterns community. Richard Gabriel explains
how the process can also be used in other domains where
creative effort is involved, such as reviewing marketing
materials. I book for two reasons. First it provide great
insight into the creative process (as applied to anything) and
the values that are used in the writers workshop can benefit
anyone who creates things, even if they don't use the workshop
process. Second, if you do want to use writers workshops, this
book explains the hows and whys of them. I had been involved
in workshopping software patterns since 1995, and I though
that I pretty much understood what they were about. I learned
a lot reading this book. I recommend this book for anyone who
involved in the creative process(of any sort): Software
engineers, writers, teachers, and students.
This book describes Essential SCM
practices. Developers, team leaders and those just learning about
software configuration management should find this book
useful.
This book is an excellent collection of tools to have
available when designing and building enterprise or web
applications. This is more of a patterns collection or pattern
catalog, than a pattern language, but the author ties the patterns
together in a way that makes it possible to compare and contrast the
various approaches. This is also a very readable book. Get a copy,
skim through it to get familiar with what is there, and keep it on
your shelf for ready reference.
This book discusses the differences between a craft
approach and an engineering approach to building software, and the
benefits of using a craft approach to build most software
applications. It is a great book to read to learn how to think about
your career, or how to build a software organization. This book is
not about Agile Development, per se , but if you are interested in
that, you should read this book too because the Agile development
works best when there are people skilled in the craft of software
working on the project.
This is an excellent book that explains very clearly how working longer hours with fewer resources in the quest for efficiency is counter productive for knowledge work, such as software development. This is a quick read, with many interesting stories to support the assertions that the book makes. The book is targeted at managers but also makes the point that leadership can happen at any level in the organization.
An excellent survey to the principles of agile
development approaches such as Extreme Programming , SCRUM,
and others. The book mixes discussions of the core ideas with
interviews with some of the founders of the Agile Alliance
.