Open Source Books

I searched for something like that so long. The tool is definetely already state of the art to enable Developers producing professionell applications under the J2ME Plattform. This book supplement the already existing and good documentation and explains everything from higher perspective.

Very Well done !

I'm a serious J2ME developer. I bought this book because it claimed to solve the 600 phone problem. It also promised to do some fancy GUI which are otherwise completely lacking in J2ME.

However, right out of the box the first demo, the menu sample, fails utterly. Ant crashed because I didn't put an Ant jar file in the any classpath then the menu sample didn't work. I had to search some forum to find there is a bug in the latest RC4 download. Apparently no one at Enough caught or fixed it. To fix it I had to patch a css file deep inside the project. If that wasn't enough the actual menu demo looked horrible on WTK 2.5. Couldn't see the menu highlights and it scrolled incorrectly.

Then I tried the roadrunner game. But the game didn't fit on the screen properly--isn't this the 600 phone issue? Ultimately, when I tried to exit, the game (or emulator) crashed. I looked at the jar file size and it was a whopping 462 KB on just 1,433 lines of source! Unreal.

I tried the tabbing demo which looked decent and worked well enough but it was 430 KB on just 200 lines of source. This is awful.

J2ME Polish depends on Ant and preprocessing of #ifdefs which were recognized a bad idea when C introduced them 30 years ago. C++ introduced const (and Java, final) partly for this reason. Actually, in J2ME Polish (and NetBeans) they're not #ifdefs but //#ifdefs because Java never bothered, and rightly, with this silliness--and here they are back again. They make the code less readable and they're virtually impossible to debug.

Then there's this matter of integration of the IDE (I use Eclipse) and Ant. I mean, why bother with an IDE if you must still use Ant? Throw in some .css files, too, for good measure. I just don't get it.

Indeed, I'm returning the book for a refund. I had enough from Enough.

When you first learn J2ME, you learn about this fantasy world where all devices follow the J2ME specification to a tee. But in the real world, because of the interpretive nature of the specifications, no two devices really implement the specification exactly the same. So this requires either targeting a particular device or have many versions of you app to run on different devices.

Man what a pain. But that is where J2ME Polish comes to the rescue. J2ME Polish provides pre-compiler directives to allow you to write code such that J2ME Polish's build script can automatically create different versions for you on the fly however you want. There is a lot more to J2ME Polish than just that, but this is a book review.

So let's get to that review. Well, first Robert Virkus is J2ME Polish, well he is the architect and lead programmer for J2ME Polish. Who better to write a book about it? Consider this book the hard copy of the manual for J2ME Polish. If you are going to use J2ME Polish, then this book is a must. It is the reference book that you will need to find anything you need to know about J2ME Polish.

Now, it isn't really a read all the way through the book and you can be J2ME Polish expert. You really need to be actually using J2ME Polish at the time, to better grasp what is being explained. The book can be hard to understand, not because of the writing, but because J2ME Polish is feature rich and there is lots to learn.

I highly recommend using J2ME Polish and buying this book if you will be developing for more than one device, and also to get their cool looking GUI screens, rather than MIDP 2.0 High Level GUIs.

If you don't know (in which case you wouldn't be reading this in all likelihood), LAMP is an acronym for Linux, Apache, MySQL, and PHP5. It's the open source "software stack" used to do web development. If you have a basic grounding in all those software elements, you might be interested in the Wrox book Professional LAMP - Linux, Apache, MySQL, and PHP5 Web Development by Jason Gerner, Elizabeth Naramore, Morgan L. Owens, Matt Warden.

Contents: What's New in PHP5?; PHP5 OOP; More Obscure PHP; Advanced MySQL; PHP Configuration; Apache Tricks; Site Security; PEAR and PECL; Code Efficiency; PHP Extensions; AJAX; Caching Engines; Content Management Systems; Language Translation; Alternative Tools; Index

As you can see from the content listing, this is a bit of a grab-bag of topics that may or may not interest you. There does seem to be some contradictory information as to who the target audience might be. Looking at the back of the book, the book is described as being for "intermediate to advanced LAMP professionals". This is backed by their visual flowchart of titles, which shows this as a high-end book for those who already know what they're doing. But in the introduction, there is a description of the book as one "for web developers with some experience who want to take their websites to the next level." This is followed by a list of basic skills that they assume, none of which are the software elements that make up LAMP. While I consider myself the target of the second description, I can tell you that this isn't a book that I could use to learn and understand LAMP. You definitely need to have a firm grasp of PHP in order to gain value from this material, as they go into new and advanced features very quickly.

Having stated the caveats, I will say the book is laid out well and would be beneficial to the right audience. There is a lot of code to use and play with, and the information is well documented. The focus is on PHP5 material, so I think that you'd find the book most valuable if you were a PHP developer looking for tricks and tips using the latest version of the software. The Linux part of LAMP is not covered much at all. It's assumed that you're using Linux to run the "AMP" part of the stack, but that's about as far as it goes. If you're looking for Linux info, you won't get much out of this book.

Recommendation? If you're firmly grounded in LAMP and you're looking for information that goes beyond the basics, you might be interested. If you're just looking to get started, you'll want to look elsewhere...

I just finished reading Professional LAMP. These four components make for quite a powerful open source solution. It is being used at the enterprise level, with companies such as Yahoo and Google taking advantage of the flexibility if can offer. This book is ideal for anyone wanting to delve further into this development environment. As far as I know, it is the first book to cover LAMP at the professional level. The full listing of chapter topics covered are as follows:

