2 comments about Core Internet Application Development with ASP.NET 2.0 (Core Series).

1. Read the book from start to the end. Not to be harsh, this is not a good book for the beginners, nor for experienced users. For beginners, the book doesn't explain some of the topic clearly, such as Page Life cycle. The way the book explain this topic might scare readers away from learning ASP.NET; for medium level programmers, this book doesn't touch any of the advanced topic, such as building custom controls. Also for the amount of knowledge covered in the book, the size should be reduced to 500 pages. If you want to learn ASP.NET, Beginning ASP.NET 2.0, Pro ASP.NET 2.0, and ASP.NET 2.0 Website Programming: Problem-Design-Solution are the three definitive books.



2. I recommend this book to experienced developers, although the topics are discussed clearly enough that a patient novice developer will gain much. Because the book assumes the reader has knowledge of basic web technologies, those with a background in earlier versions of ASP.NET or other web development platforms will get the most out of it.
   
   The approach the author took was to give the reader the most pertinent information to bring him or her up to speed quickly. Only the most useful information is presented--which is why the book contains the word "core" in the title rather than "complete." For example, when presenting a new control to the reader, the author discusses only the most-used features of the control. Often, he will mention other, less-used features so the reader knows they are available, but will not provide examples or provide much detail over these non-core features. If you are looking for an exhaustive reference of all the features of ASP.NET 2.0, this is not the book for you. However, if you are looking to learn ASP.NET 2.0, this book will cover 90% or so of the features you will likely use for any project.
   
   The typical presentation of an aspect of ASP.NET 2.0 in this book is to provide a brief description, a screenshot or two, and an explanation of what kind of situations are appropriate for its use. Most items also include example code, with additional screenshots. I especially appreciated that the examples were simple, but clearly demonstrated the use of the item they were explaining. The code for the examples was presented in its entirety, but use of bold text on the pieces being demonstrated made the examples very understandable and helped me go through them more quickly than the typical code example. Also the use of labeling in the screenshots made it easy to see the results of what each code example was doing.
   
   Overall, this was a very efficient way to quickly learn about each feature of ASP.NET 2.0. The book was a surprisingly fast read for a technical manual. Right at the point where I became bogged down with too much detailed information about controls, data sources, etc, the author took a step back and began discussing higher-level topics such as contemporary software design and the appropriate use of layers or tiers when designing a web application. Although I have had experience designing multi-layered or tiered web applications, this higher-level discussion was nice because all the details of ASP.NET 2.0 were very fresh in my mind. I was able to think about application design in a new light now that I understood the capabilities of ASP.NET 2.0.
   
   The book's last few chapters step away from the web applications themselves and discuss the "other" things pertaining to ASP.NET 2.0, such as web services, security within web applications, and deployment of applications. These are useful in that they give a slightly more complete set of information on developing internet applications with ASP.NET 2.0.
   
   Summary -
   
   If you are looking for a way to quickly get up to speed in ASP.NET 2.0, without getting bogged down in too many details, I highly recommend this book.

1 comments about Practical IDL Programming.

1. If you're like me, you've probably been confused at times by the semantics of IDL. I've been using IDL for several years now and I still run into obstacles every now and then. What I needed was a book that went through the basics first (like a C or Fortran book) and then covered the really practical stuff like plotting, imaging, saving output etc. Liam Gumley has done a great job here in showing the reader how to put IDL to work. I also own Dave Fanning's book, and the two books complement each other nicely. However I'd have to give the edge to Practical IDL Programming for it's clear and straightforward explanation of IDL fundamentals, and for very clear and well explained example programs, many of which I now use every day.

4 comments about Pattern-Oriented Software Architecture Volume 4: A Pattern Language for Distributed Computing.

1. This is a great book. It pulls together 114 patterns and shows how to use them in the context of distributed software architectures. It also claims to reference 150 patterns in other publications.
   
   The authors did a great job of creating a language composed of patterns for distributed software architectures.
   
   The book does not go into the details of the pattern's implementations, so you should already be familiar with the patterns, or be prepared to spend some time researching. They do provide brief descriptions and a model for each pattern included in the language. If you need to research a pattern a little more, that shouldn't be a problem because they have included an excellent References section that contains sources for all the patterns original resources and they do a great job pointing to them throughout the text.
   
   The book's best attribute is in how they show the relationships between the patterns. At the beginning of each section they include an introduction to a problem area that ties all the patterns in that section together.
   
   They have broken the language up into the following sections:
   From Mud To Structure
   Distribution Infrastructure
   Event Demultiplexing and Dispatching
   Interface Partitioning
   Component Partitioning
   Application Control
   Concurrency
   Synchronization
   Object Interaction
   Adaptation and Extension
   Modal Behavior
   Resource Management
   Database Access
   
   Although the book is a pattern language for distributed software architectures, the patterns are definitely usable in other contexts.
   
   I used the search on this page to check out the internals of the book before buying it.
   
   Every Software Architect should own a copy of this book. It is a wealth of information. If you have a Software Architect working for you, you should make this mandatory reading in order for them to keep their job.



