Programming Books

This book is absolutely solid, especially in its explanation of how consulting firms work. It has a number of helpful tips for what to look out for and what "smells funny" in a contract, and is good value for money just for that alone.

The salary information in it may be a little out of date, and the sample size of salaries is so small and spread out that it's difficult to know what the statistical significance is.

just what one needs to know about consulting in IT.fantastic

This book is good as far as providing lots of useful information, but I can't use its advice just yet as I am just getting into the computer field. In other words, its too advanced for me right now. I am going to order another book listed here, The Secret Path to Contract Programming Riches..." It seems to be perfect for those who want to start from scratch in the computer industry.

But, I will keep this Janet Ruhl book for reference when I am more ready to make the move into contracting.

This book is great for computer contractors or for those considering going into computer contracting. I read this book when I first contracting about five years ago (I thought I had already reviewed it, but my review does not show up). The information is still current and is greatly helpful for those, like me, who want to cross every 't' and dot every 'i', or at least to try to. A great deal of valuable information inside.

In my first book, "The Secret Path to Contract Programming Riches", I chose Janet Ruhl's earlier book, "The Computer Consultant's Guide", as required reading for an overview of the ins & outs of the consulting lifestyle, because it was the ideal complement to the highly specific and technical instruction for the raw beginners targeted in my book.

"Janet Ruhl's Answers for Computer Contractors" will now replace it, as required reading in the next edition of my book, for many reasons:

1) It gives promising contractors everything they need to maximize and maintain a contracting career.

2) It reveals the absolutely important insiders' tips on working with consulting firms, contract brokers and recruiting firms - I've been contracting for over ten years, and I've seen some really wonderful brokers and some really shady brokers. Read this book and put yourself a step ahead of them all.

3) It has answers to practically every important contracting question one can imagine.

4) It helps you decide if the contracting lifestyle is right for you and helps eliminate fears about moving into contracting.

5) By design, it is much more specific to contractors than her earlier book.

Bottom Line
If you are already a salaried computer professional or want an in-depth look at the contracting profession and have an itch for a more flexible, potentially more rewarding and higher-paying career, then I have no doubt that this book will be worth its weight in gold to your career! Now that we have this beneficial guide, I see no reason for anyone to have any unanswered questions about the contracting profession.

~ Michael Nigohosian, Author - "The Secret Path to Contract Programming Riches"

After 2 days of intense reading of Corba for Dummies, I am still a dummy when it comes to Corba. However, after reading first few chapters, I know I won't be a dummy for long. Will SAMS publish more updated edition (for Visibroker 4.x and Java 1.2)?

This book helped me get off the ground when I was trying to convert some Java/TCP code to Java/Visibroker. Very similar to Programming w/ Visibroker.

I have not yet read this book but, the reviews about these books tells me that this is an excellent book.

This book is the difference between going home at 6 p.m. and 6 a.m.

I've been working with Visibroker for Java for about 3 years now. The documentation that comes with the product itself is so bad that the only way I learned anything about the product was from experimenting with it.