1. What's New in PHP5
2. PHP5 Object Oriented Programming
3. More Obscure PHP
4. Advanced MySQL
5. PHP Configuration
6. Apache Tricks
7. Site Security
8. PEAR and PECL
9. Code Efficiency
10. PHP Extensions
11. AJAX
12. Caching Engines
13. Content Management Systems

As you can maybe tell, the above topics are a bit light on the "L" aspect of LAMP. Linux is covered briefly, addressed as the platform on which the AMP aspect runs. To be honest, I did not expect that this book would be a comprehensive look at Linux, because there is already a plethora of books out there. This book addresses in detail many aspects of Apache, MySQL and PHP.

- What's New in PHP5

This chapter covers the changes between PHP versions 4 and 5. This includes object-oriented programming, new functions, configuration changes, mysqli, XML support, Tidy library extension, and SQLite. Suffice it to say, there is quite a bit of information to absorb from this comprehensive first chapter.

- PHP5 OOP

This chapter opened with a good discussion on procedural versus object oriented programming. It then moved on to cover class definitions, methods and instances. One of the things I thought was cool is abstract, which allows you to create a class that can be extended by others. Using OOP methods also allows you to build an extensible API so that developers can create their own plugins. One such example would be peppers that people make for Mint.

- More Obscure PHP

This chapter was great, and helped to clear up some confusion for me. It covered some of the history behind Perl and C that led to PHP coming into its own. Like many languages, PHP has been around long enough that there is some "legacy" code still packaged in it. These relics remain only for backwards compatibility with older applications. Much like target="_blank" and iframe are deprecated as of XHTML 1.0 Strict, there are some things in PHP that are no longer supposed to be used, though they are still supported.

Anyway, the point is that PHP has breadth and depth that many programmers never even touch. They describe it like the English language, that though we understand quite a bit of terminology, most of us only use a small portion of it in our own daily vocabulary. Examples of things covered in this chapter are: callbacks, array_map(), array_walk(), array_filter(), preg_replace_callback(), call_user_func_array(), create_function(), glob() and creating streams.

They even discuss the code necessary to create an aerial orthophoto database query, such as would be seen in Google Maps' satellite view. They cover various compression methods for PNG files that make up the series of photos. I have to admit, it is pretty heady stuff, so you'll just have to check it out for yourself.

- Advanced MySQL

In this chapter, a simulated list of cars at an auto dealership is presented. They show you how to maintain data based on manufacturer, model, paint color, etc. There are many code examples for creating new entries, modifying existing data, and joining / merging tables. Also covered is how to use a MySQL database with the InnoDB storage engine, as opposed to the default MyISAM. Some of the benefits to this include transactions, row-level locking, and foreign key constraints. The one major drawback is lack of full-text searching. They also show you how to switch back and forth between MyISAM and InnoDB on the fly, should you ever need to use both in any particular situation.

In addition, the process of granting / revoking user priviledges is covered, which is a crucial aspect to understand if you want to have different tiers of access to different sections of your data. For instance, you might want the administrator to be able to affect everything, whereas your staff worker you would only want to be able to enter new entries into a product inventory.

- PHP Configuration

Next, they cover some of the basics of tweaking PHP for optimal performance. This all revolves around the php.ini file. They give several recommendations for settings to change, such as: register_globals = off, display_errors = off, log_errors = on, magic_quotes = off, asp_tags = off, and short_open_tag = off. They gave a compelling reason why to leave off short_open_tag, because instead being "< ?php", it is shortened to "< ?". This would cause a parsing error, because XML is written "< ?xml" but would be treated as PHP because it begins with "< ?" as well. If you plan on doing any AJAX, this would create major problems. Keen insights such as this are sprinkled throughout this chapter.

- Apache Tricks

This chapter offered a slew of helpful pointers on Apache Server, including sixteen pages on mod_rewrite alone, the Apache module that allows for more readable clean URL's, instead of messy addresses. Consider the following two examples, both of which lead to the same page (this very book review):

* godbit.com/article/professional-lamp-review
* godbit.com/index.php?id=110

As you can see, while the first might be a bit more lengthy, it contains more memorable information, such as the fact this is an article, and it is a book review of Professional LAMP. This goes a long way in making things more human friendly, and helps search engines index your site more accurately.

Another topic covered is that of mod_deflate, a compression method used in conserving bandwidth. This will cause Apache to send along text such as HTML and CSS with white-space and line-breaks compressed in gzip format, which most browsers are able to interpret and then convert back into a plain text, uncompressed equivalent. The book gives the example of sending a Zip file in an email, rather than several separate attachments. There are also security tips, such as authenticating MySQL users or using SSL when uploading files.

- Site Security

This leads me into the next chapter, which is all about security. Inevitably, with the ungoverned way the Internet operates, you will have malicious people trying to mess with your website. Basically, if you want something secure, don't hook it up to the `net. That being said, there are significant precautions you can take in order to minimize the likelihood that your site will be compromised either intentionally or accidentally.

They explain how to control authentication with both Apache and then adding another layer of PHP checks, such as form validation or register_globals protection. Plus, there is a section on protecting yourself from SQL injection attacks. This nastiness works by using an input, such as comment form or discussion forum, to do things like drop tables or granting user priviledges. Suffice it to say, that can cripple a database driven site, such as this one.