2. I found this book more theoretical and I personally would like to read books that have a flow with concepts, examples and practicality. Lot of material to read and if not put in practice you loose it. Some of the books of my taste are like Accelerated C++, Effective STL etc.



3. I don't have much to add over T. Anderson's review, but wanted to weigh in with a 5-star vote as a practicing distributed-systems architect. In particular I'm irritated by the one-star review from the person who obviously didn't understand what he/she was buying.
   
   This is as close as you're going to get to a one-stop "encyclopedia" of patterns relevant to distributed computing (and other areas as well). I own most of the architecture/design patterns books, but this is the one I'll go to first for ideas, study, and use as a reference.
   
   As for content, the catalogue of patterns is more comprehensive than any other volume I'm aware of and it is well organized. Each chapter describes a group of patterns that address recurrent vertical and horizontal architectural problem spaces. Each group is briefly introduced and described in the context of that. These introductions are pithy, on-target, and along with the complete pattern descriptions almost constitute a good introduction to distributed computing in general.
   
   Most patterns are described in two pages in a format that has been well-honed over time for usefulness and comprehensibility. You find out where and when each pattern is likely to be useful, what motivates it, how it works, pros and cons, and what other patterns might be used with it.
   
   The cross-referencing between patterns both within this book and in other sources is extensive and one of its most valuable features. The authors provide you with 114 pattern descriptions cross-referenced with "over 150" from other sources. That's a pretty extensive language!
   
   Lots of spelling errors and such, but nothing that should confuse anyone.
   
   This book is NOT a true encyclopedia, and you will want or need some of the core volumes that cover the "over 150" patterns that are referenced but not described here. The most notable are:
   
   Patterns of Enterprise Application Architecture (The Addison-Wesley Signature Series)
   
   Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions (The Addison-Wesley Signature Series)
   
   Remoting Patterns: Foundations of Enterprise, Internet and Realtime Distributed Object Middleware (Wiley Software Patterns Series)
   
   Most, if not all, of the material in Pattern-Oriented Software Architecture Volume 2: Patterns for Concurrent and Networked Objects is covered in Volume 4. If you don't have that book you might want it for deeper discussion of some of the patterns. On the other hand, the current volume contains important updates to a couple of patterns in the earlier volume.
   
   If you're new to patterns, please avoid Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series), also known as the "GoF" (Gang of Four) book. It is a classic and the authors deserve their "props" for introducing design patterns to the broader development community, but it is the worst-written and most misleading book I've ever read on patterns. (In fairness to the authors, it was the "grand-daddy" of them all and perhaps they can be excused for not having the intervening 12 years of experience in pattern documentation to help them.)
   
   I've heard good things about Head First Design Patterns (Head First) and Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development (3rd Edition) from people who have read the GoF book, so you might try that. I haven't read either myself.
   
   If you're familiar with patterns and want perhaps the most comprehensive and useful single pattern book to date, especially if you're involved with the architecture of distributed systems, buy this!
   
   It is not for beginners or those looking for boilerplate code!



4. This book is an absolute must for system architects, system engineers, system testers, and developers.
   
   I have been working DoD systems since 2000 and have studied and studied and studied trying to synch DoD's efforts to embrace SOA and distributed systems with commercial concepts, approaches, and practices. I have tried to specify system requirements from architecture views and contrived requirements trees. I have had GOF's book and POSA 1 since 2002 but, by themselves, they only make a certain level of sense. In addition, countless other books and methods only provide parts of the overall distributed system view. I have been very frustrated.
   
   This book, while not the complete picture, provides a wire up of hundreds of different approaches. The authors provide a logical approach and path to defining distributed system architectures. The authors point the reader to dozens and dozens of other references to allow them to dig deeper. When they disagree or choose why they don't implement a pattern a certain way, they provide logical rationale to go with it and provide references for the other ways you could attack the problem.
   
   Requirement developers/managers and system architects should sleep with this under their pillow. To specify system requirements using the right terminology that does not force an implementation is a primary objective. To evaluate a developer's design requires a comprehensive understanding of the forces at play in a distributed system. This book provides a roadmap. I am now much less frustrated. In fact, I am much more motivated.
   
   Ah... now to read all the references...

3 comments about Oracle Regular Expressions Pocket Reference.

