No comments about More Effective C#: 50 Specific Ways to Improve Your C# (Effective Software Development Series).

No comments about SharePoint 2007 and Office Development Expert Solutions (Programmer to Programmer).

3 comments about Java(TM) and JMX: Building Manageable Systems.

1. Remember when java burst onto the scene on 1996, and you could write cool applets that showed animations on a web page? Well things have progressed vastly since then, and especially after the dotcom crash, being essential is far more important than being cool. The emphasis with java has shifted from towards backend, web server-type applications, when you have to interact with legacy databases and management tools. The problem with the latter is that if you are writing a java application that is to be controlled by some management level software, this latter item could be furnished by several companies. It is expensive to customise your code for each management package; but not to do so may severely restrict your sales.

   JMX, Java Management Extensions, arose to solve this puzzle. It is still fairly new, and not many java programmers may be familiar with it. If so, this new book [2003 vintage] will help educate you. The authors point out a simple analogy that may clarify. Shortly after java was introduced, there was a need to let java programs access data in databases made by various
   vendors. The solution was an industry standard API, called JDBC. Each database vendor wrote an implementation of this API, which was hence called a JDBC driver. This let java programmers program to that interface and ignore any lower level details.

   So if you can understand that, you can understand JMX. The difference is that here your java application will be controlled by some management software, whereas with JDBC, your java program would have been the controlling entity.

   The bulk of the book goes into the details of the JMX API. [Ok, it may not be literally an application programmable interface, but conceptually you can think of it that way.] The exposition is straightforward and logical.

   A nice resource for the aspiring JMX developer.




2. Unlike "JMX in Action" from Manning, this book goes beyond the How To of JMX.
   It introduces the reader to the fundamental problems of systems management, before jumping into concrete implementations.
   It explains the history of the industry from the days when hundreds of people shared one mainframe and sys-admin was the same as god, to the present days when everyone has access to hundreds of computers.
   It also gives an overview of the numerous system management standards and explains why some of them were successful while others were not.
   Before I got to the JMX chapters I understood how the veterans in the industry with decades of experience distilled the scope of systems management to a few basic concepts that define it.
   It helped me make a better choice when thinking about which parts of an application should be manageable.
   Very strong book.
   Just be aware that it is not a very fun reading. The book uses a tight, dry and fast style. You better be serious about it before turning the front page.



3. This book is divided into three parts. The first section is a history of managing computer applications and an explanation of why JMX is needed for Java applications. The second part goes into detail about JMX and the third section is about JMX applications.

   The first section is an informative history of managing computer applications from mainframes to present day applications. I the reader can skip this section, if he or she just wants to understand JMX.

   The second section explains Means and the tools behind JMX-based management. MBeans represent a resource that a management system will monitor and control. The MBean is the resource according to the management server. The book goes into great detail in creating and using MBeans, including the MBean notification events. In this part, as throughout the book, the explanations are clear and comprehensive. The examples fully show the user how it works and are explained completely by the authors.

   This book has a serious and comprehensive style. The authors assume that the reader has a fairly extensive knowledge of Java. This book is an excellent introduction to JMX and is comprehensive in its coverage of all topics related to JMX. I would recommend this book for anyone interested in learning about JMX.

5 comments about Object Oriented Perl: A Comprehensive Guide to Concepts and Programming Techniques.

1. I almost passed this book by, thinking it was a primer into the OO world with Perl. I'm comfortable (if slightly annoyed) writing OO Perl code. What surprised about Conways text was that the book used OO as a premise to instruct the reader on more advanced aspects of Perl; its more an Advanced Perl book than the expected Object Oriented book.
   
   I learned more depth of Perl than I have in years. Perl is a thick and crafty language. Chapter 2, subtitled "A Perl Refresher", was worth the price of admission alone, as he deftly re-hashed Perl features he would use later in the book. The practices and features of Perl he later expanded on in the OO chapters incontinued to impress me.
   
   If you are a Perl programmer, beginner to advanced, this is a must-read book, and a great source of coding inpiration. It made me a better programmer, in Perl and other languages.
   
   This book is was published in 2000, and usually the half-life of most computer texts don't hold up 5 years, but this book certainly does! Also, I just noticed Conway just published "Perl Best Practices" which I am eager to tackle.