About six months ago, I bought this book. I learned more from reading this book than I did from years of working with the product itself. (Usually it's the opposite.)

If you working on a project using Visibroker for Java, or any ORB for that matter, you must get this book. It will save you hours of frustration and you'll have time to spare to play Unreal Tournamnent.

This is a very good book if you are using and JDK 1.1.x and Visibroker for java 3.x.

If you are using Visibroker 4.0 and jdk 1.2 , you may need to read the Visibroker 4.0 documentation on compatability issues before using this book.

There are also some minor typing errors.

Overall This is a great book.

I already read many Oracle books from Oracle Press & other publications. They are very good. This book takes different approch of How-to Style content which is very much practical & solves day to day administrative needs. Topics are covered in detail. Most importantly examples given are from grounds up. Excellent! This book is also helpfull for all who know a little bit of Oracle Database & want to know more in depth

We all know, especially here in Brazil, the money that one pays to have a good Oracle trainning. If you already have a little knowledge of Oracle and its jargon and are self estimulated, this book will take you to high level of expertise without a pain . Want to know Oracle ? Start with it.

Among all the Oracle reference books, I found this one to be the most useful and practical book. This book is very well written and has an easy to read format. The detailed step-by-step instructions in Q&A section helped me solve problems quickly. This saved me much time and effort than going through piles of other reference books and trying to pull pieces of information here and there together to get a complete picture. I highly recommend this book to Oracle DBA's in all levels.

As an Oracle Instructor and DBA I've had the opportunity to review numerous Oracle texts for DBA's and have to say I've been quite disappointed with most of them. Mr. Yuhanna's book however is an exception. Out of the many DBA texts I have on my shelf this is the one I goto most frequently. Unlike other texts which spend excessive amounts of time covering uncommonly used features and little to no time covering commonly used features this books covers almost all the basics in a hands on approach. The book is setup in a step by step how-to format. Although it doesn't discuss concepts much that is not its purpose and the best concepts book is the Oracle Documentation anyway. I've have yet to see a good how-to DBA book until I came across this one. As a consultant/instructor I recommend it quite frequently.

The book is very useful for both new and experienced DBAs because it has a lot of practical examples. I especially like its Q&A format with scripts which makes reading very interesting.

I've read quite a few of Jim's works over the years, and he has never failed to impress me. This book should be required reading for any project manager!

My initial pre-read perception of this book was that it was going to be just another perspective of agile methods. I was wrong. Coplien and Harrison have dissected development teams to identify the key criteria leading to successful efforts and high-performing teams. Beyond process, this book identifies the organizational structures required to make the processes work.

From an organizational perspective, roles and responsibilities within your development teams are a primary success criteria for your agile (or any other process) adoption. This book presents how and why key roles within your teams work and why teams without these key roles don't work. The way they have presented the material provides for a quick cross-reference when you are looking for solutions to help your teams.

Beyond the organization patterns themselves, I believe some of the richest material in this book is presented in the last few chapters as they present the history and importance of organizational structures, roles and responsibilities in applying process - "Process emerges from structure, and structure emerges from values". There is great value in this book beyond most software development process books.

As project managers, most of us who've been in the field working for a while come to realize that successful project teams are more the result of "good" ongoing social engineering of one sort or another rather than just dumping an almost randomly selected group of people together, coming up with an MS Project Plan and saying "do this" (the Death Star approach, all to common in large traditional process-driven IT shops). After this has happened to you, painfully, you begin to come to the realization that perhaps there's more to project management than the mechanistic "people are interchangeable resources" PMBOK-style approach.

If it hasn't already, it begins to dawn on you that the "soft" side of project management (client relationship building, communication within the team and between teams, team dynamics and team morale, motivation, empowerment, commitment, a human-style of project management) are as important or even more important than the technical work and the technical skills required. Most of us have run across teams with prima-donna's who think they're the cat's whiskers, be they project managers or technical personnel, who have the personal graces of a warthog and who are incredibly destructive to team morale and team performance. They continue to exist, sadly, and because they often deliver, albeit at the expense of everyone who works for them or with them, they continue to survive in "Death Star" style IT shops where delivery is all important and the style of successful delivery means nothing or is short-sightedly disregarded. OK, so that's my rant.

Now for the book. We've all seen successful projects and successful teams (or at least, I hope we all have). Some teams gell and perform way above the norm. What this book does is distil over 100 successfully applied organizational patterns of one sort or another from real projects in real software development groups. These patterns are broken down into logical groups (Project Management Patterns, Piecemeal Growth Patterns, Organizational Style Patterns & People and Code Patterns) which are dissected and explained, with examples provided. What the authors have done is to identify and describe key organizational patterns which are used by successful teams - not processes, but organizational structures of various types that are needed to make processes work successfully. A large amount of practical experience has gone into the content - over ten years of research experience from the authors alone.

I've read a lot of books on Agile, but this is the first I've come across that sets out organizational patterns - and does it so effectively that you'll wonder why all the stuff in here never occurred to you before. As you read through the book, you'll see patterns that will make sense, the kind of "ah-ha, that's what the problem is and this is how I can dom something about it" sense. You'll find this book useful in that the contents can be taken and applied right away. It's easy to pick what is most useful for your team, what can be applied immediately and what would be nice later on, once some of the basics are in place. The content is practical in that you can easily identify what your problems are and what pattern would help fix it, why the pattern is intended to fix it, and there's good advice on how to introduce new patterns.

With over 100 patterns, there are a lot, but they're set out concisely, a page or two to each pattern. There's no fluff, it's well-written, there's no appreciable bias, there's a lot of material, including some good coverage of the importance of effective organizational structures in applying process. As we all know, all the process in the world will not a great project team make. The book's structure is coherent and well-organized, the patterns described can be used individually or as groups and the authors give you some pretty good ideas as to what's immediately useful.

And the pictures all the way through the book are great! A nice humorous touch that helps make the point each time. Overall, I'd recommend this book very highly as a resource to anyone managing a project / team, whether Agile or not. There's a wealth of practical advice in here that any project manager could take and use, although the orientation is towards Agile Projects. An added bonus - unlike many technical books, this one won't date quickly - organizational patterns that work don't change much over the years, unlike programming languages. From a practical point of view, I've applied some of these patterns to teams I work with and the results have been positive - I've also shared the book with co-workers and they've all found it both illuminating and useful.

This book has to be The Grand Unifying Theory of Software with respect to managing the people and processes involved in software production.

To anyone who has worked in the software industry, this book is clearly the product of an enormous amount of practical experience in both management of people and projects as well as the development of software.

Coplien and Harrison have written a book which both the project manager and software engineer will understand and will immediately be able to apply to their respective work environments: This is because the book cunningly captures essential organisational concepts using a framework that is familiar to software engineers. Thus, the concepts will be by recognised by staff trained in business as well as those trained in software and systems.

I strongly feel that the material covered in this book can achieve a common communication basis between managers and engineers, and can help business developers understand the nature of their people and organisation.

If I could insist that all people in software read this book I would; but without the policing power, I can only highly recommend this book to those involved in all facets of software.

OK, I have to admit, this is the first book review I've ever written on Amazon and having read a lot of good books I should probably get off my a** and write more :-)

As a former developer and now a software development manager, I have come to realise that the "soft side" or sociology of software projects (communication with clients, communication with teammates, project management, team dynamics, cultural issues, morale, division of work, remote collaboration, etc) is considerably more complicated than the programming work itself.

Over time, you start to see patterns emerge such as "start a large project with a small experienced group and gradually phase people into a project as time goes on". This book does by far the best job of cataloguing and explaining dozens of these patterns related to (1) software project management (2) structuring, building and nurturing software project teams and (3) organization and division of development tasks to maximize the effectiveness of the team as a whole.

Highly recommended to anyone involved with software development at both the management level and in the trenches. Have fun!

Issues specific to Open Source are well-covered in this book. I found the section titled "Handling Difficult People" especially useful; his advice in this dodgy area is to act eloquent and keep feedback directed at the problem, not the person. If the person *is* the problem, nip in-public issues in the bud and contact the person directly to resolve the personal issue(s).

Fogel presents lots of down and dirty day-to-day details on how to create excellent software. Not just Open Source, either... the transparency built into the processes he describes are also useful within a company firewall.

Fogel places a huge emphasis on development by random unsalaried people, but I feel that most important and rapid development is due to corporate sponsorship.

Overall: excellent. Read it cover to cover, refer back to it often.

If you are thinking of starting/managing a project in an "open-source" model, this is the book you MUST read.

The book is very well written and goes over lessons learned of others that created their own open-source projects. Believe me... every step so you don't have to guess anything!

How to start, how to document, where to deploy the project, what people to invite, whether or not coding standards are necessary, democracy versus dictatorship, all of these questions are answered inside.

A friend of mine has told me that much of the information in this book can be seen for free in video in Google. It's worth looking for.

I read the book in 5 hours and i think my time was very well invested. I now believe that this model is not only suitable for small projects but to larger projects. The complexity of the system will not the an issue if you apply the rules in the book. I still have to try it though... ;-)