- PEAR and PECL

It has been said that good programmers borrow, but great programmers steal. While I do not advocate ripping people off, the premise of this quote is that if it's been done before, you'd be wasting your time to re-invent the wheel. PEAR - PHP Extension and Repository, and PECL - PHP Extension Community Library are two big components of what make PHP so great. You could think of it as standing on the shoulders of giants, continuing to build where they left off. Basically, each of these is a big pool of submitted extensions that improve PHP's functionality. You could think of it like installing a plugin for the language.

There are far too many extensions to do justice in this review, but one of the ones mentioned in the book was the Date class. With this package installed, you can reference and modify the date with methods like these: addSeconds, getDayName, getMonth, getNextDay, getQuarterOfYear, isLeapYear, etc. As you can tell, each of those is more human readable than: echo date("Y");.

- Code Efficiency

This was a great chapter on balancing code efficiency with real time efficiency. In other words, you don't want to kill yourself over a few milliseconds of loading time, if it is going to take several hours of real development work, especially if that time could be spent better elsewhere. They gave an example of a server computer running software slowly. The first reaction might be to buy new software, resulting in days of lost productivity due to necessary data backup, operating system and program upgrades. In their example though, all that was needed was more system RAM, requiring only a few minutes of down-time.

They take this same principle and apply it to coding methods, benchmarking a few ways of writing mathematical computations, namely a<<3 versus a*8 to multiply a variable integer by 8. If that looks like Greek to you, don't worry because it's explained in this chapter. Essentially, it's an argument of binary notation versus long-hand yet human readable code. They even go so far as to benchmark single quoted (') vs. double quoted (") strings. After an extensive series of tests, and rendering two very complex 3D graphs, it appears that single quoted is in fact faster, though many things can affect the outcome.

Aside from the theoretical arguments, they also help address various server configurations in order to find bottle-necks. An example of this would be too little RAM on your server, or too fast of a server in comparison with too slow of a connection. A good way to think of it is the adage "The box, or the band?" If it's the box, then you can make hardware tweaks, but if it's the bandwidth causing the problem, then you can either up that allotted amount, or tweak various compression schemes and server / client caching methods, to make things go faster. In addition, they of course show you how to write leaner, meaner PHP code, to save on both processor cycles and download time.

- PHP Extensions

This chapter touches on the many extensions that are available. Two of the ones I found to be interesting were PDFLib and GD Library. PDFLib does what the name implies, and creates PDF files on the fly via server-side methods, pulling info from a database. They give an example of how to create a r?sum? maker that outputs PDF versions for download. GD Library handles images on the server-side, allowing you to do things like rotate, resize, and even add watermark overlays or text descriptions with varying opacity directly into the image. This can be seen on sites like iStockPhoto, which have a branded stamp across preview images, encouraging you to buy the unaltered version.

- AJAX

Oh man, I am sick of talking about AJAX - Asynchronous JavaScript And XML. This book does a very good job of explaining the concepts behind it, but I feel like we hear about it so much nowadays that it is almost pointless to regurgitate it again. If you like, read the reviews I've done on books about AJAX here:

* http://godbit.com/article/ajax-and-php-review
* http://godbit.com/article/foundations-of-ajax-review
* http://godbit.com/article/professional-ajax-review

- Caching Engines

This is a good chapter for people who might be concerned about getting Slashdotted or being on the front page of Digg. Basically, it covers several methods of caching pages on a server, so that when a visitor comes, your MySQL database is not constantly being hit in order to serve up content that has not changed. This can be done in a variety of ways.

One such method involves using Alternative PHP Cache, which stores code from the PHP runtime engine in shared memory, so that it not recompiled each time unnecessarily. Other caching engines that function comparably are eAccelerator and the Zend Optimizer. They also cover JPCache, which is unique in that it does not require being installed as a DSO or built into PHP statically, because it runs off standard include and required statements. There is also one called memcache which requires its own daemon to be running on Linux, and caches database results in RAM to keep SQL from running, freeing up the hard drive. It should also be noted that according to this book, JPCache and memcache can "play well together" on the right server, further increasing response time.

Content Management

In this chapter, they cover installing and configuring a few different CMS's. Most of these I had not yet heard of, for example Exponent CMS. This is an enterprise level system, which I found is table-based and not very standards compliant. Therefore, I am not recommending it to anyone. Another CMS mentioned in this chapter is XOOPS, which suffers from the same sort of poor front-end markup. Basically, this chapter was about antiquated systems with bloated code. Also listed were Mambo and PHP-Nuke, both of which should be avoided. To their credit, the authors did cite Drupal and WordPress, which are more accessible and standards compliant than the aforementioned clunkers.

Summary

With the exception of the last chapter, I found that the whole of this book is one that I will refer back to often as I continue to grow in my usage of the LAMP development environment. I would highly recommend it to anyone who has dabbled in the Linux / Apache or PHP / MySQL combo, but really wants to gain a more complete understanding of how they interact. It will definitely help anyone who wants to write cleaner PHP or provide a more responsive hosting server.

This book only gives rudimentary coverage of MySQL or Apache.

Twenty one pages in the chapter for 'Advanced MySQL' -- really! 13 pages of this is a review of SQL, how to do queries, updates, deletes, etc.

Apache got 35 pages and was a little better. It did have info on rewriting URLs but a lot of time was spent on rewrite patterns and rules. Many of the other items and configuration settings could be gleamed from the Apache configuration file.

I really was disappointed as I expected more of a discussion of PHP in the context of MySQL and Apache. I wish the authors had spent as much time on the other subjects as they did on PHP.

Linux -- wasn't even in the table of contents or the index and I didn't see anything that was even close.

The discussion of PHP covered subjects like installing packages, code effeciency and PHP extensions and was adequate.

Maybe the book should be called "PHP Packages Available".

What I liked about the book was the heart of the content. As a new user to Xen, I had numerous questions related to configuration, what type of filesystem to use, and (very importantly) how networking functions. The author gives good examples, clear definitions of configuration file options and easy to understand overviews of how the various parts of Xen and virtual servers function and interoperate. I give the book a complete review on my own review website at Thompson Reviews but wanted to post this here in case anyone is in doubt of the quality of this book.

I really enjoyed reading Professional Xen Virtualization (PZV). The book answered exactly the right questions for me, a person who had no Xen experience but wanted to give the product a try. If you are looking for a book on Xen internals, you should read The Definitive Guide to the Xen Hypervisor by David Chisnall. If you are less concerned about source-code-level details but still want to learn a lot about Xen, you will definitely enjoy PZV.

William von Hagen is an excellent writer. I found it easy to follow his thought process and he delivers technical material very well. I found his coverage of Xen to be thorough and actionable. To try Xen I followed von Hagen's suggestion to boot Xenoppix, a live CD version. I used knoppix_v5.1.1CD_20070104_xen3.1.1_vbox-20071101.iso but as of this writing knoppix_v5.1.1CD_20070104_xen3.2.0_vbox-20080213.iso is available from the unit.aist.go.jp/itri/knoppix/iso/ FTP server. I am confident I could have installed Xen on dedicated hardware following the author's directions.

Several aspects of the book made it very useful to me. First, I liked the comparison to other virtualization products that appeared in part of Ch 2. That section gave me a better idea which product would be appropriate for my needs, especially when considering hardware support for virtualization and the differences between paravirtualized VMs and hardware virtualized VMs. Second, von Hagen often explains how and why a feature operates, rather than just listing what a feature offers. I appreciated this level of insight. Third, I liked seeing instructions for a variety of Linux distributions and the background on various Linux capabilities that could influence Xen deployment. These included logical volumes in Ch 6, initial RAM disks (initrd) vs initial RAM filesystems (initramfs) in Ch 4, and more.

I subtracted one star from the review for three factors. First, I would have liked some coverage on using NetBSD for Xen dom0 and domU. NetBSD has supported Xen in some fashion for many years and seems a priority for the OS. Second, one of the selling points for certain Linux distributions is their inclusion of tools for managing Xen VMs. While these are part of commercial distros (Red Hat, SUSE), the author could have described them more fully, or perhaps looked at Fedora's offering. Third, I could see how some of the background material on relevant but not Xen-specific Linux features might not be welcome in a book on Xen. For example, if I really want to know how to back up a system, I probably don't need to read about it here.

Overall, I was very pleased with PZV. I found earlier books on Xen to not provide enough detail to warrant reading and reviewing them. PZV, on the other hand, has all the material required to install and use Xen in production. I highly recommend it if you want to give Xen a try in your environment.

I was the first person to post a review for this book, and it appeared on amazon but then it disappeared a week or so later and a 5 star review showed up... makes me wonder... At any rate this "re-review" will not be as complete as my first review.

This book is pretty low quality. The author is overly verbose for many things that are not really directly relevant. Case in point, the first 3 chapters are spent talking about virtualization in general, and then the alternative options to Xen. That would be fine if this book was titled "professional virtualization," but it is not... it is supposed to be about Xen, so why would the author waste a full 1/3 of the book telling us what else we might want to use?

The actual meat of the book, the stuff thats actually useful, is pretty much the exact same information you can get from the Xen handbook/users guide online. The author does not provide much if any further value or insight.

Finally the Author must have been hurting for a page count because the 10-15% (i had it actually calculated in my first review.. i believe it was 11%) is an appendix and command reference for Xen.

All in all, this book is not any thing worth spending money on if you are looking for a serious Xen guide. I would recommend one of the two following books over this one.


"Running Xen: A Hands-On Guide to the Art of Virtualization" (available 4/08)

or

"The Definitive Guide to the Xen Hypervisor" (currently available)

No points, no correctness, no validation, no value!
What the hell is this book for? Is it just a manifestation that free software is bad?

This may be the perfect book about open source software because it places open source within the context of business value and does not promote it as the great panacea that characterize the message of far too many books on the subject.

What I like is that, after providing an overview of open source, its history and proponents, the authors discuss how to analyze open source software within two major frameworks: the Zachman framework that was developed in 1987 and is popular today as an enterprise-wide information systems paradigm, and a newer framework called CATWOE. I'm new to the latter, but it is solid and is independent of open source. CATWOE stands for Clients, Actors, Transformations, World View, Owners and Environment.

The remainder of the book discusses aspects of open source as they relate to the CATWOE framework, which ensures that fair and complete treatments of the business and technical issues are given. I would have liked a more in-depth discussion of the legal issues and business risks that are associated with the GPL; however, that information is in a state of flux and is probably best gotten from daily news sources.

If you want to understand open source software development, especially as it relates to business value, this book is the one I recommend. The authors also have an associated web site (the URL is provided in the book).

"Understanding Open Source Software Development" (UOSSD) is the perfect introduction to OSS for those outside the community. The book takes a fairly balanced look at the people and processes which define the open source movement. Although some aspects of the book have grown stale over the last three years, I still recommend UOSSD to those desiring a deeper look at the open source phenomenon.

One of the best aspects of UOSSD is its page count: at 180 pages of text, it's a fast read. It still packs quite a punch, drawing upon and summarizing academic and non-fiction literature on OSS. Prior to reading the book I was unaware of the idealogical battle between the Open Source Initiative and the Free Software Foundation. These and other historical observations were invaluable.

UOSSD is useful for those who want to leave the Microsoft-bashing aspects of the OSS bandwagon in search of a more meaningful role in the community. By explaining the OSS community's dynamics, readers learn that a good way to contribute is to submit patches (p. 104). Authors Feller and Fitzgerald explain that OSS has "the highest payoff for software which requires a high degree of reliability" (p. 135). This is the heart of the security debate engulfing Microsoft.

My only criticisms relate to the passage of time. The book's "acknowledgements" are dated Oct 2001. Unfortunately, a company analyzed in several locations, CoSource, appears to have had already gone out of business by then. Late last year Red Hat left its "pure play" OSS role for "RHEL." Concerns over a lack of internationalization, particularly for languages, have been completely reversed; OpenOffice supports more languages than Microsoft Office.

Despite these drawbacks, UOSSD is a great book for techies and managers alike. I'm adding it to my "Management and Policy" Listmania List today.

I have been a Novell dealer since the 80's. I also have extensive Unix (SCO) experience, though my Linux experience is much weaker.

We had already spent about six weeks with OES Linux. It was a rough ride (and still is a little bumpy at times). It could have been smoother had I had this book from the beginning.

Unfortunately, we had already learned most of what this book had to tell us from the school of hard knocks.

The most disappointing part was the troubleshooting section. It was limited to telling us where to find the log files--something we figured out weeks ago.

What we're hoping for is a "Mastering Novell OES Linux" that goes into each component (namcd, ndsd, nss, ldap, etc.) and takes it apart, gives you all the gotchas and gives you possible causes when things don't go as planned.

I've been working with Novell Netware for many years and needed something to ease me into the linux side of things. It works well by taking all the services you know and love on the NW kernel and shows you how to get the equivalents running in linux.

In less than 300 pages, the author skims the field of reporting with Ruby on Rails. Not meant as an authoritative reference nor a tutorial on the Ruby language nor Rails framework, David points to useful utilities and gems that let the developer deliver analyzed, summarized, processed data in many formats. For a great many applications, in the view of the users, the reports ARE the application, so getting the right format and right data presentation are essential. David briefly touches on the database fundamentals and then dives right into a set of practical and easily-understood examples using common data (eBay, PayPal, SugarCRM) and demonstrates how to create output in the most demanded formats: web pages, PDFs, graphs, and the office formats. With a topic so broad and a book of moderate size, David trades depth for breadth and does a great job of pointing out many Rails idioms and useful 3rd party tools.

Disclaimer: David's an associate of mine and arranged for a review copy of the book.

Practical Reporting with Ruby and Rails is primarily a book about the presentation of reports. Having gone in expecting a mixture of presentation and production techniques I was a little surprised to find that the vast majority of the reader's time is spent looking at various GUI and graphing toolkits, export to MS Office and the like, and there's not much space given to managing large volumes of data, warehousing, and other such topics.

That's not a criticism of the book so much as a caution to potential readers. After a little time spent looking at ActiveRecord, particularly focussing on using its calculation methods to save processor time, David Berube provides a pretty thorough coverage of a variety of ways to present reports. A few options for delivering data as PDFs, through a GUI, or directly into office are offered and a straightforward walkthrough is provided for each. The Rails content is minimal, and while the sample code could do with some refactoring and there'd be a case for using something more lightweight like merb it does the job.

But I must confess to being a little disappointed that there wasn't more time spent on the data processing side of the equation. Having been building a lot of graphs lately and needing to write some new reporting code in the near future it was helpful to have some analysis of tools I might use, but I never felt like the book ever really dove into the complexities of reporting. There's space in a book of this sort for serious consideration of both data processing and of visualisation techniques, but neither is really offered. Each chapter simply answers a very tightly defined request rather than delving into the full problem domain, and that feels like a missed opportunity.

If you're evaluating output options for your ruby application's reporting layer, this may be a handy book to have. It'll provide you with a sense of what tools are appropriate for which problems and more detailed sample code than is easily found on the web. But if you're looking to really grapple with reporting and visualisation you might be better off seeking out a good SQL reference and some of Tufte's books.

Disclaimer: I was sent a copy of this book for review by the publisher.

The book covers the basics of PostgreSQL, but it lacks usefull info for the more avanced tasks like tuning the database.
The 'stored procedure' (PL/pgSQL) chapter was for me the only interesting part of this book for me.
When I bought this I was hoping for the PostgreSQL 'Bible', but it was a big dissapointment.

My advice for improvement for the next release:
- much better index
- drop LXP chapter
- chapter about how to tune (not just SQL statements, but the postgreSQL server itself) and benchmark PostgreSQL.
- a chapter about 'schema' and when to use them.
- extend PL/pgSQL chapter with some 'real world' examples and how to do PL/pgSQL trouble shooting, PL/Perl(?)

- general advice how to manage PostgreSQL on 'day to day' basis
- maybe have a chapter about the SLONY replication add-on
- Postgresql 8.0 features

The Command Prompt guys did a fine job of writing this book. It contains basic topics, like retrieving rows from a table, and advanced topics, like session encryption, JDBC, and PL/pgSQL, and everything in between. A very complete SQL command listing is available at the back of the book, as well, for those times when you can't quite remember proper syntax.

Furthermore, it covers all the tools provided with PostgreSQL distributions (vacuumdb, etc.) and has a chapter on the included LXP software, which I haven't tried because I don't need it.

This text, in conjunction with Programming the Perl DBI, got me from a PostgreSQL/DBI newbie to accidentally memorizing common SQL syntax, writing my own Perl DBI wrapper, and programming some simpler PL/pgSQL functions in about four days.

I highly recommend it both as a tutorial and as a reference. Be warned, though -- the index is a bit sparse. Using it as a reference might require putting sticky tabs at the tops of your pages, as I've done.

This book used to be a good reference for PostgreSQL 7.4. However there is much more to PostgreSQL nowadays then it was six years ago.

This book has a problem that I guess most SQL books suffer from. It has a very long introduction to SQL itself. Which is not bad if you are a complete beginner. The book is somewhat boring to read, without that additional value because of which you buy a book. It lacks additional information on advanced PostgreSQL features, programming in PL/pgsql, replication, administration and some other interesting topics. On the other hand it's not that "practical" but rather a PostgreSQL reference.

All in all this book has too much reference which makes it hard to read. With that and the fact it is somewhat outdated, you might want to decide on skipping it.

I wanted to buy this book a few months ago, but after reading the reviews I relented. Finally, a few weeks ago I needed a book on PostgreSQL and it was the only one available, so I bought it. Since then I have referred to it almost everyday in my database programming duties. It is well made, well presented and goes into minute details that other books simply skip.

Normally I would have given this book 4 stars, but after being misled by the bad reviews below I decided it well deserved the extra star. My only concern with this book, is that it leaves out PHP, which is a shame. Because most people I know use PHP to interface the web with PostgreSQL.

if you need a book on the best Open Source database at the present, then this book should be amongst your top picks.

This is an excellent book to begin learning about the most advanced open source database available, it covers the theory and history of PostgreSQL and includes instructions on installing the database server.

The authors clearly explain the topics covered in the book, I've given the book to several co-workers who were interested in the book and they also view it favorably.

I recommend this book to the person interested in learning more about PostgreSQL or the person who has never used a database server before.

This book does not get into the advanced features of PostgreSQL but all in all this is a quality reference and handbook, perhaps better named as Learning PostgreSQL.

When I started with DotNetNuke a year ago I knew absolutely nothing about it. I bought a copy of professional DotNetNuke 4 read it cover to cover and it did wonders. It is very easy to understand it covers everything you need to know, and best of all it is a great reference even when you have experience with DotNetNuke. I still reach for this book to answer most of my questions.

If you are unlucky enough to get tasked with working with this godawful technology, I guess you have one of two options:

1) Buy this book. It's far, far from being comprehensive, but it's enough to keep you treading water for awhile.
2) Get a new job. This is my personal recommendation.