2. This is my favorite Perl book, alongside Advanced Perl Programming.
   
   When I first read it, I was very upset that 3 pages in particular had not simply been inserted into the original Camel book, which I think is one of the most important yet most poorly written programming books ever.
   
   I wish Damien Conway had written Camel and Llama.



3. I have written a number of modules for Perl over the last 5 years, and I really wish I had bought this book earlier.
   
   It is a mixture of sound coding practices and great examples. I actually bought this after reading Perl Best Practices by the same author, and have not been disappointed.
   
   This is a book written by someone how obviously knows Perl from the inside, and can apply this to real world issues.



4. I am a newbie to perl and I'm writing an application that involves using object-oriented perl. I have not seen any other book that explains difficult concepts with amazing clarity that even a newbie like me can understand. I wish other perl books were written as simple and clear like this one :(



5. This is a fine book, but the passage of time has rendered some parts of it less relevant.
   
   As an introduction to object oriented programming, and how to do it in Perl, this is one of the best sources you could learn from. Neither The Alpaca nor The Camel do such a good job.
   
   And it's not just objects that are well covered. You'll also find lucid explanations of closures, type globs, the symbol table and tied variables, all of which can be considered advanced Perl.
   
   Elsewhere, though, the material has not aged so well, superseded by the author's own Perl Best Practices, where some of the recommendations have been reversed, or improved upon ('inside out' classes, for example, as implemented in Class::Std, is a superior development of the flyweight approach mentioned in this book). Some of the material, which concentrates on CPAN modules, and the experimental pseudohashes is not so useful in the light of this - the latter are on course to be removed in Perl 5.10. The sections on building objects using references to things other than hashes (e.g. arrays, regular expressions and subroutines) is clever, but this reader was unconvinced of their utility.
   
   There's also coverage of generics, although in Perl this is not much like generics in C# or Java, basically passing around Perl code as uninterpolated text strings and then evaling it inside a subroutine, where any lexical values are interpolated.
   
   Finally, there are chapters on multimethods (no more elegant or manageable in Perl than other languages that support this feature, alas) and persistence.
   
   The principles discussed remain relevant, and the book is a pleasure to read. However, if you already familiar with OOP and just want to get going as fast as possible, the relevant chapters of Intermediate Perl and Perl Best Practices might be better places to look.

5 comments about Handbook of Usability Testing: How to Plan, Design, and Conduct Effective Tests.

1. Mr. Rubin provides some of the principles of User Centered Design and explains how to perform a usability test session to ferret out some of the usability problems. A wonderful guide for someone who will be performing usability tests and would like to be able to refer to some guidelines, report formats, and technique suggestions.



2. The author provides a supermarket of information from which you can choose your approach and method for performing usability testing. I had a little usability-testing experience when I bought this book. It quickly gave me some ways to streamline my process, plus some ways to shore up my process where it was weak. The most important thing this book gave me, however, was an understanding of when to use "quick and dirty" usability testing and when to perform a more thorough study.



3. This book is a very handy reference guide for anyone who is just getting into the field of usability, and will need to conduct their own studies. It has many nifty tips for test planning and lots of information those just starting up in the field.



4. I'm a professional usability analyst, and I got some really useful tips when I opened up my copy of this book recently. More than ever its clear to me that Rubin is an experienced practitioner, with a sensible eye for what works.



5. I bought this for a class. While it's not very exciting, I suppose it's canononical for the subject area.

5 comments about Beginning Programming (Wrox Beginning Guides).