Just yesterday I was talking to a friend about this book and we discovered each other very glad with it. First of all, the author has a lot of experience with the theme in question. Furthermore, Karl Fogel is very compelling with words. He knows how to write down his experience in a way that is pleasant, certainly due to a lot of writes he had made through plenties of open source projects.

With this book you will be in touch with topics like the needed infra-structure to setup open source projects, the dinamics of the open source community, strategies for packaging and releasing software, common issues that arise in open source daily development and how to workaround then, a brief about licenses (with properly links for more information on this topic); just to highlight some aspects.

This book was the first hand someone land me into the open source world. It's helping me in three ways: to extract more from open source softwares that already exist, to start my own open source project, and to look at software development through a new, different, and till now better perspective.

Hope this review helps you!

If you have already read pretty much everything that there is to be read about why you'd want to start, manage, fund or participate in an Open Source project, but want to know everything about how best to do it, then Karl Fogel's Producing Open Source Software is the book for you.

Drawing from his extensive experience with the Subversion project, Fogel provides in this book a comprehensive overview of all aspects of Open Source software development, covering technical, social, political, economical, legal, and managerial aspects.

While the book is more aimed at medium-to-large scale projects, especially those involving some kind of corporate entity, there is much in it that is applicable to most projects, excluding maybe only those little, one-man efforts that rarely become successful. But if you are the originator of one of the latter and, should it suddenly attract a wide following, you'd better be prepared to face the unavoidable problems that popularity brings.This book will come in handy in this case.