This book might be the worst software book I have read. The most helpful thing in the book is the appendix with dotnetnuke related links. The examples are lame and the content is scattered like a bunch of different people wrote sections in a vacuum. No flow.

My expectations appear to be in sync with other developers looking for a book that really goes under the hood to explain how to develop modules for the DotNetNuke portal framework. Much of what is written here you can find in their other book geared toward DNN 3. For example, page 58 in the DotNetNuke Portals book is page 88 in this one. I also agree with others that much of the information in this book has already been covered in the DNN documentation, the online help, and more thoroughly in Lorraine Young's DNN Guide (I understand that she is authoring a DotNetNuke for Dummies book, also not geared towards the developer, and which I have a hunch will also be a re-hash of her DNN Guide - which is rather good for its intended audience).

I hate to be so harsh here but I hope that the message gets across that developers are really looking for a solid technical book with practical examples on how to program for this framework, and tips and tricks for leveraging the DNN framework as well. Daniel Egan's first book covering DNN 3 was a very good attempt (his second was yet another re-hash, though). Traincert.net has a video which describes a creative way to setup your development environment to develop DNN modules for DNN4/VS 2k5, but that's about all...

I hope that Shaun and the other's who are responsible for putting together such a terrific open source application see an opportunity here.

This book is NOT for you if you need to seriously use DotNetNuke or if you are going to embark on custom module development.

