|
|
|
|
|
|
|
Head First Design Patterns
Elisabeth A. Freeman, Eric Freeman, Bert Bates, Kathy Sierra
|
|
O'Reilly Media, Inc.
Published: 2004-10-25 |
|
Make sure you read the introduction so that you know what you're getting into, and to realize you're getting into something
great. Rather than being a group of books with little real point of difference, the Head First principles - outlined in the
introduction - are geared towards presenting real problems and real solutions with real learning. But we're supposed to be
talking about Head First Design Patterns.
The list of patterns presented is small compared to other books, but this works well since the coverage is more about learning
the basic patterns well with a solid understanding. Also of great value is the way each pattern is taught by presenting common
problems with the obvious, but wrong, solutions and then leading you out of the hole you dug and highlighting the important
steps towards a better and more maintainable solution.
I was particularly impressed how the presentation of each pattern was built on solid Object Oriented concepts. But rather
than assuming you know these advanced concepts, they are integrated into the learning exercise and presented as a cohesive
bundle. The book is also structured so it refers back to and reinforces both the pattern and OO lessons as you progress.
It's hard to find real fault with the book. At times it jumps between topics, is repetitive and a bit irreverent, but this
is all part of the formula and exactly what is promised.
Beginner or experienced, you better be careful or you might learn something.
(David O'Meara - Bartender,
November 2004)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Fearless Change - Patterns for Introducing New Ideas
Mary Lynn Manns, Linda Rising
|
|
Addison-Wesley
Published: 2004-09-04 |
|
Did you ever struggle to introduce a new idea at your workplace that would make everyone's life easier? Did you ever wonder
how some people actually manage to introduce changes? Then this book is for you.
"Fearless Change" starts by explaining why change is so hard and what we typically miss when we approach change, followed
by an excellent introduction to the broad concept of patterns in general.
The "patterns for introducing new ideas" are then introduced in a sequence of chapters, each dedicated to a specific phase
of the change process - from testing the waters, over getting the first people on board, to convincing the masses and finally
keeping the implemented change alive. One chapter solely discusses how to deal with resistance.
Four experience reports (one about the introduction of the J2EE patterns) then show how the patterns have been successfully
used in concert. The third part of the book contains an alphabetical catalog, describing every aforementioned pattern in detail.
The whole book is quite entertaining to read, every chapter being to the point and at the same time filled with clever quotations
and examples from the trenches. On each page you sense it's not only the experience of the two authors that is to your disposal,
but also that of dozens of people they talked with during the years.
If you want to have an impact on how things are done at your workplace, you should put this book at the top of your reading
list.
(Ilja Preuss - Bartender,
October 2004)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions
Gregor Hohpe, Bobby Woolf
|
|
Addison-Wesley Professional
Published: 2003-10-20 |
|
Enterprise Integration Patterns is part of Addison-Wesley's new Martin Fowler Signature Series, which Fowler's Patterns of
Enterprise Application Architecture (PoEAA) is also a part of. I was very satisfied with PoEAA and the same can be said about
Enterprise Integration Patterns. It has the potential to become a classic.
The authors' writing style is a pleasure to read -- no ambiguous statements, no unnecessary babbling. The book is structured
to suit both cover-to-cover reading and a "dive-in" approach for situations where you're looking for a solution to a particular
problem. After an introduction to the field of enterprise integration, and a discussion of why the book concentrates on the
messaging integration style in particular, the reader is given a hierarchical catalog of patterns revolving around a small
set of "core" patterns. The book's coverage is in my opinion very well scoped.
I must also praise the look of the book; besides the layout being familiar from prior works and the proven pattern catalog
structuring, the authors have used graphics very efficiently. Not only the authors define a vocabulary for integration patterns,
but they have also come up with an expressive visual language for illustrating the patterns using simple notations that can
be easily drawn without CASE tools.
I found only two downsides for this book. First, the title can be slightly misleading as the book focuses on messaging as
an integration style and only briefly mentions alternatives such as RPC, file transfer, and shared databases. However, I don't
know a single person who doesn't read the back cover before buying a book, so I wouldn't count this as a big issue. Furthermore,
the reason for focusing on messaging is thoroughly argued in the book. The second downside is the code examples, which are
presented using varying languages and products and seem somehow disconnected from the text.
In summary, Enterprise Integration Patterns is a great book. It's worth reading and re-reading if you're working with systems
integration projects or writing integration software yourself. Yet another book that makes me think, "I wish I had it back
then..."
(Lasse Koskela - Bartender,
December 2003)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Patterns of Enterprise Application Architecture
Martin Fowler, et al
|
|
Addison-Wesley Professional
Published: 2002-11-15 |
|
Simply put, you can't go wrong with a Martin Fowler book and this one is no exception. If you climbed the mountain to get
advice from the IT guru at the top, he'll probably quote from this book.
Born on the web and rarefied by reviews and discussions with Fowler's colleagues and peers, including JavaRanch bartender
Kyle Brown, this book is full of ideas that will help you make decisions related to enterprise applications architecture.
Writing in the same easy-to-read style as his past works, Fowler presents over fifty patterns that are mainly focused on
layered architectures. And while Fowler readily admits that none of the ideas are new, developers, experienced or otherwise,
will nonetheless benefit from the collective wisdom and experience of Fowler and all who contributed to the book.
To get the most out of this book, be sure to read the introductory chapters and understand the author's intent. There are
many code examples, mostly in Java with a few in C#. I doubt though that you can use the code without some sort of tweaking;
they are all meant to show the core of the pattern. Ultimately, you have the best understanding of your requirements and
you have to make the decisions that affect your application's architecture. To paraphrase Fowler, don't use the examples as
glorified macros but as a way to stimulate your own thinking. And believe me, this book has more than enough to get you thinking.
(Junilu Lacar - Bartender,
March 2003)
|
|
|
Addison-Wesley Professional
Published: 2002-11-15 |
|
|
It's a patterns book, it's by Martin Fowler, and it's good. But how good is it?
It is actually two books in one. This is discussed in the book, but the second half is a list of patterns including the
information required to make them useful. Reasonably standard, except that the patterns are presented in a language neutral
manner that gives Java developers a view into the .Net world and vice versa.
The best part is still the first section. There is a general discussion on enterprise applications including common problems
and ways to solve them depending on the way it shows up in your application. Not all of it will be new to everyone, but I'd
challenge anyone not to learn anything. Even if you don't agree with all the solutions posed, it has very concise coverage
of the problems.
There appeared to be the assumption of a respectable level of experience in the reader, so the book may not be useful to
programmers with less than 3-5 years under their belts. This isn't necessarily a down side, but it should be considered if
you're considering purchasing the book.
Now a small complaint. Although the first section was great, it discussed the patterns from the section in too much detail.
There were some patterns I wasn't familiar with and some that I knew by different names, and it made some sections confusing.
Still well worth a place on the shelf.
(David O'Meara - Bartender,
March 2003)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Patterns for Time-Triggered Embedded Systems
by Michael J. Pont
|
|
Addison-Wesley Professional
Published: 2001-07-12 |
|
Not your typically software patterns book. Real engineering, hardware and software making stuff happen! Yeah!
Probably the best example that I've ever seen of how patterns should be described and discussed, clear, concise, and with
sufficient background to make each pattern feel meaningful and complete.
While this book deals specifically with the 8051 family of microcontrollers, almost all of the patterns given are generally
applicable to any microcontroller family.
Even if you're just a software engineer, and even if you don't do embedded work, at least half of this book contains information
that will pique your interest, and cause you to rethink some of your assumptions.
Pretend that you have to write an embedded program that responds in real time and has a bounded response window. Now you
have the choice of a preemptive or cooperative scheduler. (For all you nonhardware folks: A scheduler is a microoperating
system that you either buy of build yourself for your microcontroller.) I'd say most folks would choose the preemptive scheduler.
Needless to say, the patterns in this book give clear guidelines as to which to choose and when. Furthermore, they illustrate
that for the most reliable (most predicable) operation, a cooperative scheduler is probably a better choice. Now think about
some business systems architectures, response times, latency, liveness, robustness, the discussions on embedded schedulers
have relevancy!
The world needs more books of this caliber and utility. If you're even remotely interested in embedded systems, GET THIS
BOOK!
(John Volkar - Greenhorn,
December 2001)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
IT Architectures and Middleware: Strategies for Building Large, Integrated Systems
by Chris Britton
|
|
Addison-Wesley Professional
Published: 2000-12-16 |
|
An excellent coverage of what's, why's and how's of middleware technologies.
The book gives an interesting perspective into the growth of middleware solutions with special focus on enterprise systems
architecture and distributed technologies. The long journey that begins with TP monitors and primitive "transaction machines"
covers a great deal of ground outlining the need-driven evolution of various middleware alternatives and ends with the discussion
of latest - the EJB, .NET and CORBA. There is a special emphasis on the changing landscape brought about by the rise of eCommerce
and the need to manage large-scale enterprise systems.
I love the way author drives home some very complex concepts. This book can serve as an indispensable resource both for
beginners and experienced professionals. While the novice can easily comprehend intricacies of IT architecture, experienced
architects will find a lot of food for throughout and new insights into many issues. I personally had many "ah, what a brilliant
idea" moments. You will find many useful and perhaps unconventional solutions to practical problems. It can even help an IT
manager to understand the real middleware and IT architecture issues and to make intelligent decisions without having to get
deep into technical waters.
Overall, this book is a must have and deserves 10 horseshoes.
(Ajith Kallambella - Sheriff,
December 2001)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Design Patterns Explained: A New Perspective on Object-Oriented Design
by Alan Shalloway, James R. Trott
|
|
Addison-Wesley Professional
Published: 2001-07-09 |
|
I was going to say "read this book", put a period and finish my review, but they didn't allow me to.
This book is a very well written introduction to patterns. Read it before GoF and Cooper books. Read it after, if you want to understand what GoF and Cooper books are about.
I was going to say "this book is more about good design than it is about patterns", but this would be senseless - patterns
are good design. This book doesn't teach you how to "use patterns", it does better - it teaches how to find a good design.
It maps a conceptual level of thinking about design - "good design principles" with an implementation level that happened
to be patterns. Reading about design principles when you do not see how they work on concrete code examples isn't particularly
insightful. Looking at good code if you do not understand principles that underlie it doesn't help either - only makes you
puzzled why it is designed in such a weird way? The magic of this book comes from mapping and tying together these two levels
of thinking. It liberates your mind from thinking on implementation level ("nouns are classes, verbs are methods") and allows
you to think conceptually - "see the forest and the trees" in authors words.
"At this final stage, the patterns are not longer important... The patterns have taught you to be receptive to what is real"
- C.Alexander speaking from the last pages of Design Patterns Explained.
(Margarita Isayeva - Bartender,
October 2001)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
UML Distilled
by Martin Fowler, et al
|
|
Addison-Wesley Professional
Published: 1999-08-25 |
|
The best book on UML. Oh sure, you can buy the three amigos books, take a few years to read them and if you can stay awake,
you might actually retain something. This book is an easy read and answers your practical questions. The author is the same
guy that wrote the "Refactoring" book reviewed on this page. He makes any subject come alive.
(Paul Wheaton ,
January 2000)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Refactoring: Improving the Design of Existing Code
by Martin Fowler, et al
|
|
Addison-Wesley Professional
Published: 1999-07-08 |
|
This is currently my favorite book. It has changed the way I do development because it gave words to the way the I was doing
things and took me even a few steps further! The book discusses the importance of rewriting code NOT to add functionality,
but to add clarity and improved design. There is general discussion as well as a list of specific refactorings. It gives tips
on how to stress the importance of this to managers, or sneak it by them if they might not be so understanding. :) I think
we are going to hear a lot more about refactoring in the next decade. I found the refactorings to be as useful (if not more
so) as design patterns.
(Paul Wheaton,
January 2000)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Emergent Design: The Evolutionary Nature of Professional Software Development
Scott L. Bain
|
|
Addison-Wesley Professional
Published: 2008-03-08 |
|
The author states in the preface that he'd like to push software development as a profession forward by promoting a set of
methodologies that are universally recognized as beneficial. This reviewer thinks he achieves this goal admirably and wishes
he had had access to a book like this when he first started out with object-oriented software development professionally.
A number of what might be called best practices are examined as to why they're useful, how they might best be applied, and
how they deliver value in conjunction with other best practices. Some of these are well-covered by now (e.g. coding style
and patterns), others are somewhat newer (like refactoring, the open-closed principle, unit tests and test driven development).
At each step the author uses a combination of concrete code (mostly in Java, but easily understandable to everyone) and abstract
UML-style diagrams to illustrate what is happening, and what difference a particular technique makes.
One important recurring theme is that the waterfall model of software development is truly dead, and that change of all kind
needs to be embraced in a project, especially including changing requirements. Every software professional will recognize
the value of being able to cope with change, and in this book that's part of the core message at each step. I recommend the
book to get fresh perspectives and new ideas about various parts of the development process, both for developers and managers.
(Ulf Dittmer - Sheriff,
May 2008)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Design Patterns in Java
William C Wake
|
|
Addison-Wesley Professional
Published: 2006-04-28 |
|
It's hard to review this book without mentioning "Design Patterns" by Gamma, Helm, Johnson and Vlissides (known as "Gang of
Four", or "GoF"). Both start with a general intrduction, describe the same 23 patterns, and even have an index of patterns
inside the front cover..
That said, it's the differences which matter. .
GoF chose mainly UML and C++ to describe the patterns in detail. This book considers how these patterns can be used in Java.
That in itself is significant (at least if you use Java), but there is also a strong difference in style between the two books..
GoF is dry and academic, sometimes requiring a lot of study to understand and apply abstract pattern descriptions. This book,
on the other hand, is much more lively - full of worked examples, self-test problems and puzzles, all set in the context of
a fictional firework manufacturer. This makes it a much more enjoyable read. And if you get stuck, the solutions are all in
the back..
However, this easy-reading, approach has a negative side. The patterns are so comfortable and copyable that subtlety can be
missed. Take Flyweight, for example. Admittedly this is one of the rarer patterns in the wild, but in this book it seemed
more like a recipe for one particular usage than an exploration of possibilities..
In summary, GoF is a crusty classic worthy of anyone's bookshelf, but this book provides a useful and practical introductory
step for anyone working with Java.
(Frank Carver - Sheriff,
May 2006)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Refactoring To Patterns
Joshua Kerievsky
|
|
Addison-Wesley Professional
Published: 2004-08-15 |
|
A high quality reference for those that want to gain some direction to their refactoring. That's what Joshua Kerievsky has
managed to create with this book. This book assumes that you already know about refactoring and even states clearly that this
book is best read with Martin Fowler's "Refactoring" as a reference. With that prerequisite in mind, this text does an excellent
job of introducing the process of using refactorings to fix code problems by introducing patterns into your design.
Some of the strongest points include: editing, organization, and clarity. My hat goes off to the editor(s) of this book as
I found very few errors even though this book contains a lot of "real world" code. Organizationally, this book does an excellent
job of making itself useful as a "read-through" book for those that want to immerse themselves in the topic and as a reference
book that can sit on your shelf until you need it.
One word of caution about this book is that it originally started as a paper and grew from there. Especially throughout the
first few chapters of the book, this is very evident. Constant references to works done by other authors and numerous footnotes
can, at times, become a bit distracting from the overall message.
Overall, this is an excellent book and, if you're into extreme programming and refactoring, it's one that you're going to
want to have on your shelf.
(Corey McGlone - Bartender,
October 2004)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Software Architecture Design Patterns in Java
Partha Kuchana
|
|
AUERBACH
Published: 2004-04-22 |
|
Design patterns used to be the hottest topic around a couple of years ago. One of the side-effects was the "Applied Java
Patterns" book which I very much liked and used to recommend to anyone looking for a "GoF" replacement using Java for code
examples. Not anymore. From now on, I'm recommending Kuchana's "Software Architecture Design Patterns in Java".
Why am I so pleased with this book? What makes it any different than other design pattern books? Well, first of all the volume
is huge. Kuchana's book covers all the original Gang of Four patterns plus another 20 or so patterns, including a couple of
multithreading related patterns. Second, the text itself is very readable and doesn't cling too much on fancy words. The explanations
are concise and to the point. Further kudos goes to dealing with such frequently asked questions like the difference between
Factory Method and Abstract Factory.
To list some things I didn't like about this book, I have to say that having exercises without sample answers in the back
was a tiny disappointment and I would've preferred a bit more condensed font for the code listings. That's about it.
All in all, a very good choice for filling the gaping design patterns encyclopedia slot in your bookshelf. Highly recommended.
(Lasse Koskela - Bartender,
August 2004)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Core J2EE Patterns: Best Practices and Design Strategies
|
Second edition
by Deepak Alur, John Crupi, Dan Malks
|
|
Prentice Hall PTR
Published: 2003-05-10 |
|
There are two obvious changes between this second edition and the first edition of this book. First, some new patterns have
been added mostly dealing with web services. Second, the book has been released as a hard cover book, presumably because the
publisher expects this to last on your shelf as long as the original "Design Pattern" book. The new patterns dealing with
web services are a welcome addition to the book although anyone who is interested in this subject will probably want more
detail such as found in Paul Monday's book.
Part 1 is an introduction to design patterns and the J2EE platform followed by a catalog of design considerations, bad practices
and refactorings. Part 2 is the collection of design patterns and strategies. Each pattern is described in a format which
will remind you of the GoF book. Since this has become the standard ormat for presenting design patterns this should not be
a surprise. The patterns are well thought out, explained clearly, and demonstrated with some good code samples. If you have
the first edition you will be very impressed with the improvements made in this new edition. It appears that virtually every
pattern has been reworked to make the pattern easier to understand and use.
This is the book that every J2EE architect and programmer should have on their desk. Anyone designing, architecting, or coding
with J2EE will find this book to be extremely useful.
(Thomas Paul - Sheriff,
August 2003)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
First edition
by Deepak Alur, John Crupi, Dan Malks
|
|
Pearson Education
Published: 2001-06-26 |
|
Not another line of code for Servlets, JSPs, or EJBs should be written by anyone who hasn't read this book and understood
the concepts explained. This book is about best practices in designing and coding J2EE applications. The lessons explained
here were developed by the Sun Java Center based on their work in the field. As they developed applications for clients they
noticed that the same problems occurred over and over again. This book documents the standard solutions to solve these problems
that were built as a catalog of design patterns and best practices.
Part 1 is an introduction to design patterns and the J2EE platform. Part 2 is a catalog of bad practices (the authors describe
these as, "less than optimal ways to solve problems"), and refactorings (ways to correct these problems). Developers working
with poorly designed J2EE applications will find this section especially helpful.
In Part 3, fifteen separate design patterns and strategies are explained. Each pattern is described in detail with the motivation
for using the pattern and the design goals to be achieved. UML class and sequence diagrams are included along with detailed
code examples that serve to further clarify the pattern. These patterns aren't theoretical constructs but rather are practical
strategies that can be applied to real world applications. Using the strategies in this book will make you more productive
and your code easier to understand and maintain.
Anyone designing, architecting, or coding with J2EE will find this book to be extremely useful.
(Thomas Paul - Bartender,
November 2001)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Software Fundamentals: Collected Papers by David L. Parnas
Edited by David M. Weiss and Daniel M. Hoffman
|
|
Addison-Wesley Professional
Published: 2001-04-19 |
|
Anyone who considers themself a Java developer should know who Dave Parnas is. Without the insight of Dave Parnas in the
60s and 70s there would be no such thing as the Java programming language. Ever heard of information hiding (the basis for
all Object Oriented programming)? Yeah, Parnas came up with that. Exception Handling? That's him too. Interfaces? Parnas.
(Get the idea?)
This book reprints 33 of Parnas' most influential papers. Each paper is started off with an introduction from one of Parnas'
peers (like Barry Boehm), giving the paper a connection to the modern state of Software Engineering, and trying to give the
reader an understanding of just how seminal the particular paper was to the world of Computer Science and Software Engineering.
I believe you become a much better programmer if you understand where things come from. Once you understand how things were
before "Information Hiding" came about, you get a better appreciation for why its such a necessary and important practice.
You'll become a better programmer because you're more aware of what would happen if you didn't have exception handling. And
you'll be come a better writer when you understand why buzzwords can be so dangerous in technical papers.
Dave Parnas has been a huge influence over the world of Software Engineering. Everyone should have the chance to read his
work.
(Jessica Sant - Bartender,
June 2003)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Agile Software Development: Principles, Patterns, and Practices
Robert C. Martin with contributions by James W. Newkirk and Robert S. Koss
|
|
Prentice Hall
Published: 2002-10-25 |
|
Agile Software Development is a great Object-Oriented Design book that presents it's subject in the context of Agile Development.
The book delivers solid design and programming advice in a very "light" style. Not light in that it avoids technical detail!
No, Bob seems to have taken the principles of agile development and applied them to the art of technical book writing.
The book is divided into six sections and has four appendices. There are many UML diagrams and lots of code examples in C++
and Java. If you don't know UML two of the appendices will introduce you to it. The book takes a top down approach. You are
first given a quick overview of agile development practices. I particularly liked the Testing and A Programming Episode chapters
from this section. The second section presents five high-level design principles that every developer should learn and apply.
Case studies dealing with a payroll system, weather station software, and testing software are then presented. Each case
study section starts by discussing the design patterns that will seen in the case study. Section Four discusses subdividing
the payroll system into packages. Six principles and a set of package Dependency Management metrics are covered. The book
wraps up with the two UML appendices mentioned above, a comparison of two imaginary developments, and an interesting article
by Jack Reeves.
In my opinion Agile Software Development Principles, Patterns, and Practices is the best OOD book out there.
(John Wetherbie - Bartender,
January 2003)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Writers' Workshops & the Work of Making Things: Patterns, Poetry...
Richard Gabriel
|
|
Pearson Education
Published: 2002-06-17 |
|
Every fall, just after school starts, some of the finest minds in object-oriented programming depart for an extraordinary
conference in an improbable location. Held at a turn of the century mansion hidden among the corn fields of central Illinois,
the PLoP (Pattern Languages of Programs) conference is one of those rare, magical events where everything you know about the
way the software world works is turned on its head.
Instead of "acolytes" gathering around the feet of the "master" to hear the same talk that he gives at every other conference,
experienced folks like Richard Gabriel, Ralph Johnson, Kent Beck and Ward Cunningham sit and give personalized advice about
how the patterns and pattern languages written by first-time authors can be improved and strengthened. It's a place where
you might find out one of your dinner companions has written four books on OO design and speaks at conferences twelve times
a year, while the other is a new graduate student just getting started in the field.
How does this occur? And why do people keep coming back year after year? The key is in the primary innovation of this conference
-- bringing the notion of an Author's Workshop to computer science. Richard Gabriel is the person who introduced that idea
to the computer science community, and he writes lucidly and joyfully about the wonder and the terror of Author's workshops
in this delightfully agreeable little book.
In this volume, Richard describes how the Author's workshop came out of the creative writing and poetry community, and provides
a roadmap for carrying out a writer's workshop. He describes the benefits of the process, and gives sage advice to the participants
in such workshops. He draws his stories and examples from his varied experiences in workshops in both communities (software
and literature) and explains why such an unlikely way of doing things has come to be so valued and cherished by the software
patterns community.
So, if you've wondered why people in the software patterns community are so set on the way they run their conferences, read
this book and you'll understand why. But that's not the only value; reading this book can give you insight into how to improve
your own writing in any genre, and how to marshall the resources of your communities to improve the quality of your work.
I'm hooked on this process, and I'm delighted that I finally have something to refer people to so that I can share some of
the magic of this unconventional way of teaching, and learning.
(Kyle Brown - Bartender,
July 2002)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Applying UML and Patterns
by Craig Larman
|
|
Prentice Hall PTR
Published: 2001-07-13 |
|
Craig Larman has outdone himself. This edition, with its many changes and new sections, is really almost a rewrite rather
than an enhancement.
This edition uses the Unified Process (UP) as a sample iterative process, replacing the first edition's generic set of Recommended
Process and Methods (RPM). Many of the changes in the text and diagrams revolve around this shift. If you don't use UP, don't
worry: the material is still very relevant since the basic ideas can apply to any iterative development process.
Java programmers will also feel right at home since the code examples are in Java. If you use another object-oriented language,
you should still be able to follow the discussion. Larman expands his discussion of object-oriented design principles and
the General Responsibility Assignment Software Patterns (GRASP) introduced in the first edition, particularly the "Don't Talk
to Strangers" pattern which has been incorporated into the more general "Protected Variations" pattern.
Other changes include updating use cases to follow the approach popularized by Alistair Cockburn and including a third iteration
in the POS System case study. My favorite addition was the new "You Know You Didn't Understand..." sections. They listed common
misconceptions about various UP concepts-" a useful aid to quickly review your understanding of the preceding sections.
If you read the first edition, you'll probably want to read this one, too. Highly recommended for anybody who wants to learn
the basics of UML and iterative OOAD.
(Junilu Lacar - Bartender,
June 2002)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Java Enterprise Design Patterns: Patterns in Java Volume 3
by Mark Grand
|
|
John Wiley & Sons
Published: 2001-02-15 |
|
This is an very well-written book on Enterprise design patterns. Mark Grand presents his topics very clearly and describes
each pattern he discusses in detail. The book starts with a thorough tutorial on UML that provides many different examples
of the various diagrams and elements, and how they are used together. This part of the book is a good foundation for the balance
of the book, which uses UML diagrams in each pattern description.
The book is logically divided into different sections based on the common uses of the patterns described. Then each pattern
description is broken down into various parts. Mark does an excellent job of focusing in on the various things that affect
the pattern in use. He also uses real world examples to describe usage instead of the usual contrived ones found in many books.
This is a book that you will read once then use each time you are implementing a pattern to see what you've missed. From
an educational point of view, the book is very good and will teach you a lot about the patterns in it. From a development
standpoint it may be even more valuable in that it can be used as a reference to get alternative ideas or to see what consideration
you may have missed in your implementations. I highly recommend this book to anyone doing enterprise work now or in the future.
Now I have to go out and get the first two volumes!!!
(David Vick - Bartender,
April 2002)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Applied Java Patterns
by Stephen Stelting, Olav Maassen
|
|
Prentice Hall PTR
Published: 2002-01-05 |
|
If you're unsure how to apply design patterns to Java, this book provides a solid, methodical, but gentle introduction to
the practice.
This guide uses the classic design patterns first decribed by the GoF book. For each pattern, the authors provide a fresh
motivation (writing a Personal Information Manager application), and rationale for matching a program feature or function
to an appropriate pattern. The book seems best suited for those who need to learn definition and application in Java by example.
There's no CD-ROM; bummer. At a $45 list price, I think code-intensive books should offer one. This code is available by
FTP, but, since my local firewall prohibits that, I find fault with the publisher for the inconvenience.
In the interests of full disclosure, I know Stephen and Olav personally. It's a pleasure to see them do what a number of
us have been avoiding. This book needed to be written, but doing it well requires the diligence of a methodologist and the
patience of a researcher. They've done very good work despite the tedium of building the book. Any aspiring program designers
will find their time reading it well rewarded.
(Michael Ernest - Bartender,
March 2002)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Software Architecture: Organizational Principles and Patterns
by David M. Dikel, David Kane, James R. Wilson
|
|
Prentice Hall PTR
Published: 2001-01-07 |
|
You might ask if a book devoted to Organizational Principles and Patterns on Software Architecture is really necessary. I
didn't think so until I read this book!
I quickly found myself nodding as I recognized patterns from the book that we practiced at work. I was also alarmed at the
number of Anti-Patterns we have as well. This gives me a goal and guidance to help guide things, hopefully, along a successful
path.
Besides my enlightenment, the book mainly covers the VRAPS Principle (Vision, Rhythm, Anticipation, Partnering and Simplification
Patterns) with real world case studies from organizations such as Allaire. An extreme amount of research went into the production
of this book. The result is obvious.
Any company producing software should make reading this book mandatory for their Managers, Architects and Developers
( Carl Trusiak - Sheriff,
November 2001)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Prefactoring
Ken Pugh
|
|
O'Reilly Media, Inc.
Published: 2005-09-01 |
|
The term "prefactoring" is supposed to mean using things you learn from your own experience or the experience of others to
improve new programs. The book "Prefactoring" revolves around approximately 70 requirements and design guidelines. The stated
audience is anyone who understands the basic concepts of OO. It is good for a beginner who has read some or a practicing
developer who wants a reminder of best practices.
Most of the book follows the development of a fictional system. The guidelines are sprinkled throughout as appropriate.
The author is realistic in noting that many exceptions to the guidelines exist. A few are illustrated within the context
of the fictional system. However, I found the user of some guidelines left much to be inferred by the reader.
The guidelines focus on abstraction, separation of concerns and readability. An appendix cross references them well. The
fictional customer was realistic in demands, which was nice to see in a book. Overall, the book read well, was factually accurate
and provided a good walkthrough of the thought process in a sample design. But on the book's focus of guidelines, it left
me wanting more depth.
(Jeanne Boyarsky - Bartender,
December 2005)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Succeeding with Use Cases: Working Smart to Deliver Quality
Richard Denney
|
|
Addison-Wesley Professional
Published: 2005-05-06 |
|
"Succeeding with Use Cases : Working Smart to Deliver Quality" walks you through four quality engineering disciplines: quality
function deployment, software reliability engineering, model based specification and use case configuration management. Most
of the book is readable by project managers, while model based specification (pre conditions, post conditions and invariants)
is of special interest to developers and testers.
As you can guess, the book assumes you already know about use cases. For the most part, the authors are good about going into
detail without making any further assumptions of your background. Examples include concrete numbers and the diagrams are excellent.
Once chapter does get theoretical and use algebra, but it is immediately followed by a practical application.
Personally, I found the reasoning and walkthrough of the ROI example to be most valuable. The book does read like a short
textbook and academics are explicitly mentioned as one of the target audiences. However, you can tell the book is written
by someone who has been through it personally. Overall, I found the book to be a valuable read.
(Jeanne Boyarsky - Bartender,
August 2005)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Fast Track UML 2.0
Kendall Scott
|
|
Apress
Published: 2004-03-19 |
|
As described on the back cover of the book, the target audience of Fast Track UML 2.0 includes folks with previous visual
modeling knowledge, perhaps including UML 1.x experience. In the book, the author does not attempt to describe the differences
between UML 2.0 and UML 1.x, or to point out the new features. Instead, in a content-packed 161 pages, Kendall, with a "fresh
look" at UML 2.0, describes well what a typical developer would want to know about modeling with this improved language.
Normally, when a book's title tries to convey that it's going to teach me something "really fast" or "in just XX hours",
I won't even pick it up. In this case, from reading a few of his previous books, I trusted that the author, Kendall Scott,
had probably put together another good book worth reading, and he did. In this book, I was looking for something that would
quickly bring me up to date with UML 2.0, while still serving as a good reference manual into the future, as I sit down for
some fancy picture drawing, also known as visual modeling. This is that book.
I would definitely recommend this book to anyone looking for a well-written, easy to follow and understand, concise UML 2.0
reference manual. If you're a career designer, note that this book does not describe in full detail, the complete syntax
of UML 2.0. That said, if you're drawing fancy pictures using syntax not described in Fast Track UML 2.0, then perhaps that's
a sign that you're models are too detailed. If you're brand new to the study of OOAD looking to develop these skills, this
book alone probably isn't what you're after, though it would still serve well as a supplement to another material geared towards
teaching OOAD. As a bonus, the book is priced well.
(Dirk Schreckmann - Sheriff,
May 2004)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Enterprise Patterns and MDA: Building Better Software with Archetype Patterns and UML
Jim Arlow, Ila Neustadt
|
|
Addison-Wesley Professional
Published: 2004-01-01 |
|
Enterprise Patterns and MDA is the third and latest book related to OMG's Model Driven Architecture. However, as the title
implies, it's not all about MDA. In fact, the most significant focus of the book is actually patterns, specifically business
patterns and archetypes.
The authors start the journey by introducing concepts and techniques such as archetypes (universal, recurring "things") and
archetype patterns, and Model Driven Architecture. Furthermore, the authors have dedicated one chapter for describing a technique
called Literate modeling (combining traditional visual modeling with an accessible business context provided via a narrative
text, for example).
Up to this point (vicinity of page 116), the authors' writing style has been flawless, in my opinion, and easy to read. From
chapter 4 onwards, the authors have provided a huge pattern catalog for archetype patterns. The catalog has been divided into
chapters around archetypes such as Party, Order, Customer, and so on. Each archetype pattern introduces a business context,
a high-level overview model, and descriptions of the related archetypes, their properties and related activities.
I didn't go through even nearly all patterns in the catalog. However, I feel confident that I will dive into the catalog
looking for insight when moving to a new problem domain on a new project. Enterprise Patterns and MDA is a nice resource to
have on your bookshelf.
(Lasse Koskela - Bartender,
February 2004)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Data Access Patterns: Database Interactions in Object-Oriented Applications
Clifton Nock
|
|
Addison-Wesley Professional
Published: 2003-09-21 |
|
This book is an excellent addition to Addison-Wesley's Software Pattern Series. At some point every software application
is going to have to access data. The patterns in this book will be invaluable when its time to write data access code.
I really like the book's organization. While you don't need to read it cover to cover, it makes it very easy to do by putting
the most common patterns first. Using the decoupling patterns alone will allow me to greatly improve my code.
While all of the patterns are written with a relational database in mind, there is no reason why many of these patterns could
not be applied to flat files or any other data store. The author left all the patterns open to easy interpretation in that
sense.
This book is all about documenting data access patterns. If you are new to patterns, this is probably not the book you want
to start out with. After you read a more introductory pattern book, you really should consider adding this book to your library.
(Matthew Phillips - Bartender,
October 2003)
|
|
|
More info at Amazon.com ||
More info at Amazon.co.uk
|
|
Web Services Patterns: Java Edition
Paul B. Monday
|
|
Apress
Published: 2003-04-08 |
|
Now that we have read all the books on the basics of web services and have a good understanding of how they are supposed
to work it is time to get down to actually trying to create some decent designs for our web services applications. That is
where this book fits in. The book shows how to apply design patterns to a web service architecture in order to solve common
design problems. If you are designing a web service architecture you will want to read this book before drawing another UML
diagram.
The book starts out by looking at the design patterns used in web services itself. This part of the book was interesting
| |