Here are, in my opinion, the strong points of the book:

* Providing a concise, yet comprehensive, overview of all aspects of Open Source development. This is really the manual of open development.

* Demonstrating that there is much in open development that is similar to more traditional, corporate-style software development (you cannot always rely on good will and volunteers), but also much that is different, in motivation, rewards and objectives.

* Putting the accent on the human aspect of development: mutual respect between participants is often the deciding factor in determining whether a project will thrive or fail. Since even the best of intentions sometimes are not enough to foster a peaceful, productive and collaborative environment, Producing Open Source Software contains a lot of useful, practical advice that you can follow if you want to keep developers happy and motivated.

It's easy to make the mistake of viewing this book as "too fluffy" or perhaps too soft to be of any use to the practical user or developer of open source software. Nothing could be further from the truth: in a classic open source way, the author has compressed man-centuries of OS community experience into a practical working guide for anyone who wants to do something serious in this area.

If you want to understand programming the Flash Communication Server and it's capabilities this is a good place to start.

Although I'm using Flash Media Server 2, this book is still highly relevant as not much has changed. The core objects and language is the same so I would not hesitate to recommend it for anyone looking to use FMS.

This book is all about the design of applications using Macromedia's Flash Communication Server MX. FCS MX enables the building of media-rich web applications by taking care of the basic tasks required in the networking of the applications. Thus, you can focus on the application itself rather than worrying about low-level communication details.

Since this book is concerned with situations where multiple Flash applications will be executing on the same server simultaneously, there is going to be considerable effort involved in coordinating events, which is addressed by this book. You should already have FCS installed and running on your server and you should also have Flash MX available on the client. The following is description of the book by chapter:

Chapter 1, Introducing the Flash Communication Server - Acts as an introduction to FCS and an overview of the whole book.

Chapter 2, Communication Components - How the FlashCom communication components encapsulate commonly needed features such as chat, video recording and playback, bandwidth control,and user configuration. These components implement many basic building blocks for your application.

Chapter 3, Managing Connections - This chapter covers connections in more depth past the SimpleConnect component, including how to write custom code to handle various changes in the connection status as well as different errors.

Chapter 4, Applications, Instances, and Server-Side ActionScript - This chapter describes how to write Server-Side ActionScript and work with the objects that control application instances and the Flash movies that connect to them.

Chapter 5, Managing Streams - Offers a somewhat oversimplified but complete example that shows the basic steps in publishing one live stream and subscribing to a second.