1. This book is likely to frustrate true beginners. In attempting to work through the excercises, the C++ complier the authors recommend refused to compile the sample code. Two frustrating hours later pursuing solutions on the Borland web site, I managed to create two configuration files, edit my environmental variables, and finally get the code to compile. Such geek gymnastics are certainly beyond most "beginners," and are likely to cause them to give up the whole idea of learning to code.
   
   Shame on Borland for providing a compiler that was apparently never beta tested on XP(!), and shame on Wrox for failing to provide adequate instructions. There are a few answers of varying quality and coherance on their forum, but you shouldn't have to resort to the forum to run the very first compiled program in the book.
   
   If you aren't familiar with how a compiler works BEFORE reading this book, you are likely to run aground sometime around Chapter 7. Save your money.



2. I am about half-way through the book and I am frustrated with its incomplete references, errors, and ambiguities.
   
   One of the problems I have encountered was getting the recommended C+ compiler to work. That problem is discussed both here and on the WROX website. The book fails to give a simple explanation of how to configure the computer to make it run. Thankfully, I had enough independent knowledge to prepare the required configuration files and to restate the path, but that may not be so trivial for a complete tyro.
   
   There are ambiguities that arise from unqualified uses of "it" and "this." For example, on pages 141-42, there is a suggestion that a very basic block of code be prepared in an editor and saved. The discussion then shifts to compiling the code, but the example provided confusingly shifts to a different file (test.cpp) and then shifts back to the file that started the discussion (template.cpp). The references are imprecise.
   
   There are careless comments such as the one appearing on page 153: "To make the others run, you put all of them in the code." That statement would be clearer if the word "code" was replaced by "in the code for the main function."
   
   There are troubling typographical errors such as the block highlighting on page 164 which should be limited to the first four "cout" and "cin" lines and should exclude the last "cout" line.
   
   Other matters that bug are mismatches between code and the output illustrations. Precise copying of the code on pages 176-177 does not produce the output in the accompanying illustration. The same comment can be made for the material on page 180.
   
   My impression is that this book was not carefully proofed, and precision is essential in any book that purports to be a fundamental, introductory text.



3. I think this would make a good text for a beginning programming class. The authors touch on various programming languages, though I would prefer to see sample code in all languages (or at least have it available online) so an instructor could choose which to use.



4. 'Beginning Programming' is an entry level introduction to programming, about as dumbed down as it can possibly get - and that is what is so great about it.
   
   There are not many books targeting readers with absolutely no previous knowledge of programming, wanting to learn the very basics before moving on to an introduction course or book using one specific programming language. 'Beginning Programming' fills the gap nicely.
   
   The book starts off with outlining the history of programming, explains what benefits programming skills will give you, discusses some common myths in a real honest way, and thoroughly details learning paths. Exercises are plentiful, the tools and language code samples shown (Java, C++, VB, JavaScript) are highly relevant.
   
   In the following section authors Katie and Adrian Kingsley-Hughes move on to meticulously teaching the fundamentals of computers and machine language, coding, number systems, interfaces and tools required for a programmer. The paragraphs on the importance of picking a good chair and keyboard (!) illustrate just how deeply their book delves into detail.
   
   Describing problem solving, compiling and debugging, file and registry interaction is done, before wrapping the book up with a great section on programming from problem identification to the distributed product. The brief appendixes provide a glossary and information on further resources, and how to obtain every needed kind of tool.
   
   What I most appreciated while reading 'Beginning Programming', was that the authors took time to introduce the fundamentals before moving on to actual coding (which was very simple). Coding is not introduced until half way into the book. It is sad colleges and universities do not allow students to acquire a thorough grasp of the basics, but dive straight into learning the first programming language. Students would benefit from starting off with a book like this.
   
   On the down side, 'Beginning Programming' does not mention the important subject of object oriented programming at all, and the description of graphic user interfaces is just too short, not even showing code samples. I missed a demonstration of tools like NetBeans or MS Visual Studio Express Edition (both are free). Also, the publishers have not bothered to proof read the book properly. Language is sub standard, and the errata is a wee bit long.