1. "ORACLE Regular Expressions" is a booklet about the new ORACLE 10g SQL functions that work with regular expressions:

   - REGEXP_INSTR
   - REGEXP_LIKE
   - REGEXP_REPLACE
   - REGEXP_SUBSTR

   The authors describe the new functions and the ORACLE regular expression dialect (what kind of patterns the regexp engine handles).

   The book consists of five chapters:

   - Tutorial (an introduction into regular expressions)
   - ORACLE's regular epression support (the functions, NLS support, Perl vs. ORACLE regular expressions)
   - Regular Expression Quick Reference (explanation of the regexp dialect that ORACLE understands, what metacharacters does what and so on)
   - ORACLE Regular Expression Functions (who to call the four functions mentioned above)
   - ORACLE Regular Expression Error Messages (the new ORA- errors related to regexps)

   Unfortunately I had no access to an ORACLE 10g database at the time of writing this review (ORACLE 10g was not available for download the "normal" users yet), so that I was not able to test the new functions and the examples in this book (although I am looking forward to do this sooon).

   I think that "ORACLE Regular Expressions" is not sufficient to learn Regular Expressions from scratch but this was not the goal of this book anyway. If you are new to regular expressions, get J. Friedl's book "Mastering Regular Expressions" (the very best book about regular expressions in general). Afterwards "ORACLE Regular Expressions" will be perfect as a small reference book for the ORACLE regexp implementation.

   I liked the comparison between ORACLE and Perl Regexp Support (I am a big Perl fan, and did lots of DBI programs on ORACLE with Perl). Unfortunately this book is missing an example on how to create a function based index to support REGEXP_LIKE queries (the possibility was mentioned) and get no full table scan.

   The pocket reference book from O'Reilly does not contain an alphabetic index. However because of the good table of contents and the small size of the book, having an index is not really necessary.