Chapter 6, Camera and Microphone - This chapter explains how to use both the Microphone and Camera classes to record live streams. These classes are at the heart of most communication applications involving multimedia.

Chapter 7, Media Preparation and Delivery - This chapter covers many details for compressing and streaming audio and video.

Chapter 8, Shared Objects - This chapter starts an entirely new subject - shared objects, which provide a mechanism for the transmission of data between client and server.

Chapter 9, Remote Methods - This chapter also shows how to broadcast method calls to every movie and application instance connected to a shared object or stream, or send them to and from individual movies using RMI.

Chapter 10, Server Management API - Discusses the Server Management API and its applications, including monitoring a FlashCom Server, gathering statistics on application instances, and managing the log streams.

Chapter 11, Flash Remoting - Demonstrates how Flash Remoting can be used to add data connectivity to FlashCom applications. Flash Remoting can access web services, server-side scripts, CGI applications, XML files, or the local filesystem with the help of an application server such as ColdFusion.

Chapter 12, ColdFusion MX and FlashCom - Teaches some specifics involved in using Flash Remoting with ColdFusion MX and FlashCom. There are some practical working examples shown that demonstrate how you can leverage the benefits of Flash Remoting in conjunction with FlashCom.

Chapter 13, Building Communication Components - This is the first step in building complete applications, and is demonstrated through an extensive example.

Chapter 14, Understanding the Macromedia Component Framework - How to modify an existing component and how to create a new one. Also discusses server-side framework code and its core features and data structures.

Chapter 15, Application Design Patterns and Best Practices - Describes some of the best practices available to application developers. This chapter provides some useful design options, patterns, and best practices that will help you build better applications.

Chapter 16, Building Scalable Applications - Deals with building multi-instance and multiserver applications that don't bog down as the number of client connections increases.

Chapter 17, Network Performance, Latency, Concurrency - Traditional network design issues affect FCS also.

Chapter 18, Securing Applications - Specifically this chapter examines the three A's of security - Authentication, Authorization, and Accounting.

Excellent book, stuffed of examples very well explained, easy to read and to understand, essential for who desires initiate or even though to profound itself studies on FlashCom.
Obligator reference in projects involving FlashCom, either for fast consultations and advanced tasks.
Excellent approach of subjects as Design patterns and security, yonder a perfect demonstration about audio, video and much more.

If you're a developer looking into real-time server communication using Adobe Flash, this book is a must-have. It guides you thru various levels of application development in an easy to understand format, and provides well documented pieces of code to assist you in the learning process of putting together your project:

Topics covered include:

- learning about components and how to use them
- establishing and managing client connections
- publishing live and recorded streams
- local communication with clients
- remote communication with outside applications

The book also shows how to build and integrate your own custom components, and how to scale your application using the components that you've created. Other highlights include information on how to use shared objects and server management API, as well as ways to improve both design and performance.

this is far the best com book I have read. I am happy to be in possession of one

It's a great book to possess, When it comes to Component programming. After Don Box "Essiential COM", this is by far the best COM+ book I have read. It will give you good understanding about not just writing but design and implementing COM+ Components. Examples are great and right to the point.

I finished this book over a year ago, and never got around to writing a review. Probably won't help too many with most of the new development moving to .NET, but here goes. Overall, it was solid but I thought it could have done two things better. I thought the coverage on MSMQ could have been stronger and the project at the end did not get tied together as well as it should have. I like the approach of a lot of the Wrox books that really get into detail WHY they're doing something in their projects they use to tie their ideas together. I felt as thought the author really almost rushed this section of the book, and, in doing so, missed the opportunity to really drive home his points. Hopefully he reads these and will take a page out of the Wrox books in really getting down to explaining his reasoning and what is going on when he's tying his ideas together with a project in his next book. I thought he did an outstanding job up to that point though.

Scot Hillier's book COM+ VB is destined to be considered a classic among the great big programming books. I wouldn't jerk you around. In fact I can honestly say I love to read Scot's work. Tony Davidson once said "A Smith can be a common man, but does that mean I see a Smith and think: "There before
heaven go I"? There is absolutely no need to ponder. In fact to ponder this is to get confused. I read and laid down the book again. Soon I'll read more.

