Computing Internet Books

Gives a great overview of different strategies to use that are quick & easy to implement.

This book was largely uninformative, too broad in scope to be useful, and every chapter it felt like it was a pitch for some web companies's Wares, including the other authors Book. Do not waste your time on it.

Man and computer, but this guy is not my idea of a nice person. He has fun faking his identity in a chat. What happened to being honest and not lying to people? He talks about Western pioneer spirit ya well we have heard that by now. Must be the WELL because there seems to be a unity in writers from there. And yes their story dominates too much of the writing about the net. Sorry but I like community I am not a libertarian, thank you very much. It was an interesting read my own grips about the WELL aside. But then we could all write something like this but as a story of one person's personal views on the computer explosion in America and the media business it has merit. Since Bill Gates seems to be known for his relation to computers I guess this writer got to know his subject. I didn't finish it but it has some personality.

As might be expected, the book is very dated now. I was also on the Internet in 1993 and 1994 and don't regard myself as a pioneer of any sort. I did find Seabrook's description of online life accurate and especially the arc of a long-term presence online .. from euphoria and enthrallment to disillusion and disgust finally arriving at a place of balance.

Seabrook opens his story by describing the login screen to the WELL, an online conferencing system. He quotes it as saying "you are your words" and, based on this, proceeds to draw a variety of conclusions about the WELL and the online world. Which might be fine, except that the login screen to the WELL reads "You own your words." Big difference there. You'd think a writer for the New Yorker could, when recounting a quote that sets the tone for his book, get the quote right. The book heads steadily downhill from there. Seabrook makes it all about himself. That isn't a bad thing per se, but it doesn't work here. Seabrook's personal journey is not interesting, and he has very little original or interesting to say about the medium. I suppose this book could be useful as an object lesson about the dangers of journalistic narcissism, but that's about it.

I liked it a lot. Why do some reviewers characterize an author as narcisisstic when he talks about himself once in a while? Give me a break. Well rounded perspective of one man's introduction to the cyberworld.

I had read excerpts of this in The New Yorker, where Seabrook is a staff writer, and was interested in seeing the finished product. Reading it bit by bit over time was one thing; reading it all at once was another. John Seabrook is really infatuated with himself. We do not need to know that he went to boarding school and then Princeton, yet he repeats this information again and again. We do not need to know how smart and wonderful he "knows" he is -- but since we're in his head, we're stuck with him. If he is indeed so smart and wonderful, why does he need to hire someone to build a homepage for him? He's insufferable, and readers can do better elsewhere.

Although there are hundreds of blogging books in print, from my surveying this one appears to be the most relevant practical guide -- so I gave it an extra star. I liked it for the following reasons:

(+) good tips on building readership (plus some SEO)
(+) explanations of importance of garnering and giving referent links
(+) practical tips on monetization
(+) coverage of some useful tools I might not have otherwise discovered
(+) highlighting some popular blogging platforms
(+) engaging writing style
(+) accessible as a book you could give to a co-worker, or even less-technical family member
(+) gets reader excited about blogging

However, it has the following problems:

(-) some material highly subject to aging (e.g., blogger how-to steps could have been omitted)
(-) promotion of some obnoxious tools (e.g., White Smoke grammar helper, user-unfriendly Microsoft Live Spaces)
(-) very little mention of WordPress (you wouldn't realize its popularity by reading this book)
(-) not enough emphasis on blog *reading* (Google Reader got one sentence, but its features and best practices could been expanded to a whole chapter). Optimizing your reading habits/patterns is a critical skill for surviving blog-bombardment
(-) no mention of the role of pinging (and necessity by some services)
(-) too many interviews (police wives and military perspectives didn't add anything for me)
(-) a number of grammar and spelling mistakes
(-) audience target may have been too broad (I would expect Apress to have had a better techie focus)

Overall, I thought the book could have been half the length and still had the same impact. But as a new blogger I got quite a bit out of the book, and I still recommend it to anyone who is not already a pro. Just be prepared to do a lot of skimming, and try to get a library/used copy that has important points highlighted.

To put it succinctly, Clear Blogging is the kind of book I would give to a boss or manager to educate them about what blogging is, can be, and a hint of technicalities on the back end. While a good book and a great overview of what is entailed with blogging, there are not enough nitty-gritty details to satisfy someone who is of a technical nature or someone who has been blogging for a while.

However, for someone who needs to know what this blogging thing is about and how they might be able to use it for their business, either directory or indirectly, this is the perfect place to start. I would estimate that at least half of the book is made up of interviews with either bloggers, people who run blogging companies, or marketing type folk. These interviews, though they get a little long and predictable after a while, lend real life examples to the lessons being taught.

Additionally, there is sufficient attention given to topics such as podcasting, monetization, and social networking to give you a good start on finding out more about these areas.

All in all, for any body wondering where to get started, I wouldn't hesitate to recommend Clear Blogging. And if you are already in to blogging, I will bet this book can still teach you a few things.

Bob Walsh goes a long, long way past the usual, superficial approach. ("Blogging is great - here's how to set up your blog on TypePad.") The interviews with well-known bloggers are an outstanding feature of the book - they are insightful and very useful - they'll help you understand what you're committing to, how to run a successful blog, and what you can expect to get out of it. Also, Walsh gives the best advice I've seen for advertising your blog via Technorati, Feedburner, et al., and for using social networks to promote your message. Great job. - George (fitnessintuition.com)

I've been blogging in a ho hum way for over a year - but this book has opened up blogging for me in a whole new way.
I would recommend this as an intro... middle and advanced book. It has tons of stuff for every level. Of course I'm at the beginning level so maybe I'm not the perfect judge but I can say it has enough stuff for me to follow up with for at least a year!
What I really like are the interviews, the links and the detailed information (step by step) to do or check things out. And... besides the book I'm getting just as addicted to his web site... http://clearblogging.com

If you are going to recommend just one book to someone who wants to get started reading, following and creating a blog, this is the book. Author Bob Walsh goes far beyond the usual treatment of the topic and gives you tons of practical tips, suggestions and information about resources. I've been blogging for over a year and I learned a ton from Bob's book. Don't waste your time with other books, go right to source and read this one. I highly recommend it.

Having dabbled with attempts at animation for a while now, my efforts were improved by purchasing a book on "Animation" prior to the book in question. This fired me up and made me really think about what I was trying to do. However THIS book dealt with animating in FLASH which puts a different spin on the process as it dealt with LIMITED animation besides FULL animation, the latter being more difficult for obvious reasons. whichever way you want to go, this book as heaps of tricks to use that only flash can provide which will make your animating more convincing.
The best bit is being able to pull apart and see how the animation created in the book is done by downloading it from the authors website, plus there is also another website with the authors work and others with numerous short LIMITED animations which will inspire you I am sure ....it did me.

The content of the book is without equal. Very in-depth and very readable, but it looks like their editor fell asleep on the job. Multiple spelling errors and editing mistakes throughout the book become irritating in an otherwise spectacular book. If you're looking for a "how-to" for animating in flash, get this book.

if you're thinking about learning flash animation, this is a good place to start. You will learn the basics and essentials to get you started to making your own cartoons. Great book for beginners but not so much anyone else

This book covers how to create pans, walk cycles, storyboards, perform squash and stretch, etc. This book is an excellent price! Much cheaper than going to animation school. This book coupled with "How to Cheat in Flash CS3" by Chris Georgenes will teach you everything that you need to know about flash cartooning. I bought this book a while ago and returned it because it couldn't really appreciate it the first time. I bought the book again and realized that it's really a very good book. I hope to finally sit down one weekend and start creating my 2nd cartoon. I have no excuse now since I have both "Flash Cartoon Animation: Learn from the Pros" and "How to Cheat in Flash CS3".

Though the artwork throughout the book isn't that entertaining, the sheer amount of information presented is amazing! The chronological skill set they present to the reader starts you at the beginner's level and ends with you creating flash cartoons. I enjoyed the way it was written as well, the two guys who wrote it obviously enjoy using flash more than correct grammar (or spellcheck for that matter haha). Despite the occasional misspelled word, I recommend this book to anyone just starting to use Flash. It is an excellent resource for future reference as well!

I'd been meaning to buy this book for over a year and was not disappointed. It is very well written, easy to understand and goes quite into depth regarding OS X.

I enjoyed the writing style of the author, well presented information with bits of humor to keep it interesting. I enjoyed reading the history of OS X and learning how all the parts were brought together to create the most enjoyable computing experience I have ever had. The technical information and programming examples are extremely helpful in better understanding how things work under the elegant aqua interface.

It's enormous! And every page has information useful to someone who develops on the Mac. This book is the ultimate tome of reference for the serious Mac developer. It's also a significant contender as a tome of reference for IT support for the Mac. Finally, it is the best reference for someone with a Windows background who's wondering if Mac OS might be superior technically (leaving aside user interface). (it is.)

All the gory details of how a Mac OS is put together from Mach to Cocoa are covered and then some. The author is a hard-core expert who put a lot into this book. Well worth the price!

This well written books contains everything you need to know about the internals of Max OS X. This book is enormous and really goes deep into the internal of the OS.
This reading gave me the satisfaction of understanding the inner working of Mac OS X which now make my work as a software engineer much easier because I know what is going on.
The book is well balanced in that it cover all the different aspects of the operating system without getting into unecessary details.
One small complaint is that the chapter describing the hardware architecture focus on PowerPC systems. I would of course have rather have a detail explanation of the Intel platform. Maybe in a second edition.

This is analogous to the Windows Resource Kits for OS X, only better. The many examples, most using some sort of code to make their point, combined with the depth of topics covered, makes this the one book really serious OS X coders and admins need to have.

Like it's cousin, the MS ResKit, it's dry, concise, and may scare off some folks. And like the ResKit, it's just as essential as a learning tool and reference book rolled into one.

I've seen many reviews that talk about this book as a book for programmers. I don't believe that for one second. I've heard many references to the old days when all admins were programmers and heard tell of greybeard hackers who are equally proficient at both coding and admin work. This book does a similar job of blending the lines between the two tasks, illustrating concepts and giving examples using C and scripting as well as using human readable english. As a non-coding UNIX and OS X aficionado, I look forward to broadening my knowledge of both programming and unix administration as it applies to OS X via this awe-inspiring book.

The author explains vendor independent concepts of load balancers and discusses their (dis)advantages.

He is dividing them into four major applications:

* Server Load Balancing (63p)
* Global Server Load Balancing (19p)
* Firewall Load Balancing and (15p)
* Transparent cache Switching (8p)

additions:

* application examples (4p)
* future outlook (2p)

What makes the book so enjoyable to read is the authors love to the details. The story just flows very smooth.

Especially the thorough explanation, screenshots and technical details deserve the mark "distinction" (Very good). While I read the book it was like puzzle peaces suddenly falling all together to show me the bigger picture.

I did like the follow up of technical issues like session persistency (server affinity), URL switching, system design vs. functionality considerations and the limitations that come with the chosen solutions. The described issues are exactly those that system designers will face in real life and it doesnt stop there of course. The book is laying a good groundwork for development of advanced concepts.

The part of the book that I enjoyed most was the chapter about firewall solution concepts. As the author points out correctly the traffic flow in both directions must be managed. This is also why the setup from a redundant firewall to a load balanced redundant firewall must justify multiple complex issues.

In this case the author went through the analysis of the traffic flow, a stateful vs. stateless discussion, a layer2 vs. layer3 discussion, proxy firewalls, synchronized firewalls, multizone firewalls, VPN load balancing, active-active vs. active-standby discussion and the interaction between routers, load balancers and firewalls. While some topics could only be scratched on the surface the concepts and ideas behind it are explained very clear.

There is no doubt for me that a 2nd edition can easily just pickup where this edition left off. The author clearly shows that there are more scenarios to be discovered and discussed.

On the one side I would love to see a updated 2nd edition from the same author, on the other side I guess it's been hold back to keep the competitions products in a distance ;-)

Also the book was published 6+ years ago I felt that the concepts did not loose any of its value. Which leads me to the point that this must have been " THE Technical Book of the Year 2002"

This book still receives well deserved full marks.

Bravo !!

if you are new to load balancing, get this book. Clear concept explanation, with diagrams. Highly recommend.

With his background in server products and networking products, this author is uniquely qualified with the product experience to present these topics.

From the simple beginnings of DNS server load balancing Kopparapu explains the driving forces behind and solutions presented to load balancing. The majority of the book is an introduction to the concepts and solutions available for server load balancing suitable for everyone from business casual to advanced technical users.

In addition to detailed explanations, the author demonstrates load balancing techniques through a number of illustrations. The illustrations are detailed enough to explain the concepts, but occasionally lack enough practical detail to go out and bulid in a lab or on a network without further understanding.

In combination with a good manual from a load balancing product, any reader would have enough information to implement sophisticated load balancing configurations.

In addition to server load balancing, the text covers caching techniques available through the use of some layer 4-7 devices. Of all the topics this one is the least detailed in the text. The author understandably covers only that part of cache technology related to layer 4-7 devices. A great deal of the technology required to put together an entire cache system resides in other parts of the system outside of the scope of this book. The implications for the architecture of a network are far reaching and worthy of at one more dedicated book on the topic.

Finally, the author presents the topic of firewall load balancing. Like caching, this is a complex topic. A complete understanding of network security and firewalls would require at least a few other books.

For those that already understand caches or firewalls though, this book provides detailed information on how to scale those systems with layer 4-7 technology.

This is certainly the most comprehensive and easy to read text on the topic. Anyone who reads this will also look forward to future texts from the author on emergning challenges in layer 4-7 network security and streaming content and distribution.

Compared with Tony Bourke's book, this one depicts more on technical details such as how packets flow, how health check is done and etc.. On the other hand, Bourke's book mentions more about the basic concept and the introduction to current available products.

If you are interested in how load balancers are designed, this is the right book for you. However, if you are just shopping around and only want to know what load balancers are, get Brouke's one.

Btw, I was a bit disappointed at chapter 9. I expected to see more opinions on the future development of load balancers but it was not mentioned too much.

This book is a very well written and nicely organised introduction to server load balancing. The author describes the basics of load balancing, including NAT, session persistence, and network architectures. A discussion on application-layer parsing was quite good. There is also a chapter on global server load balancing (including incorporating load-balancing into the authoritative DNS server) which I found to be very detailed and interesting.

Much of the book is centered on how to load balance TCP (and to a lesser extent UDP), and the author uses HTTP and FTP as his primary driving examples. Throughout the book, the author provides some insight regarding what approaches real companies use (e.g. "this method is what Foundry and Cisco uses."), which I liked very much. Also, the illustrations were plentiful (although a bit primitive-looking).

There are only a few negatives about this book. The english writing is a bit stilted at times, and the chapters on firewalls and caches were basically rehashes of earlier chapters. Finally, I was hoping the author would have provided more detail on the load-distribution heuristics (which server to choose) with more metrics and actual real-world results.

I found the book to be extremely well organised. You will not get lost while reading this book, but you will need a university-level understanding of TCP/IP (and probably the link layer as well to get the NAT material) and networks in general to fully appreciate the matieral. Overall, a great book.

This book is great for Ajax newbies who are confused with all the frameworks available out there. Provides a quick overview of a lot of them with working examples. I would have prefered if it included more advanced scenarios.

Web programmers working with Java will appreciate this guide, which tells how to make a Java web application more responsive and dynamic by incorporating new Ajaxian features, from suggestion lists and drag-and-drop modes to producing third-party tag libraries and using Ajax with Struts. The idea is to streamline operations and use Java developer backgrounds to understand Ajax's strengths: AJAX ON JAVA is the place to begin the process, and is a pick for any library strong in web programming topics in general and Java in particular.

I was looking for a book on to explain the underpinnings of Ajax technology. What I purchased was little more than an advertisement for several Ajax development projects. Additionally, the author covers, in equally superficial detail, many side technologies which do not drive the subject matter forward; cascading style sheets (CSS) and Ant, for example.

The code examples have many bugs and references code/methods that have yet to be presented in the book. Meanwhile, the text explaining the examples discusses the actual methods that should have been in the code examples. The author does not take the time to discuss good object-oriented programming techniques or why this would be important.

All in all, this is a very disappointing offering.

'Ajax on Java' by Steven Olson is a nice intro book to learning how to use Ajax with your Java code. Nothing more than a quick overview (certainly not a reference) at just over 200 pages, this book will help Java programmers get their feet wet and start learning how to program the Ajax way with instant responsiveness in the Web 2.0 world.

If you program with Java and want to begin to learn how to use Ajax to make your apps hit the "turbo" button, pick up this book and start your engines!!!

**** RECOMMENDED

Sad to say, this book is little more than a code dump, and the code does not run without debugging.

There are no explanations of technologies and concepts that surround Ajax, therefore, given the state of the code, there is not a lot of reason to work through the book. In fact, this is the first computer book that I returned to the seller, simply because I found so little reason to keep it on my bookshelf.

The writing in the introductory chapter gives promise, but as the book progresses the code quickly becomes dense and the organization and writing becomes unacceptably thin. I expected more from O'Reilly.

Before I gave up on this book, I was half way through it, and only one code set had ran correctly from build on. For example, the author's code has at least four variations of the basic application URL sprinkled among the Javascript and build files of the first four examples. Finding and correcting the URL was annoying but not difficult, but even after that, the examples did not run without further debugging.

I finally threw up my hands and surrendered... defeated by the author's rush to publication.

I had great expectations for this book, but I have to say they have not been met. Some of the exercises are extremely simple; many of the others are difficult, vague, or ill-defined. Also, the exercises don't match up conveniently with chapters of the accompanying text. You have to poke around in the homework problems of the text to find what exercises may go with those chapters. They're not in the same order as the text, and there are many chapters in the text that have no exercises associated with them. Also, the exercises don't ask for any analysis on the students' part--they just have a list of steps for the students to check off.

Fine ideas in the area of managing the test code part of test driven development
Aimed at developers, testers may find some ideas that fit in their ballpark too.

Let me start by stating the obvious: this is a patterns book about the organisation of tests and the workings of the xUnit family of unit testing frameworks. It is _not_ a book about Test Driven Development, although there is material that is pertinent to that. Given that the use of JUnit and TDD is pretty intertwined in the minds of many Java developers, it's worth making this distinction, so you know what sort of book you're getting. Speaking of JUnit, most of the code examples uses Java, although there are some examples in C#, VB and Ruby.

Like Martin Fowler's Patterns of Enterprise Application Architecture, the book is split into two main sections, a narrative that weaves together a lot of the patterns and strategies, and then a catalogue of individual patterns. Between the two, there is a catalogue of 'test smells', similar to the 'code smells' discussed by Fowler in Refactoring, which I would suggest can be read profitably with the narrative section, rather than used as reference material.

There are a lot of patterns here on the mechanics of xUnit, such as 'Test Runner', 'Garbage-Collected Teardown' and 'Named Test Suite'. I was a bit confused about who this material is aimed at -- maybe someone looking at porting xUnit to a new programming language would find it useful, but a lot of it is fairly obvious to anyone who's used an xUnit in a non-trivial fashion (and certainly, if you haven't done so, this book is not a format that makes for a good introduction), or requires playing against xUnit's strengths (e.g. not putting setup and teardown code in their eponymous methods), although there is good reason for doing so in some of the examples provided, such as databases.

Beyond this, there is some good stuff on design-for-testability patterns (e.g. dependency injection versus dependency lookup), value patterns to replace magic constants, custom assertions and custom creation and other utility methods to make the intent of tests more clear. This material, along with the test smells chapter, is where the real value of the book lies. It encourages the application of the same software engineering principles you would apply to your applications (encapsulation, intent-revealing names, Don't Repeat Yourself) as you would to your testing code, something that's surprisingly easy to overlook, at least in my experience.

Also, the material on 'Test Doubles' (mocks, stubs, dummies and their ilk) is extremely useful. It touches on designing with mocks only superficially, but it does provide a helpful taxonomy of what different classes of doubles do. Now, if only everyone would standardise on this nomenclature, it would make life a lot easier. I suggest we brandish this enormous book threateningly at anyone who refuses to toe the line, and that should do the trick.

Because, boy, this book is big (about 900 pages). To be honest, it's too big. I rarely complain about getting too much book for my money, but the likes of GoF, PoEAA and PoSA 1 manage to come in between 400-500ish pages, so there's no reason XTP couldn't. The advantage is that the patterns in the catalogue, which take up most of the space, stand alone, without requiring too much flicking backwards and forwards between patterns.

The disadvantage is that there is a lot of repetition, so unlike the three design patterns books I mentioned above, which I suspect most people read cover to cover (or maybe that was just me and I'm a complete freak), I would suggest only dipping into the catalogue as necessary. For instance, how much difference is there between the 'Testcase Class per Class', 'Testcase Class per Feature' and the 'Testcase Class per Fixture' patterns? Not a lot, as you might expect.

I definitely liked this book. I would have liked it even more if it came in at about half its size and I would have preferred more emphasis on test and assertion organisation than the mechanics of the xUnit framework, but maybe that would have been a different type of book to the one Gerard Meszaros intended. This is nonetheless a must buy for anyone who cares about unit testing.

I've been familiar with agile concepts of automated unit testing (AUT) and test-driven development (TDD) for awhile now. In the past few years I've made several attempts at incorporating AUT and TDD into my own personal workflow, but each attempt soon resulted in my abandoning the whole idea. The testing effort quickly outweighed the benefits. I've believed in the ideal of TDD, but I didn't see quite how to pull it off.

Then I bought XUnit Test Patterns by Gerard Meszaros. Wow! Finally the issues I've struggled with are being addressed. Okay, I must admit I'm not very plugged in to the online software development community, and I'm sure these issues have been discussed before. But this book looks special. I sense it's giving voice to these issues in a big way that's introducing many developers to these ideas for the first time. After all, it had to take time for this kind of book to be written. Time for the patterns to be developed through hard and frustrating work.

Rarely have I bought a thick book on software development and eagerly read every single word from cover to cover. But I have with this book. And I know I'll soon do it again. I'm even tempted to also purchase the PDF version of the book, just so I can reference it wherever I happen to be.

It's not the final word on AUT, but it has me embracing the ideal of TDD once more. The company I work for develops a huge OO-based enterprise software system with no automated tests. As Meszaros explains, this kind of legacy system is the most difficult for incorporating AUT (and daunting for those new to AUT). But at least now I feel like we have a good chance.

By now, the concept of "patterns" in program design is pretty well accepted. And the concept of test-driven development has a solid foundation also. But are there certain "patterns" to building and running those tests? The answer is yes, and the book that covers it is xUnit Test Patterns: Refactoring Test Code by Gerard Meszaros. If you use any of the xUnit software in your development efforts, you need to have this book...

Contents:
Part 1 - The Narratives: A Brief Tour; Test Smells; Goals of Test Automation; Philosophy of Test Automation; Principles of Test Automation; Test Automation Strategy; xUnit Basics; Transient Fixture Management; Persistent Fixture Management; Result Verification; Using Test Doubles; Organizing Our Tests; Testing with Databases; A Roadmap to Effective Test Automation
Part 2 - The Test Smells: Code Smells; Behavior Smells; Project Smells
Part 3 - The Patterns: Test Strategy Patterns; xUnit Basics Patterns; Fixture Setup Patterns; Result Verification Patterns; Fixture Teardown Patterns; Test Double Patterns; Test Organization Patterns; Database Patterns; Design-for-Testability Patterns; Value Patterns
Part 4 - Appendixes: Test Refactorings; xUnit Terminology; xUnit Family Members; Tools; Goals and Principles; Smells, Aliases, and Causes; Patterns, Aliases, and Variations
Glossary; References; Index

Most of the books that cover xUnit software do so from the perspective of a technical manual. Everything is geared to writing the actual code for the test. Meszaros takes a different tack. He covers more of the "why" behind test writing in xUnit, as well as the basic patterns and principles you should be aware of when you're putting together your tests. People new to xUnit will throw together tests without much thought as to the structure and robustness of that script. Meszaros maintains that much of the same care that goes into writing and designing programs should also go into the test scripts. Patterns such as In-line Setup, Chained Tests, State Verification, and many others can adjust your whole mindset towards what makes a solid and maintainable test script that will serve you well both now and down the road when you have to make changes to the program (and add more scripts to your test suite). The book is set up such that you can scan for basic ideas, and then go back to specific patterns for more information as the situations and needs arise. With the use of both actual code and UML diagrams, it's very easy to catch the gist of each pattern, as well as seeing how it would actually be implemented. Very good stuff here...

If you practice test-driven development (and you should), you have no doubt worked with your particular xUnit variant. This book is the next step in your learning, and it will make you a much better developer and tester...

We went over 2,000 unit tests this past week during Iteration 72 on our Agile project. Of course, over the course of the last 18-24 months we have removed some tests, and in many cases, refactored the existing tests many times. We also have been learning a whole lot about TDD and the actual domain that we are building and testing. As we were doing this, we were implicitly discovering Test Smells, and discovering test automation patterns. The value in establishing patterns, and more precisely a pattern language in a particular domain are substantial. It's not so much that the "collector" of patterns is defining something new (some often mistakenly criticize pattern books in that regard) that you didn't know, but defining a shared terminology of our practices that we keep doing over and over. To that end, the patterns themselves not only define a shared vocabulary but serve other functions, not the least of which is learning from others. An obvious example of this is Martin's PEAA collection of patterns that enables us to say things like PageController or Lazy Load or TableDataGateway and we all know what it means. In fact, when I am talking about Interaction versus State/Behavior type of testing on CB, and others here use much of this terminology, I am in fact, talking about patterns like TestDoubles and MockObjects, among others.

When I became aware that Gerard Meszaros ' xUnit Test Patterns book was going to ship Friday, I ordered it for overnight delivery on Saturday. I read well over 200 pages yesterday pretty much at one sitting, contented with a book that will change the face of the software industry, just as JUnit and all the other xUnit family have fundamentally altered software development for the better. Its definitely a big book at 944 pages, but it's not a book of excess, unnecessary pages. Rather it shows how hard it is to write defect-free software and the depth of the work that people are putting into this endeavor. The book uses Java as the language which obviously is no hardship to the C# programmer. Like most of the sound practices that have been evolving in the last ten years, this work has been evolving out of the terrific Java community.

Just like their are Code Smells, there are Test Smells, and writing good test code is just as hard and as worthy as writing good production code. Meszaros categorizes Test Smells into ProjectSmells, BehaviorSmells, and CodeSmells. Particularly interesting is his discussion in this regard to the commercial "record and playback" test automation products that have given test automation a bad name in many circles with their tendency to create FragileTests particularly with regard to Interface Sensitivity. Like many others, we were drawn in, and spent and wasted thousands of dollars with a vendor and exhibiting extreme Interface Sensitivity with the user interface. Their interface was not only unable to "pick up" most of the controls we use but even minor changes to the interface can cause tests to fail, even in circumstances in which a human user would say the test should pass. This only goes to support the notion many of us have talked about here about factoring a UI into MVP or MVC and not having logic in the "presentation."

Meszaros goes onto to provide very valuable discussions of Goals of Test Automation, Philosophies of Test Automation, and a Roadmap to Test Automation. We talk about things like Tests as Specification, also known as Executable Specification: "If we are doing test-driven development or test-first development, the tests give us a way to capture what the SUT should be doing before we start implementing it. They give us a way to specify the behavior in various scenarios captured in a form that we can then execute (essentially an "executable specification".) To ensure we are "building the right software", we must ensure that our tests reflect how the SUT will actually be used." We also talk about Tests as Documentation.

The main part of the book, of course, is the catalog of the patterns. Meszaros has provided a tremendous service to our community by not only cataloging and naming much of what we do, but also providing excellent discussions of why and how we do those things. I think, over time, this will be regarded as a seminal work in Software Development.