2. This pocket-sized 60-page booklet covers only one topic: the regular expression support in Oracle Database 10g. And it covers it well. Though the book's cover says "pocket reference", the book actually contains both a short tutorial and a reference.
   
   The tutorial does a good job of explaining basic regular expression concepts. It doesn't provide a lot of examples or detailed explanations. But if you're apt and don't mind to experiment a little, it'll probably be all you need. Oracle's regular expression flavor is fairly limited, so there aren't many tricky concepts to explain.
   
   The second half of the book is the actual reference. The first part of the reference lists all of the available regular expression tokens, along with a brief but clear description of what the token matches, and one or two examples. The examples use only literal text, so you can try them in Oracle without needing a particular example database.
   
   The second part of the reference describes Oracle's four regular expression functions: REGEXP_INSTR, REGEXP_LIKE, REGEXP_REPLACE and REGEXP_SUBSTR. All the parameters that these four functions accept are fully explained, with clear indications of what all the possible values for these parameters will do. The book shows several examples for each function, again using only literal text. You can easily replace the strings with column names in your actual SQL code.
   
   The final part of the reference lists all 10 error codes that the regexp functions can trigger, along with a one-paragraph description explaining exactly what the error is about (which isn't always obvious from the error messages themselves).
   
   All in all this is an excellent little book. It's probably all you need to successfully use regular expressions with Oracle.
   
   Many people recommend Mastering Regular Expressions to go along with the Oracle book. I disagree. Oracle implements POSIX regular expressions, which are a fairly limited subset of modern Perl-style regular expressions. (Actually, Perl's regex syntax is a significant extension of POSIX.) Mastering Regular Expressions barely mentions POSIX, and never mentions Oracle. It mostly talks about the advanced regex features in Perl, Java, .NET and PHP. If you use any of these languages, buying both Mastering Regular Expressions and Oracle Regular Expressions is certainly a good idea. But if you're a database administrator working solely with Oracle, the Oracle Regular Expressions Pocket Reference is all you need.



3. This book provides not only the basics and some extras on the built-in Oracle utilities for regular expression handling, but also provides a nice "translation manuscript" if you are used to working with regular expressions in languages such as Perl, Java, C++, etc.
   
   Great little reference and especially useful for translating your regular expressions between engines.

5 comments about Professional .NET 2.0 Generics (Programmer to Programmer).

1. I wanted to understand everything on Generics and finished the book with only a few new concepts...



2. You'll need a good understanding of Programming concepts in general before you start on this book. After that however this is a good way to figure out what Generics are and what they can do for you. Highly recommended for those needing to simplify quite a few repetitive programming tasks...



3. This book sucks, the author seems to have written this book without first getting a thorough understanding of Generics himself.
   I read 3 chapters, this book was so frustrating that I stopped after 3 chapters. You are better off reading a C# reference that does a couple of chapters on Generics. You'd learn more than what this book teaches you.



4. I have 3 books on my bookshelf at work. "Writing Secure Code", An O'Reilly XSLT Reference and this one. I love it. The style is light and reads very well (unlike most technical books). It's filled with practical examples that do well at both exemplifying the topic at hand and providing a snippet for my own use. The chapters are well laid out and follow the natural order of learning/mastering generics, and they're also strong enough to stand alone for reference when needed. If you work with .NET 2.0 or 3.0, you need this book.



5. .NET generics are very valuable addition to .NET framework with 2.0 and this book provides detailed information about generics and container issues. As a long time STL user, typed containers brought a lot of value to the framework .I started to be aware of Power Collections library after this book and used in some projects. I would suggest this book to anyone without hesitation.

5 comments about Access 2002 VBA Handbook.

1. I upgraded from Access 2000 to Access 2002 and wanted a 2002 reference so based on reviews from other sites I bought this book. I have turned to it time and time again only to be disappointed time and time again. I haven't learned really anything from this book and judge the $60 I spent for it a total waste of money. A MUCH better book is the Access 2002 Developer's Hanbook by Paul Litwin etc.



2. You have done the graphical interfaces of Access to the limit and You need more theoretical knowledge to climb a step further, so your projects can advance for their accomplishments.This book will give You high quality information, meaning knowledge that is in harmony with other sciences, for instance mathematics.You will not find usefull new examples of code, once the book is based on the Access Samples (Northwind), thanks God! You wont find the icecream shop, or the whisky bottlement, or the video rent,etc.These originalities are meaningless to the understanding of the structure of VBA. You will not find that a number divided by zero is zero, or that x = x + 1, without further explanations, and that programming has a special type of logic that blows up whatever You thought credible. So I would advise to buy the book because it is an excellent work, linking the many areas of knowledge in a deep way, although the subjects are managed with as few words as possible, enough to You understand how VBA is conceived.



3. I am in chapter 3 and have decided to set the book aside and look for a more hands on approach. It's my learning style. I learn a lot more from a technical book (on a new topic) where you work through more examples. Once I have gone through a book with more examples I suspect that the theoretical approach will be more meaningful. I will come back to read this book at a later time.



4. I started using Access a few years ago as an adjunct of Microsoft Office, creating simple databases for my Christmas card list and such. Then about a year ago, because of work, I had the opportunity to dig deeper. Where to start? I began with Alison Balter's Mastering Access 2002 Desktop Development, a frustrating and disorganised tome that seemed to be missing all of the secret handshakes, signals and knowledge I longed for to unlock the supposed power of Microsoft Access. Every time it appeared Ms. Balter was going to get to the actual point and impart the wisdom I was seeking...she swiftly moved on to another topic. The book didn't even serve to help me clarify the mind-boggling vocabulary necessary to describe and understand the application. To me, Ms. Balter seemed like somebody whom, if they possessed a lot of knowledge, wasn't giving any of it away. A job change took care of my deadline but I was still intrigued and inherited a larger project when I committed myself to writing a custom database application for my partner's administrative needs. I needed help and serious instruction to achieve the application designs I had in my head.
   
   I turned to Getz, Litwin & Baron's Access Cookbook (1st edition), thinking I could hi-jack some off the shelf solutions and, if not actually learn to write Access VBA, at least tweak the code they supplied to suit my starry-eyed custom application needs. Not a bad idea. Problem was, as intriguing as the book is, it's really for experienced developers looking to take their skills in another direction (skyward). Very strong on methodology too, which is important, but it wasn't exactly getting me off the launch pad (it wasn't even getting me off my mouse pad, to be more accurate).
   
   Seven months on, two books later and still no real understanding of Access VBA. I checked out Getz, Litwin & Gunderloy's Access 2002 Developer's Handbook Set and was ready to dig deep...but one really needs to know the basics and fundamentals of Access VBA to keep up (otherwise it's like reading a foreign language of which you have very little knowledge). One hundred pages in and I sensed that I had skipped a grade and it wasn't going to get any easier. Even Ken Getz & Co. were repeatedly pointing me toward Novalis & Jones' Access 2002 VBA Handbook (useful for 2003 as well) and I can honestly say, after a few months procrastinating and about 2.5 - 3 weeks of focused study, without any previous programming knowledge or experience, I can now read an Access VBA procedure and understand what is actually going on. It's like I'm speaking their language!
   
   Novalis and Jones are thorough and precise to a fault. Despite the repetitive vocabulary of Access application development, they do a stunning job of continually moving the reader along, down what is, it has to be said, a very tricky and treacherous path. ("Each AccessObject object has an AccessObjectProperties collection object, sometimes just referred to as Properties, a collection object that stores custom properties for the object. Each AccessObjectProperty in the AccessObjectProperties collection object itself has two properties: Name and Value." Don't worry, by the time you get to Chapter 13, from whence that comes, it'll just make you chuckle instead of sweat.) If you've ever tried to learn Access VBA and have been left scratching your head wondering what some author's glib explanation is supposed to actually mean, you won't be disappointed in this book. Novalis and Jones will not leave you behind.
   
   The experience of reading the book is like one of taking a university course called Access VBA 101. You have to concentrate and focus while you do your reading. There are procedures aplenty throughout the book with step-by-step demonstrations and explanations about how to write Access VBA. The book is very well structured with regular variation between activity and explanation. (You will be inclined to start writing customisations and applying your newfound knowledge to the code samples as the book continues.) All of the samples are immediately applicable to the kind of useful procedures you'll want to include in your custom database application--in very simple form. This book is about foundations, however, it is an end in itself because you could finish it and start writing your own procedures. I have 12 different sections specifically earmarked for functionality that I want to include in my application, which is pretty useful. Their section on Creating and Modifying Database Objects (Chapter 14) has given me plenty of ideas about coding tools I want to write to flesh out the VBA IDE and write my code faster. Did I mention that 3 weeks ago I couldn't even read Access VBA?
   
   If at times the book feels like it's hard going, it probably has more to do with the subject itself (maybe I should've taken a few more breaks). You will hit a few walls but everything is surmountable; I made it all the way through the book (save the DAO Appendix) and all of their code worked for me (be careful in Chapter 13 "Working with Groups of Records...", however, because a couple of their early procedures in the chapter will break some of the later ones). Not a quick start and at least a month or so of Sundays but for those looking to lay a solid foundation in Access VBA, this is a wise investment of time and money. I now feel that I know the depth and power of Access using VBA programming and when you're trying to learn and utilise something this complex, that's half the battle.



5. This book has been all that I hoped it would be. I use it as a tutorial one day and a reference the next. I was a beginner Access VBA developer and now with this book I have become much more comfortable around VBA. So much more comfortable that I have developed 4 financial Access applications that are going to be used by multiple departments. I recently picked up the Access 2002 Developer's Handbook Set which is a little more advanced but I keep coming back to this one.

5 comments about PHP 5 for Dummies.

1. Yes, the author reads the reviews here. That's me. The error in which a few quotes were replaced with underscores occurred during the publishing process, after I was finished with the book. I didn't know about the errors until I saw the earlier review here. However, there is no way to fix it. If the book is reprinted or a second edition is released, I can fix the errors, but not until then. I wish I could. I apologize to any who were confused by this problem.
   
   There are 8 quotes replaced with underscores on 4 lines in Chapter 3, 2 quotes replaced with underscores on 1 line in Chapter 4, and 20 quotes replaced with underscores on 8 lines in Chapter 5. I have a list of the errors and corrections on my web site at janet.valade.com/php5errors.html.



2. I only give this two stars because there are a few snippets of code that are worth absorbing. However this book has enough errors to make the subject matter confusing. I've used quite a few "Dummies" books as intros to a variety of subjects in my 20 years of programming. They have for the most part been quite helpful.
   
   I always expect some errors from books dealing with technical material, but the errors here are of a nature so as to cause confusion, especially to those new to PHP.
   
   My bottom line recommendation is not to use this book if you are new to programming or to PHP. You'll spend more time than warranted separating the wheat from the chaff. There are much better intros to be had. Try Sam's "PHP, MySQL and Apache" or Sitepoint's "Object Oriented PHP Solutions". Both are accurate, easy to understand, and have code samples that are easy to get to.



3. I have to repeat what others have said. This being a programming book, it is inexcusable to have _ when the programming language wants a "
   
   Terrible experience trying to learn a programming language when several symbols are just plain wrong in the text. What's the point? I'm paying money to waste my time figuring out typos in a programming language I do not know.
   
   So why did I give my money? Never again. The publisher should be recalling this book but they haven't done so.
   
   Other then this tremendously horrid mistake which is throughout the book there is some good information. There is also a lot of senseless rambling. The author goes on and on about PHP numerical functions. All she had to say was you can perform calculations and a few examples. Her rambling text is painfully dry. Maybe she should have spent more time proofreading rather then the obvious page filling.
   
   I'm angry that I had to translate code I'm trying to learn. Maybe the author and publisher should be paying me to teach them. Refund please.



4. I would've given this a 4. But, because of the amount of typos, give it a 3 instead. Good for beginners.
   
   Overall, very basic for beginners and explained in somewhat laymen term. Some may say that PHP is designed for non programmers, but for those who never used any programming languages before, trying to grasp the meaning of an array, multi dimensional array, different types of loops, functions, objects(their properties and methods), regular expression, blah blah blah, can be a brain twister still. However, if you have an editor/debugger (I use the Komodo IDE), it'll make learning MUCH easier. Don't let the brain twister part discourage you though, it's just a fact. But, once you start reading and writing codes, especially with the help of an editor/debugger, so that you can step in and watch line by line, to see what each line of statement and the variables are doing, things will fall into place. I used to program in VB, so I mainly read this book to learn the basics of how PHP syntax & structure work, the rest would be a lot easier(should've done this YEARS ago).
   
   An author should not be rating their own book a 5 star, especially with the amount of typos and definitely should not be justifying those typos. Before printing, those simple code snippets should've be tested, where they could have easily been caught and corrected.