Joanne Brady

I started my COM+ learning experience with Peishu Li's "Visual Basic and COM+ Programming by Example" and then used this book to get a more advanced look at COM+. This was NOT money wasted. I highly recommend both books to users wanting the learn about COM+ and n-tier. This book is very well written. Developers with a background in MTS may want to skip the "by Example" book but you definitely want to read this book. Scot Hillier understands COM+ (and MTS for that matter) and his style of writing is pleasant to read.

This book was written when Dungeon Siege I and Neverwinter Nights I were in development, and thus lacks any information regarding their sequels, Baldur's Gate II, Diablo II, Titan Quest, Morrowind, and ultimately Oblivion. It briefly discusses UO and mentions both Asheron's Call and Everquest, the early mainstream MMOs. Don't expect anything regarding WoW, DAoC, EQ2, DDO, AO or Lord of the Rings Online. That's a lot of material that just didn't exist when this was published.

However, for what it contains, it's VERY good. It has a great introduction on the early development of RPGs. You'll find good information on the influence of Dungeons and Dragons and Lord of the Rings on CRPGs. The interviews at the end are excellent reading as well.

The book sets out to guide new RPG designers through the do's and don'ts of CRPG development, and give them a good background on why things are the way they are. It lays out what you need in your proposal and design document, with plenty of examples. It really does an excellent job in all of this. If you're looking for code, look elsewhere. You won't find ANY in this book. It's intended for designers, not programmers.

If you can grab it for under ten bucks like I did, go for it. Everything inside the book is still useful and the guiding principles are accurate even with all that's happened since it was published. I just wish there was a second volume that included all of the new stuff.

This book wasn't at all what I thought it would be, but I loved it. I finished it within a day.

Don't buy this book if you are expecting someone to tell you the steps involved in making an RPG. There are many better books for that. S&C doesn't tell you how to make a game. It tells you how to THINK when making a game. It also goes quite in-depth about what it's like to be in the role of a game designer.

So the two scenarios in which this book would be most useful are:

1. You have a game already designed in your head and just want to make it more fun or more professional.

2. You are considering whether you want to become a game designer as a career.

If you fit one of these two, buy this book right away. If not, it might still be worth a look. It's interesting, well-written, and you may just learn a thing or two.

First and foremost I have to say this book is very well written and easy to read. The only real mistakes I noticed were with release dates on some of the games in a timeline.

The concepts covered in this book will help not only individuals trying their hand at designing RPGs, but other games as well. The information is also presented in an interesting and entertaining way to keep the reader doing just that, reading.

Having recently entered the video game industry, I would recommend this book to anyone seeking to get a start in the industy or anyone just curious about game design in general.

Neal and Jana Hallford, Swords and Circuitry (Prima, 2001)

A word to prospective buyers: Swords and Circuitry is not a book about coding games. If that's what you're looking for, Prima has a number of other titles you can go to. This one's about designing games, and there's nary a line of code to be found.

Okay, now that that's out of the way, this book does have a lot to offer both for those who plan to specialize in game design and those who are running (or trying to run) one-man shops. The Hallfords offer a good deal of advice regarding the whole process of game design, from defining what it is (and having others interviewed by Neal Hallford do so as well) to details of design documents, proposals, etc. The benefits for the aspiring game designer are obvious; to the one-man shop, reading this may help clarify some things that will help when programming time comes, or shed a different light on things that may not have been thought of in quite that way. Definitely worth checking out, but know what you're getting. *** ½

This book provides a clear outlook of how to design an RPG though I wish there was a reference book to go with it. It even could be used as a text book for a class. It does everything it says. Includes other designers perspectives to broaden your perspective on design including designers from Might & Magic, Neverwinter, Star-Trek, and a few others.

I had originally bought this book for son who was going to spend the summer working for my development team writing unit test for our database POJOs. I was so impressed way in which concepts were incrementally introduced I read the book cover to cover. It is now the only book I recommend to beginners and I introduce it as a 'must' read for all my new hires.