5. So you're interested in programming? Then this book is a good start to get an idea what programming is all about. I finished the book in 3 days!

5 comments about Integrating Agile Development in the Real World (Programming Series) (Programming Series).

1. This book gives a project manager the "knowledge" needed to effectively manage a software product. The methods/processes defined by the author really work. I have first-hand experience that the project management techniques work and can bring a project to success, and on time.



2. Integrating Agile Development in the Real World is basically a manual on implementing Agile development in a real-world environment. The book is well written and clear. However, this book is not for the casual reader or developer.
   
   The "Who should read this book" section in the front says it best; it indicates that this book was written for someone who already has a strong understanding of Agile development (you can check the section out for specifics) and is wanting to attempt to implement it in their own development.
   
   Since Agile development is fairly flexible and can be applied to variety of disciplines, it also assumes you are familiar with one (for example, XP) and will be reading it with this in mind. If you aren't very familiar with these, this book is definitely not for you. If you are, then you could learn a lot from it.
   
   If you have some familiarity with one or more disciplines, however, this book could be used as a guide to adding Agile development to a development department's "toolbox". It is written from a wide-scale, departmental point of view and not intended for the solitary developer.
   
   I found some of the text to be a little too high-level and abstract to visualize. I normally feel very comfortable with the theoretical, but this book seemed almost a little too general. Again, this might be exactly what some others would want. A counter-argument could be made that should the book become too granular, it might become more of a "how to" book rather than a "why to" book. While it won't provide you the answer to your questions, it will provide the reader with the tools necessary to figure out for sure what questions your organization should ask.
   
   I also really liked how the book was divided. It provides very distinct sections, acknowledging that not all development tasks are the same. For example, there is a separate section for testing software (a subject near and....dear to my heart as a QA Engineer). This focus on testing is very much in tune with XP and test-driven development.
   
   So, overall, this is a good book. It's just not for the average programmer.



3. Peter's book is a great tool for helping you solidify your Agile practices. As a consultant, I've found it extremely beneficial for tweaking our Agile methodology. My clients that use it have appreciated the very practical and straightforward advice as well. Appropriate for BOTH managers and developers... ;)



4. This book provides excellent material for a transition from a traditional approach to an agile method. The book gives only a brief description of the agile methods (XP, Scrum, FDD, etc.), but you will find a detailed presentation of the best practices common to agile approaches. For each of them, the author exposes the purposes, the prerequisites, the implementation, the opportunities and obstacles.
   
   The books provides an agile treatment of many of the daily problems of software development projects like database management, data conversion, test data management, project communication, documentation, end-user contacts or developers management. The most interesting point for me in this book is that the author recognises that you cannot always start with a white page and require an "all-agile" process. It provides information on how to integrate gradually agile practices in a traditional software development context.



5. If you want to learn about how to take your theoretical understanding of agile development and implement it in the real word, this is a good book for you. Very well written. Very well organized to give concrete ideas in a logical manner for successful implementation.
   
   This book does not spend too much time on teaching basic tenets of different agile methodologies other than providing a brief overview of different agile methodologies at the beginning. That's good enough considering the objective of the book which is to give real-life "how to" implement agile development practices in the real world.
   
   The author does a good job of grouping agile practices as they apply to different sub-disciplines such as development, testing, documentation, project management, people management, communication management etc. This provides a nice way to pick and choose practices to attack some low hanging fruits first and then go for difficult ones later after getting a few successes under your belt.
   
   People management which is treated with very little detail in many books finds a good measure of treatment in this book. That is certainly refreshing. One thing I would not forget from this book is something goes like this - "Skills can be learnt by anyone with varying degrees of speed and effectiveness. Nevertheless, they can be learnt by anyone given sufficient time and training. Experience naturally comes with time. But, character is one thing that is ingrained in a person. So, while hiring people do not focus only on skills and experience but pay close attention to the character." Of course, teaching how to hire right people is not one of the objectives of the book. But, the fact that the author recognizes the very important but hard to quantify character as one of the most important attributes while selecting team shows his maturity and hard earned battle proven expertise in the real world.
   
   Best practices get very limited treatment in the areas of requirements engineering, documentation, integrating other important cross functional disciplines such as user training, outbound product management, tech support. However, while delivering a large software product, these functions play very important role and practicing agile may have serious impact on their work as well. Offshore development and large distributed development also gets very minimal treatment.
   
   All in all a great book on the basics of how to do agile in real world.