5. This book is a very well prepared for its purpose and target readers... This is for the beginners and guides you through to intermadiete level in PHP. If you have some background in PHP, then I would suggest other works for intermediate and advanced coders.
   
   There are some printing errors that corrected by the author at her web site.. www.janet.valade.com/php5errors.html Please do not forget to go there to print the table out, so you can keep with the book.

4 comments about Software Configuration Management Strategies and IBM(R) Rational(R) ClearCase(R): A Practical Introduction (2nd Edition) (Visual Quickstart Guides).

1. As a long-time ClearCase user, consultant, Rational field rep, and all-around proponent of SCM, I found this book to be a wonderful update of Brian White's first edition. Tom and Dave have an extremely readable style of writing that you don't often find in technical publications. For the uninitiated, this book will serve as a great introduction to SCM concepts, ClearCase and the Unified Change Management process. For the experienced SCM administrator, this book is full of tips and practical "how-to" based on Tom and Dave's decades of experience in the SCM field.



2. Was the first edition mostly a repeat of the UCM manual that comes with the installation, this second edition brings more valuable, strategic information about SCM and ClearCase UCM. It is a must-read for SCM practitioners working with UCM or considering a step towards UCM. In fact, the SCM strategies covered in this book are a must-read for any SCM practitioner. Issues like quality promotion, parallel development and composite configurations are becoming quite common to modern software development organizations.
   Subjects that I am missing are activity management (as part of project management), reporting and audit trails, customizations (e.g. role based permissions, automation, triggers) and integration with other development tools (e.g. requirements and test assets).
   
   It is very difficult to find just the right book about SCM, with the right balance between theory and practice. Well, this book is it for Unified Change Management.