This is my new favorite-book-to-give-to-anyone-who-is-learning-or-using-Java.

The title is misleading in that this book is about much more than just the Agile Programming stuff. While it does a great job talking about Agile techniques and always starts by creating a unit test, the book really is about all aspects of Java (specifically Java 5) programming. Anyone who takes the time to work through the examples will become a much better Java programmer.

OO patterns, collections, type safety and more are covered and explained in the context of a rich, in-depth example. And because the author has you construct a high-quality test suite around the example, you are free to experiment with different ways to implement each new feature - thus proving to yourself the benefits of Agile design.

Just like it says in one of the quotes on the cover, this book is now required reading for the Java programmers at our company.

I'm not a beginning programmer, or even an absolute Java novice, so maybe this book isn't really aimed at me. My biggest gripe is that the code snippets continue on and on making the book very poor for anything other than cover-to-cover reading.

I've gotten about 6 chapters into this book and I love it. I've been developing Java for almost 7 years and am currently teaching myself Agile principles and this book comes as a great help.

This book is primarily for new programmers who want to learn Java as their first programming language. The book can also be helpful for programmers familiar with test driven development (TDD) but new to Java, or vice versa. I am an experienced Java developer, and I found that going through Agile Java presented me with a new and better way of approaching Java code development. This book covers Java 2 Standard Edition (J2SE) version 5.0, but covers only a few of the additional APIs at an introductory level. Technologies that are used pervasively in the majority of enterprise applications, such as logging, JDBC, and Swing, are presented in Agile Java. Some of the information, such as that on logging, will teach you all you need to know for most purposes. Other lessons, such as those on Swing and JDBC, will give you a basic understanding of the technology and will tell you where to go when seeking further information.

The core of Agile Java is fifteen lessons of about 30 pages each. It starts with baby steps in Java, TDD, and OO. The book finishes with a strong foundation for professional Java development. The core lessons should be read sequentially since each lesson builds upon the previous ones. Once you have completed the core lessons, you should have a solid understanding of how to build robust Java code. If you haven't completed the fifteen core lessons, you should not assume you know how to write good Java code. Each of the fifteen core lessons in Agile Java has you build bits and pieces of a student information system for a university. This single common theme helps demonstrate how you can incrementally build upon and extend existing code. Each lesson also finishes with a series of exercises. Instead of the student information system, the bulk of the exercises have you build bits and pieces of a chess application. Some of the exercises are involved and quite challenging, but they are where learning the methodology really begins.

There are three additional lessons to cover a few more Java topics. Two of the lessons present an introduction to Swing. These two lessons will provide you with enough information to begin building robust user interface applications in Java. But the bigger intent is to give you some ideas for how to build them using TDD. The third additional lesson presents an overview for a number of Java topics that most Java developers will want to know such as JARs, regular expressions, cloning, JDBC, and internationalization.

I really liked how the author integrated the three concepts of Java programming, TDD, and object-oriented design without confusing matters. The book is very clear with good illustrations. I highly recommend it. The following is the table of contents:

Lesson 1. Getting Started
Lesson 2. Java Basics
Lesson 3. Strings and Packages
Lesson 4. Class Methods and Fields
Lesson 5. Interfaces and Polymorphism
Lesson 6. Inheritance
Lesson 7. Legacy Elements
Lesson 8. Exceptions and Logging
Lesson 9. Maps and Equality
Lesson 10. Mathematics
Lesson 11. IO
Lesson 12. Reflection and Other Advanced Topics
Lesson 13. Multithreading
Lesson 14. Generics
Lesson 15. Assertions and Annotations
Additional Lesson - Swing, Part 1
Additional Lesson II. Swing, Part 2
Additional Lesson III. Java Miscellany
Appendix A: An Agile Java Glossary
Appendix B: Java Operator Precedence Rules
Appendix C: Getting Started with IDEA
Agile Java References