This book is definitely for you if you want to know why Shaun Walker and the other core folks made certain decisions from 1.x through 4.x. This is only useful if you have to write a review or report on DotNetNuke for a magazine or blog.

I've been using DotNetNuke seriously since before it was DotNetNuke and I have read all the books written about DotNetNuke through version 4.x. Frustratingly, none of the books gets my recommendation and this particular book is at the bottom. This book is full of general explanations that do you no good if you need to use DotNetNuke.

This book is a shining example of the Achilles heel of DotNetNuke: it's a framework by architects, for architects.

If you want to see what DotNetNuke ought to be more like, get the XMod module (it's a third-party product and I'm not affiliated with it in anyway and I'm not going to give you a link to it, just search for XMod).

XMod is doing what DotNetNuke should be doing because XMod is a user's product. If you don't really want to make your own module or find that the documentation on customizing DNN just does not cut it -- get something like XMod. You'll still be using DotNetNuke but something like XMod is well documented and provides many duplicate features of DNN that accomplish functions similar to DNN but in a much, much more robust and usable way.

In the case of both DNN and XMod the "user" refers to a developer.

Don't let anyone fool you, DNN is a developer's product and you need to know a lot about all the web applicaiton technologies involved and ought to be able to use Visual Studio and SQL at a minimum.

But the nutty thing about this book is that it spends half its time speaking above the developer talking about architectural decisions and other esoterica that will not tell you enough to mimic the architecture or use the code unless you are already a DNN expert developer.

This book will drive you mad if you are a developer who is not afraid to compile a VS project and you are looking for an answer such as, "How do I just add a couple of columns to the Survey module table, a bit of extra business logic and a few cosmetic changes I need?" This book will only reiterate that DNN modules are scattered all over the place in this provider and that or this App_Code folder or that. And that DNN achieves an oh-so-wonderful but madingly obfuscatory 'separation of Church and State' architecture.

The rest of the time this book talks below the developer and gives worthless "For Dummies" information about how to use the various modules like Announcements and Links. For goodness sake Wrox, how in the world did you pass off such a disjoint amalgam of chapters?

DotNetNuke is a very good application framework. Today (Spring 2007) DotNetNuke 4.5 is the best starting point for your web application regardless of size or deployment. DNN blows the LAMP alternatives out of the water.

It remains to be seen if DNN will continue to be needed. My prediciton is "No". DNN is already being absorbed into .NET & Visual Studio and will continue to be absorbed. The only wildcard is the need for Microsoft to present the illusion of "Open Source". It is an illusion because in truth, Microsoft directly funds and virtually controls DotNetNuke. (Sorry, Shaun, it's a fact even you admit in this book. But it's okay with me and most DNN users.)

Even though this book spends and inordinate amount of time explaining "For Dummies" details, it does not provide enough to be useful! For instance, it tells yous about the editor and the discussion module and then promptly dismisses both as inferior to modules you ought to go download. So, you are left on your own to use a module that is not documented.

Trying to develop a custom module in any version of DotNetNuke is not for the uninitiated and chances are you bought this book because you are endeavoring to create a custom module. You would think this book would excel at providing assistance to the custom module developer. But alas it does not.

It is full of "we did this in version 3 because people wanted that in version 2, etc." rather than getting down and dirty into custom module development. Also the examples are incomplete snippets and only in VB.

I will conclude this epistle with a plea to Shaun and the Core: Stop writing books! Instead, provide thorough, updated online documentation, tutorials and private forums. I'd pay way more than the price of this book for a library of sample projects (And please in C#!) with tutorials and explicit instructions. For instance, take Michael Washington's tutorials. I'd pay for access to that type of resource if it were fleshed out a bit more, presented in a more organized fashion and included in-depth documentation and access to private forums to ask questions and get help when deadlines need to be met (on a pay-per-use basis if necessary).

Trying to follow an example in this book will drive you mad because it always leaves out all the REALLY IMPORTANT details like paths, settings, options, creating and configuring IIS for webhost sites versus localhost sites etc. Constantly the book says things like, "If your site is hosted, you'll have to do this part differently." REALLY!? Just HOW is it done differently!? THAT'S WHAT I BOUGHT THE BOOK FOR!

P.S. It is quite evident that few of the Core Team actually use DotNetNuke. The Core really needs to add some serious users to its ranks. Right now it is just a bunch of (very good) system programmers. System programmers we all know are topnotch in their areas of expertise but usually suck at knowing what makes an application a winner with the end users. The upshot is that we who do know the latter end up spending the bulk of our DNN time tweaking under, over and around the ugliness and clumsiness of DNN. This ugly clumsiness can be seen architecturally where too many times, when you need another of something you have to create a new modules and there is no way you (the developer) are going to let end users add modules to pages. So you end up not being able to use a module only because you cannot get "another" one without adding a new module to a page.

I tried to read this book, but gave up after the first few chapters.
There MAY be actual useful and relevant information in later chapters, but judging by the amount of text devoted to opinionated rants and tiresome attempts at humor, and the otherwise belabored discussion of precursor or peripheral technologies, I decided that the book was too short to ALSO cover much useful information on the actual subject, and also that life is too short to spend it panning through these layers of distraction to maybe find a few useful points. At this point, I would have to view any points made with skepticism, having witnessed the author/editor's apparent poor judgment if not outright disrespect for the readers.

The book reads like a blog that thinks it's too big for just the web.

This book was far more informative than I imagined it would be, and I very highly recommend this to anyone who wants to get into Ajax.

Also lots of good humor throughout the book.

Great!

with the reviewer that mentioned the fact that this book is filled with an unbelievable amount of nonsense. If you were to take the good parts of this primer and remove all the other tree pulp waste, it would be a 30-35 page book. The parts that are informative are so, but fall short in depth and sometimes the author just goes on another of his drivel rampages in media res and confuses the bjeezus out of the reader.

One of those computer books that makes you be glad there are lenient return policies for books.

I found the book to be an easy read because the author wrote in a conversational, and often humorous manner. However, what I found disturbing and difficult to learn from was that, even though the author included a lot of code in the book, there were almost no screen shots of what should be expected of the code. It made understanding what was being explained difficult because there was no visual side to the code. Also, he talked about the ability to hide pages and using a method to unhide those pages for debugging purposes, but, again, should have included screen shots to demonstrate his techniques. Unfortunately, I will have to find another source to help me learn this topic.

The book is an unfortunate failure, given the popularity and importance of the topic. It is filled with geeky humor, but far too much so, such that this fluff adds almost a third to the length of the book. There is plenty of code, but much of it is detached and not useful at all to someone trying to learn these concepts from scratch. The book is of little use to either the expert or the complete beginner. The expert will be puzzled by extremely repetitive explanations of the absolute basics of XML and Javascript, while the beginner will be bewildered by the fact that it contains such introductory passages even as they are overwhelmed by pages of PHP, C#, advanced XML, and countless short-cuts in the code which feel like unnecessary showing off when you are trying to teach users how to use AJAX.

If you are interested in getting a Mythbox up and running, this is a great book to start with. True, all of the information you need is available on-line, but here it is organized and at your finger tips. The book is clear, well written, well organized, and reasonably complete and accurate. Things change very rapidly in an area such as this, but this book provides a great foundation. If you are willing to use the Ubuntu distribution and MythTV version that is used in the book, things should go well.

One thing to look out for, if you are new to Linux their recommended procedure for compiling from source will be a bit of a challenge. They do NOT tell you what you have to do to be able to compile something from source. There are many packages that need to be installed above and beyond the standard Ubuntu install. However, I just used Synaptic to install the version of MythTV that is available as a Ubuntu supported package and things went fine.

Well worth the money and highly recommended.

I have been using Windows for as long as it has been around. I have done web development. I have even been exposed to Unix a number of years ago, so I thought I would be able to follow directions in this book and be successful. Ubuntu was easy to install and looked like a good product. However, the directions in MythTV did not work. I finally gave up after installing Ubuntu five times and starting all over again. I even purchased a Ubuntu manual thinking that would resolve the problems I had. Unfortunately, it did not and I finally gave up and re-installed Windows XP on my computer and BeyondTV. That did work. I was reminded that Windows does make some things simple that the Unix platform still makes somewhat difficult. I would not recommend the book. I plan to give it away... The Open Source "Open Office" worked great on Ubuntu as it also does on Windows, so I judge MythTV or this books directions to be the problem.
Cecil Denney, Maple Grove, Minneapolis

I fall within the vast range of Linux users who know just enough to be dangerous, but at least realize that this is where they happen to be.

I purchased this book brimming with enthusiasm and confident that with its assistance, I'd have no problem getting MythTV up and running.

In fact, my experience with this book was very ungratifying and downright frustrating.

To start with, I found that many of the command lines cited in the book just plain didn't work. In some cases, it was easy to discern where the commands strayed from reality, in other cases not so much. These discrepancies might arise from my using a later version of Ubuntu or MythTV than those to which this book was written. Frankly, I don't know.

I was also frustrated to find that while the publisher provided a web page for users to report errata, it was a purely one-way - You're free to leave your comments, but don't expect a compilation of earlier postings (or corrections)to be made available in exchange, and certainly don't look for any sort of response.

In the end, I set this book aside and installed Mythbuntu - Ubuntu and MythTV all rolled into one ISO package, and searched the web to resolve the myriad of issues and tweaks that had to be addressed. This was not the outcome I would have preferred, and what I was hoping to avoid when purchasing this book, but at least I've managed to get my crate up and running from scratch.

If you are already very strong in Linux, this book will easily give you the guidance you need, but otherwise, caveat emptor.

For what it's worth.

The book is outdated for the state that mythtv has advanced to. I used MythDora to set my system up and most of the hard work has been done. There are also areas that the book does not cover. I actually found the book to be not be worth the money.

Look, I'm not going to say that these guys didn't try, or that this is a cynically written attempt to cash in on something, but this book is as close to worthless as I can imagine.

Now, again, this is not entirely the authors' fault. MythTV is highly dynamic. What's true today isn't true tomorrow. I'm a journeyman MythTV builder, and a lot of what I've learned in the painful progress I've made simply does not apply any more.

That said, a lot of stuff =hasn't= changed, and it's here where the book falls apart. They should have started with the basics of content flow, i.e., where is the media coming from? Because that's the first thing you need to know before you even decide if MythTV is right for you. (Over the air content, for example, is easily handled by Myth, while controlling a set-top box from a cable, satellite or fiber optic company is a whole 'nother kettle of fish.)

While support has been added since this book was written, the stuff they actually did mention that has been part of MythTV since its incpetion is not well covered. For example, to set up your MythTV backend, you have to select from various capture card types. There are V4L, MPEG2, DVB, etc.--how about explaining what these are? No explanations is the norm, and when there is an explanation it's often simply restating the on-screen text without actually clarifying.

Six months of having this book and I've never once found an answer to a question I had. Now, I don't go looking for product specific stuff, because (as I said) there's no way they could cover that, but just basic joints and cogs and so on.

See, the thing about MythTV is that if you have just the right hardware and a simple enough setup, it might take you fifteen minutes to set up. If you don't, it could take you weeks to set up, or you might never be able to do it.

To be useful, this book really should have explored =how= to troubleshoot. They couldn't do the actual troubleshooting for you--there are too many things that can go wrong--but they could tell you about the utlities and hardware settings that allow you see where your problems lie.

Maybe they just didn't have the space. But, as I say above, it makes the book almost completely worthless.