3. I purchased this book as a new Configuration Manager to the Rational suite of tools. I have used other 'big' CM tools in the past, but was unfamiliar with ClearCase. The book is very well laid out, has very good information and definitions that I have used in other presentations as I prepare to roll out a ClearCase solution to my team. After reading the first 1/2 of the book, I felt very versed on the tool, and was able to refer to my knowledge in conversations with other team members about how ClearCase is to work. I recommend that if you are new or even experienced with ClearCase, that you purchase this book for yourself. You will find in no time that you will mark many pages with yellow sticky's and highlight passages that you'll refer to many times!



4. I've a long history with CC, and SWCM. This is a good book for simpler projects, and it has some good tips I had learned, but hadn't seen in print. I wish it worked a bit more on the successful patterns that scale to really big projects, but that's not where the market is for books, right?

4 comments about The Financially Confident Woman: The Least Every Woman Needs to Know to Manage Her Finances and Prepare for the Future.

1. Mary really gave me hope! I thought this was just for women but discovered what she had to say applied to both me AND my wife. This book is a real answer to prayer and has given us a great leap forward down the road to getting out of debt...once and for all! Waytago, Mary! Hope you sell a million copies! -RPR, Franklin, TN



2. I found this book to be extremely helpful and informative. Mary Hunt offers practical advice in a manner that makes you feel like you're listening to advice from a good friend or relative who has been through it all. She also made me feel like I wasn't a freak for having bad financial habits but that I needed to learn how to break them. For those of you out there who are compulsive spenders (like myself), this book is a great way to start getting on the right financial track.



3. I'm a HUGE Mary Hunt fan... her cheapskate lifestyle and debt-proof way of life has completely turned my finances around for the best! I've read nearly all of her books and love them so much I am quick to buy many copies and give them to others... EXCEPT THIS ONE. As a feminist, I found this book enormously patronizing. I felt that when she generalized women's spending habits, she made grossly inaccurate assumptions like I don't understand how a credit card works. If you don't know how a credit card works, read this book! I do not recommend this book unless you are a woman completely clueless about money. If you consider yourself financially savvy and trying to gain more tools, go with "The Complete Cheapskate." If you're married and trying to get a debt-proofed life, go with "Debt-Proof Marriage..." "The Gourmet Cheapskate" is also incredible! I also highly recommend her cheapskatemonthly.com newsletter, but the books are better if you're trying to make a personal change in your life with your finances. Good luck!



4. Written by Mary Hunt - the editor and founder of the Cheapskate Monthly - the Financially Confident Woman is a quick read with lots of sound ideas for stretching a dollar and establishing financial independence. Pertinent scriptures are quoted for inspiration and motivation.
   
   This short book is a great gift idea for women trying to take charge of their finances and clear their financial clutter. It also works out as a nice "bathroom" book - there is one tip per page, so it makes for easy browsing.
   
   The advice is perfect for helping anyone create new money-related behaviors. Again, nothing too outrageous, but nice reminders just the same.

5 comments about Beginning PHP and PostgreSQL 8: From Novice to Professional (Beginning: From Novice to Professional).