5 comments about Java in a Nutshell, Fourth Edition.

1. I keep this book by my side and reference it at least twice a week. An integral part of my Java programmer's desktop library.



2. This isn't a textbook. It's a handbook, and gives good, clear descriptions of every corner of the Java language. Java isn't a big feature-sodden language, but has a few obscure corners. If you just can't remember the syntax for up-reference from an inner class, you'll find it fast and explained well.
   
   The API guide is fairly complete, but terse. Well, it has to be - the API keep growing. No one book could hold a complete description of everything. Sad to say, earlier editions had more complete API descriptions. The second, for example, had a very good introduction to reflection. As the Java API grew, however, the old descriptions had to shrink to make way for the new, and the reflection discussion was squeezed out. Still, it gives a good quick look at the API. This isn't as complete as the Javadoc API information, but is hugely more browseable. Use this to direct your query into the right area, then use Sun's Javadoc to get the details.
   
   If you have room for only one Java book, make it this one.
   
   -- wiredweird
   
   2007 PS to the 2004 review: Flanagan's new edition on Java 5 supercedes this version of the classic. The new version has all the strengths of earlier editions. It covers language basics and Java 5 extensions even better, except for some rough spots in generics. It covers the fast-growing standard library even worse. If coding Java pays your paycheck, then upgrade. If you work on legacy or casual code, the 3rd or 4th edition, plus easy access to javadoc, might still serve you well enough.



3. This book is way too terse to be useful. Modern Java development tools will help you use the correct class method signatures anyway. Buy the posters instead and give yourself a visual overview instead.



4. Java: In a Nutshell (4th ed.) is a decent reference manual for quick lookups. Be forewarned: it's very terse. This helps and hurts it; the Java language is pretty hefty itself, so concise reference is valuable, however sometimes I've found it to be a little bit on the lacking side when I really needed fast and easily understandable reference.
   
   Not a must-have, but definitely not a waste.



5. For those that find that Javadoc hard to read (like me) or aren't "always on" the internet, this is a great alternative. The first few chapters are particularly - short, sweet and to the point - a cross between Javadoc and a cookbook and is quite readable.

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.

5 comments about The qmail Handbook.

1. I just finished setting up a mail server at home and this book really made it simple. I'm not a novice, so I can't speak to it's ease of use, but the steps were simple, and a bit verbose and repetitive, but overall the book was invaluable.

   I also needed DNS and BIND to get everything working just the way I wanted, so I'd buy them both.

   Tim




2. Everything you need to know about Qmail from installation and complete configuration. There is no other book.



3. After a month, and hours of installing and reinstalling FreeBSD and Qmail, I finally got the mail server working right! This was my first attempt at a mail server which I use for my family members and a few friends. There are a few errors in the book in some of the scripts which did cause me many problems. That was a pain. But, even at that, I don't think I would have been able to get Qmail running without this book. It is a great book for a person like me who is always doing something a bit over my head.



4. Dave Sill did an excellent job of showing how to setup email server. If you know some Linux commands, you'll have no problem setup your first Linux email server. I personally prefer Dave's Qmail handbook to John Levine's Qmail (I got as well). Levine's Qmail is an great second book.

   Best Linux book I ever bought!




5. My first edition copy of this book is dog-eared and full of bookmarks. This is an excellent tutorial on installing and using qmail. It includes step-by-step instructions for each task involved in setting up and administering (as well as customizing) qmail. Great text. Highly recommended. You don't need to be a Linux expert to install qmail if you follow this guidebook.