This book is absolutely excellent. Gusfield walks the reader from simple concepts in string matching through advanced in a way that I found very easy to follow. Every bioinformatics researcher should have copy of this text.

A well written text book with an obvious bias to biological application, but maybe most useful for its clear explanation and rigour of string algorithms.

If you haven't read this book, you don't know biological string matching. The book's focus is clearly on string algorithms, but the author gives good biological significance to the problems that each technique solves. I came away from this book understanding the algorithms, but also knowing why the algorithms were valuable.

No, there isn't any real source code here. That should not be a problem - this book aims above the cut&paste programmer. The book in meant for readers who can not only understand the algorithms, but apply them to unique solutions in unique ways.

String matching is far too broad a topic for any one book to cover. The study can include formal language theory, Gibbs sampling and other non-deterministic optimizations, and probability-based techniques like Markov models. The author chose a well bounded region of that huge territory, and covers the region expertly. The reader will soon realize, though, that algorithms from this book work well as pieces of larger computations. The book's chosen limits certainly do not limit its applicability.

By the way, don't let the biological orientation put you off. DNA analysis is just one place where string-matching problems occur. The author motivates algorithms with problems in biology, but the techniques are applicable by anyone that analyzes strings.

The text sits at the intersection of computer science and computational biology. It centres around the observation made by the author and others that often in CS, one has to manipulate strings of text, which are just sequences of text. While in computational biology, a recurrent theme is how to deal with sequences of molecules. These might be in a DNA sample or in a protein.

Surprisingly, from this simple observation, Gusfield manages to gather together considerable material. Over the decades, computing has accrued many algorithms for text string processing. The book's merit is in presenting those which are also applicable in bioinfomatics. The level of treatment is sophisticated, from the computing vantage. Enough so that perhaps the typical geneticist might not be able to easily follow the narrative. But a researcher with a strong background in both fields might be able to benefit.

If you like definition-theorem-proof-example and exercise books, Gusfield's book is the definitive text for string algorithms. The algorithms are abstracted from their biological applications, and the book would make sense without reading a single page of the biological motivations. Gusfield aims his book at readers who are fluent in basic algorithms and data structures (at the level of Cormen, Leisersohn and Rivest's excellent text). The exercises are wonderfully illustrative, being neither trivial nor impossible.

All of the major exact string algorithms are covered, including Knuth-Morris-Pratt, Boyer-Moore, Aho-Corasick and the focus of the book, suffix trees for the much harder probem of finding all repeated substrings of a given string in linear time. In addition to exact string matching, there are extensive discussions of inexact matching. Even the discussions of widely known topics like dynamic programming for edit distance are insightful; for instance, we find how to easily cut space requirements from quadratic to linear. There is also a short chapter on semi-numerical matching methods, which are also of use in information retrieval applications. Inexact matching is extended to the threshold all-against-all problem, which finds all substrings of a string that match up to a given edit distance threshold. The theoretical development concludes with the much more difficult problem of aligning multiple sequences with ultrametric trees, with applications to phylogenetic alignment for evolutionary trees (an approach that has also been applied to the evolution of natural languages).

Note that there is no discussion of statistical string matching. For that, Durbin, Eddy, Krogh and Mitchison's "Biological Sequence Analysis: Probabilistic Models of Proteins and Nucleic Acides" is a good choice, or for those more interested in language than biology, Manning and Schuetze's "Statistical Natural Language Processing". There is also no information on more structured string matching models such as context-free grammars, as are commonly used to analyze RNA folding or natural language syntax. Luckily, Durbin et al. and Manning and Schuetze also provide excellent coverage of these higher-order models in their books.

This book is not about efficient implementation. If you need to build these algorithms, you'll also need to know how to write efficient code and tune it for your needs. This is an algorithms book, pure and simple.

As a computer scientist, I found the discussions of computational biology to be more enlightening than in other textbooks on similar topics such as Durbin et al., because Gusfield does not assume the reader has any background in cellular biology. Instead, he provides his own clear and gentle introductions illustrated with algorithms, applications, open problems and extensive references. Like most Cambridge University Press books, this one is beautifully typeset and edited.