1. If you are like me, you have probably dabbled in PHP and MySQL driven CMS solutions, simply because that combination is so prevalent. I consider myself to be primarily a front-end developer / graphic designer, and am not terribly interested in knowing every server-side language there is, so long as whatever I am using can get the job done. Suffice it to say that while I am eager to learn and expand my horizons, my exposure to more than LAMP has been limited.
   
   So, when Jason Gilmore sent me a review copy of his latest book, that he co-authored with Robert Treat, I was glad to be learning about this powerful database. The title is Beginning PHP and PostgreSQL 8, and the structure of the text mirrors closely that of Jason's other best-selling book on PHP and MySQL 5, now in its second edition. To get a feel of the PHP aspect of both these books, read my other previous reviews on the First Edition and the Second Edition...
   [...]
   
   This saves me having to repeat myself, covering the PHP side of things as much. Suffice it to say that it is extensive and well worth reading. Now, allow me to focus on the second aspect of this book, PostgreSQL. While MySQL bosts being the world's most popular open source database, PostgreSQL has stake to the claim of being the world's most advanced open source database. Are these two in competition? Well, yes and no. I will expound further on that, but first a brief history lesson.
   
   In 1986 at UC Berkeley, professor Michael Stonebreaker set out to build a better open source database than his previous project, called INGRES. Since the first project was a huge success, he decided to entitle the follow-up Post-GRES. So, while the first name was an acronym, Postgres is simply a derived nick-name that grew out of it. Postgres became so popular that providing tech support was becoming far too time consuming for Stonebreaker and his team. Eventually they ceased development to focus on teaching.
   
   But, since it was released under the BSD license, development was picked up by Andrew Yu and Jolly Chen, who added in SQL functionality. Eventually this hybrid grew into the PostgreSQL database we know today. Their mantra has always been stability first, speed second. Whereas MySQL is built for responsiveness, PostgreSQL is designed to be rock-solid. This mentality is reflected in the choices of database mascots: a Dolphin vs. an Elephant.
   
   You might have been hearing about PostgreSQL more lately because of the rising interest around the Django Project, which recommends PG as their database of choice. While it is of course driven by Python and not PHP, this further illustrates the scalable versatility of PostgreSQL. When reading this book, I was blown away by some of the server strain that PG can handle.
   
   Consider these examples: Afilias Incorporated, the Internet registrar company responsible for managing the .info domain name extension, handles over 1000 database inserts per second! The NOAA weather service Weather.gov has scaled their operations across 150 PG servers. Whitepages.com runs PG databases exceeding 375 gigabytes with over 250 million rows. Big newspaper sites also run PG, such as Lawrence.com, KUSports.com and LJWorld.com.
   
   Mega-churches such as FellowshipChurch.com also make use of PostgreSQL. When you have 20,000 people that go to your church, each one needing to check up on what's happening on a dynamically driven PHP website, that can be quite a server strain. To handle this, you either need an expensive proprietary platform, or a scalable open source solution. Fellowship opted to roll their own CMS and power it with PG.
   
   Okay, so now you get the point that PostgreSQL is a force to be reckoned with. Allow me to touch briefly on the code aspects of what I thought was cool in this book. Robert has done a great job of flowing with Jason's proven writing-style. Many times, multi-author books differing topics can seem disjointed, but that is not the case here. He explains things very thoroughly without mincing words.
   
   One of the cool features of PG is Multi Version Concurrency Control or MVCC for short. This allows "snapshots" of your database to be taken at set intervals, so that you can serve up cached data without repeatedly hitting the database, risking a hardware lock-up. This is commonly referred to as the "Digg Effect" or becoming a victim of being "Slashdotted," in which high-traffic websites send a flurry of incoming visitors to a lesser server which cannot handle the load.
   
   PostgreSQL also supports MySQL style row-level locking, but the MVCC method is preferred because of its stability. Another nice feature is the ability to store commonly used queries, and even create abbreviations for frequently called procedures. You could think of it like referring to a best friend by a nick-name. This set of features has been native to PG for some time now, and is something that MySQL has recently implemented as of version 5.
   
   The way I think of the differences between MySQL and PostgreSQL is that PG is a more transactional database. Meaning, if you want large enterprise level sites that handle many insertions and modifications throughout any given day, PostgreSQL is probably the way to go. MySQL can do this with with the InnoDB table type, but PG has better native support for it. PG also sports Foreign key support, Views, Stored procedures, Triggers, Unions and Full joins.
   
   On the flip-side of that coin is that MySQL is typically a bit faster, has a more simplified database layout, and does not require vacuuming. Vacuum is a command that must be run from time to time, and typically is set as an automated process. One of the ways PG maintains consistent stability is through the previously mentioned MVCC method, which disperses duplicate data in order to avoid hitting one particular location repeatedly. Periodically, these duplicates need to be reigned in or vacuumed, to clean up disk space.
   
   In comparing PostgreSQL with MySQL side by side, there is not a clear-cut winner, because it is a bit like comparing apples and oranges. If you want a fast and responsive site, MySQL is probably the way to go. If you are managing one that has a high amount of traffic and needs to handle enterprise level or "mission critical" data, PostgreSQL should be one of the solutions you consider. I think of it this way: MySQL is a ninja, PostgreSQL is a samurai. One is quick and nimble, the other more heavily armored. If you want to learn more about the latter, then this is the book for you; Also available as an eBook, PDF file from the Apress website...
   
   [...]



2. I read this edition after Gilmore's earlier book on PHP and MySQL, so let me quote the pertinent parts of that review and augment with appropriate comments:
   
   A beginning PHP book, not a beginning programming book. The subtitle, 'From Novice to Professional', can be a tad misleading for the novice coder. A beginning programming book covers a lot of material that this book assumes the reader already understands. Many software books include a 'Who Is This Book For' section that offers some guidance on the suitable reader knowledge level, not this one.
   
   That said, I found this book to be very helpful. The sections on installing and configuring Apache, PHP and PostgreSQL certainly saved me many hours of reading the online documentation and tweaking of settings while setting up my local test bed. That, in itself, made me a very happy camper. The author goes on to cover the various aspects from the basics of the PHP language and class libraries to topics like Authentication, Security, Session Handlers and eMail functionality that help anyone new to PHP setup some fairly sophisticated site capabilities.
   
   Gilmore has included a section on PEAR (PHP Extension and Application Repository). This is a wealth of prewritten classes and packages that can be used to add even more sophisticated functionality to the novice's web development toolbox. The author demonstrates several of the more prominent packages.
   
   New for this edition, Robert Treat has contributed coverage of PostgreSQL, including chapters on tables and data types, views, functions, indexes and triggers. There is also coverage of the more pertinent PHP functionality to access PostgreSQL. Most of the examples offered are clean and general enough to be useful templates for the reader's tailoring.
   
   My suggestion for novices to PHP is read through chapter 9, then skip to the various sections that solve specific problems being faced or are of particular interest, including installing and configuring your local test bed.
   
   Bottom line, this edition was a good book for intermediate to veteran programmers looking for a quick tutorial on PHP (circa version 5.1) and specifics for the PostgreSQL community. Novice programmers should ensure that they have a full understanding of the basics of programming (and OOP) before attempting it.
   P-)



3. To me, this book was a disappointment. I had expected much more in the way of integration between PostgreSQL and PHP. Some of the questions that I had expected an answer for, was like: What is considered 'best practice' as to how to interface with PostgreSQL from PHP? How to write reusable queries?
   
   Instead, the book is divided in two disparate parts: One is about installing and configuring PHP, along with a rewrite of parts of the online PHP manual; the second part is about installing and configuring PostgreSQL, along with a rewrite of parts of the online PostgreSQL manual. None of which, I dare say, I found particularly useful.
   
   On my system, a Gentoo Linux computer, most of the installation of both PostgreSQL and PHP is covered by the simple command "emerge php postgresql". So, what do I need this book for?
   
   I found some nuggets in the PHP section about array functions that I wasn't aware of, but mostly it was all old hat. I simply don't need yet another instruction on how to install PostgreSQL and PHP on my computer. I've figured that out a long time ago.



4. What's annoying about this book is that I bought it to learn more about PHP and PostgreSQL but the authors decide to use Smarty and PearDB throughout instead. If I wanted to learn those two I would have bought books about them. Smarty and PearDB is used in every single piece of code they do which is extremely annoying. I don't want to learn Smarty or PearDB. If you're trying to learn PHP and PostgreSQL don't buy this book. If you want to learn Smarty and PearDB this book might be for you.



5. Are you a professional or novice to PHP and PostgreSQL 8? If you are, then this book is definitely for you. Authors W. Jason Gilmore and Robert H. Treat, have done an outstanding job of writing a book that offers users an impressive platform for building high-powered Web applications.
   
   Gilmore and Treat, begin by acquainting you with the basics of PHP offering insight into its roots, popularity, and users. Then, the authors show you how to install and configure PHP, as well as, the Apache Web server. Next, they cover the various aspects from the basics of the PHP language and class libraries to topics like authentication, security, session handlers and e-mail functionality. The authors also focus on PHP Extension and Application Repository (PEAR). They continue by addressing PostgreSQL, including tables and data types, views, functions, indexes and triggers. Then, the authors present the more pertinent PHP functionality to access PostgreSQL. Next, they show you how to install and configure your local test bed. The authors continue by describing the server strain that PG can handle. Then, they show you how to use Smarty and PearDB. Next, the authors also cover the integration between PostgreSQL and PHP; the interface with PostgreSQL from PHP; and how to write reusable queries. Finally, the authors go further by covering the installation and configuration of PostgreSQL.
   
   This most excellent book is not for beginners. Nevertheless, you will find plenty of tips and notes focusing shortcuts to complete both new and familiar tasks.