5 comments about Principles Of Software Engineering Management.

1. This book covers three main topics: evolutionary development, requirements management, and inspections. A good introduction to all three, but if you plan on trying evolutionary development, I also suggest reading the pertinent sections of Rapid Development by Steve McConnell.



2. Gilb covers only a small portion of "Software Engineering Management" in detail. Other important issues are either not addressed at all or receive only cursory treatment. Still, what it does go into depth about it usually well thought out and makes imminent sense. I'd say it's worth reading, but it may be a bit expensive for it's narrowness.



3. Firstly, don't let the title put you off -this book is relevant to a lot of people who wouldn't call themselves "sofware engineers" or "managers" - it's also highly relevant to systems analysts / designers & just about any sort of IT consultant, amongst others.

   What separates this from most other books on software development is that just about every page is obviously written by someone who has been there and done it (recently), not just talked about it. The main ideas of the book (evolutionary delivery, defining ojectives as either "functional" or "attributes" ) may not seem revolutionary, but apply it and it could revolutionise your project and maybe career. No IT book I've ever has ever affected my own work so profoundly.

   It's also well written and exceptionally well laid out. More please, Tom!




4. I found this book hard to read. I often had to force myself to read further, although the ideas and principles described are important and should be required knowledge of any software engineer and SE manager (which does not mean that they necessarily apply to all projects).

   The book contains endless redundancy and lots of hard to understand details of projects the author has worked on. One chapter even contains excerpts from other books and articles that confirm the author's views - as though the author feared he hadn't been convincing enough (that wasn't the problem).

   In summary, the book should have had half the length and that would have still covered the same content. It might be interesting to readers new to the principles of evolutionary delivery, measurable attribte objectives, and inspection.




5. This book covers two very important software engineering topics: the unambiguous specification of business goals and product specification and on evolutionary project management. It also covers the Fagan inspections process which is one of the most powerful techniques in software development. If you like this book, you should also consider the book "Competitive Engineering" by the same author.

5 comments about An Introduction to General Systems Thinking (Silver Anniversary Edition).

1. In computing, a timeless classic is anything that is worth reading for any reason other than to obtain a historical context after five years. If that still holds true after twenty five years, then it is truly an extraordinary piece of work. That label applies to this book. It is not about computing per se, but about how humans think about things and how "facts" are relative to time, our personal experience and environmental context.
   Human thinking is a complex operation and that is the point of this book. The problems and examples presented are not those in computing, but problems in how we think about the world and how that world can be different from person to person. In many ways, Weinberg anticipates the development of the science of chaos, where small changes lead to disproportionate large changes. His example of the "small" change of a single character is a classic. A man was considering the purchase of a piece of real estate, but when told the cost was fourteen million dollars, sent the response by telegram, "No, price too high." However, somehow a character was dropped, so the agent received the message, "No price too high", purchased the property and so a classic error was invented.
   Weinberg uses science and mathematics as the genesis point for most of his examples. The laws of thermodynamics, chance and simulations in state spaces are used to demonstrate the points. As someone with a wide background in science, I found his examples of how scientific thought gives us an anchor but yet alters over time excellent learning material. Thought problems are included at the end of each chapter and they cover many different areas. Some involve mathematics, others science and many could be the point of a vigorous philosophical debate. Together they form the best collection of thought experiments and points of contention that I have ever seen gathered together in one location.
   This is a book that is a true classic, not in computing but in the broad area of scholarship. It is partly about the philosophy and mechanisms of science; partly about designing things so they work but mostly it is about how humans view the world and create things that match that view. This book will still be worth reading for a long time to come and it is on my list of top ten computing books of the year.



2. Weinberg distills the essence from von Bertalanffy's classic and manages to present it in a very accessible fashion. The book has been out of print for quite a while so it is great to see a new edition. The message and information contained in here, although originally published in 1975, is now more relevant than ever.

   Weinberg covers many aspects of systems theory beginning with the main stumbling block with the present scientific paradigm: the idea that the universe is mechanistic. His treatment is much more general than Robert Rosen's in "Life Itself" but still conveys why the mechanistic notion is flawed.

   He then outlines the general systems theory approach before leading into the idea that a system is simply a way of looking at the world. He then outlines the principle of indifference. This leads straight into two sections outlining various aspects of making observations. Finally he discusses behaviour and then some general systems questions.

   Throughout the book he uses many examples from disparate fields in conjunction with questions for further research. It is great to see someone who doesn't preach systems but actually uses the ideas.

   Definitely a must-read as we decided how to solve the myriad of issues before us.




3. I was searching for an alternative to the out-of-print book 'Quality Software Management, vol.1: Systems Thinking', written by the same Author.
   Having read few Sofware Management series books from the same Author, which I rate at the very top of my list, I was biased on very high expectations. Surprisingly, I have found it being quite verbose and in the end, I couldn't get too much inspiration out of it.



4. This book is excellent. I first read this book in graduate school in 1976, and I continue to find Weinberg's ideas useful. It was outstanding then, and it has held up with time.



5. Weinberg's book will not teach you how to be a systems thinker. It will, however, provide a stimulating discussion and thoughtful examination of an alternative approach to problem analysis and solution. The book is not so much about how the systems approach works or how it can be applied to complex problems as it is an invitation to his readers to explore their perceptions of what they think they know versus what they really do know. Throughout the book, Weinberg follows the strategy of leading the reader through a series of logical discussions designed to bring them face to face with their biases and misconceptions about systems vs. reductionist thinking. In doing so, Weinberg exposes the shortcomings of the reductionist approach to problem solving by demonstrating to his readers that the real solutions to some familiar and apparently simple problems are very complex.
   
   Through his examples, Weinberg shows that by viewing a system holistically within its environment, we may be able to discern patterns of behavior/actions and recognize interactions, interrelationships, and interdependencies among the components that will be missed in a reductionist approach. From that view, we can better understand the system and, perhaps, better predict how it will evolve over time. The success of his approach is demonstrated by the fact that people are still reading and quoting his book 25+ years after it was written.
   
   One facet of this book which I found beneficial may be a drawback for some readers. Weinberg wrote from the viewpoint of a computer programmer and a scientist. A person not versed in either field might have difficulty understanding his examples.

2 comments about The Software Optimization Cookbook Second Edition. High Performance Recipes for IA 32 Platforms.

1. This is a well-written, easy to read and inspiring book that gives insight into a fascinating new technology - this is the most useful software optimization book ever written. As modern processors include many advanced features such as branch prediction, cashes with hardware prefetch, out of order execution cores, instruction level paralellism and intraregister vectorization, writing high performance software for such arcitectures is not so easy. In addition, most programming languages available today have not been delibetarly designed to take advantage of these newly introduced architecture features.
   
   It is therfore fortunate that the second edition of the software optimization cookbook gives such a useful and easy to read introduction to software optimization on modern architecures. This is most important for the engineers that develop performance critical software applications but want to ensure high readability and easily maintainable source code.
   
   For example, advanced compiler techniques such as profile guided optimization and inter procedural optimization, pedagogically described in this book, may boost the performance of your application. This is not surprising; cache misses may seriously obstruct memory intensive applications as memory is ridiculously slow compared to cache on most modern processors.
   
   The Intel processors, together with the Intel compilers and the books from Intel press, significantly simplify the job for the software developers that struggle to increase the efficiency of their applications. My experience is that the Intel compilers, tailormade to the Intel processors, take better and better advantage of the advanced features in modern processors. Thus, the development of efficient software becomes easier and easier even though the processor architecture becomes more and more complicated.
   
   Switching to the Intel compiler may significantly improve the performance of your application, thus there is no such thing as "change the compiler only"; the compiler alone may actually be responsible for most of the increased speedup seen in many applications. However, you may need to rewrite some parts of your code, as recommended in this book, to obtain a clear and readable compiler-friendly programming style - a too complicated source code tends to hamper the usefulness of the advanced optimizations available in the Intel compiler and reduces the source code readability for your co-workers.



2. The Software Optimization Cookbook, Second Edition, provides updated recipes for high-performance applications on Intel platforms. Through simple explanations and examples, four Intel experts show you how to address performance issues with algorithms, memory access, branch prediction, automatic vectorization, SIMD instructions, multiple threads, and floating-point calculations.
   
   Software developers learn how to take advantage of Intel® Extended Memory 64 Technology (Intel® EM64T), multi-core processing, Hyper-Threading Technology, OpenMP*, and multimedia extensions. This book guides you through the growing collection of software tools, compiler switches, and coding optimizations, showing you efficient ways to improve the performance of software applications for Intel platforms.
   
   Highlights include:
   
   - Choosing the right algorithm
   - Automatic vectorization and hints on how to guide the compiler
   - Compiler support for multi-threading
   - The performance impacts of shared L2 and L3 caches
   - Loop optimizations and when to use the compiler for performance gain
   - Use of intrinsics to exploit SIMD technology
   
   Software developers who want to understand the latest techniques for delivering more performance and to fine-tune their coding skills will benefit from this book.
   
   
   Customer Comments
   "A must-read text for anyone who intends to write performance-critical applications for the Intel processor family."
   
   --Robert van Engelen, Professor, Florida State University
   
   "This book simplifies the task for engineers who strive to develop high-performance software without sacrificing source code readability or having to understand all the nitty-gritty details of IA-32 processors."
   
   --Lars Petter Endresen, Doctor of Engineering, Physics Scandpower Petroleum Technology
   
   ABOUT THE AUTHORS
   Richard Gerber has worked on numerous multimedia projects, 3D libraries, and computer games for Intel. As a software engineer, he worked on the Intel® VTune(tm) Performance Analyzer and led training sessions on optimization techniques. Richard is the original author of The Software Optimization Cookbook and co-author of Programming with Hyper-Threading Technology.
   
   Aart J.C. Bik holds a PhD in computer science and is a Principal Engineer at Intel Corporation, working on the development of high performance Intel® C++ and Fortran compilers. Aart received an Intel Achievement Award, the company's highest award, for making the Intel Streaming SIMD Extensions easier to use through automatic vectorization. Aart is the author of The Software Vectorization Handbook.
   
   Kevin B. Smith is a software architect for Intel's C and FORTRAN compilers. Since 1981 he has worked on optimizing compilers for Intel 8086, 80186, i960®, Pentium®, Pentium Pro, Pentium III, Pentium 4, and Pentium M processors.
   
   Xinmin Tian holds a PhD in computer science and leads an Intel development group working on exploiting thread-level parallelism in high-performance Intel® C++ and Fortran compilers for Intel Itanium®, IA-32, Intel® EM64T, and multi-core architectures.

2 comments about Pro Access 2007.

1. There is useful information here but the presentation and layout do not allow one to easily take advantage of it



2. I have been very much enjoying reading Martin WP Reid's new book "Pro Access 2007".
   
   
   
   In fact, for me, it is just what I need at this time.
   
   
   
   As an Access developer who has acquired a reasonable level of skill and knowledge of earlier versions of Access, I have nevertheless been feeling a little intimidated by the scale of the learning curve ahead, to come to terms with the new wave of changes in my industry. I bet I'm not the only one!
   
   
   
   Martin Reid is easy to read. He has a slightly informal, shoot from the hip sort of style. Very personable.
   
   
   
   He wades into all the key areas where Access developers have to take notice. The Ribbon UI, what's new in Access 2007, SQL Server 2005 Express, Windows SharePoint Services, to name a few.
   
   
   
   It's a relatively short book, less than 400 pages. It isn't an in-depth coverage of everything you would ever want to know. It's not that sort of book, nor does it pretend to be.
   
   
   
   On the other hand, it is not a trivial work. It is written for the professional developer, and the content relates accordingly.
   
   
   
   What comes through, is the author's passion for Access, and his understanding of Access's continued position at the cutting edge of database application development.
   
   
   
   Martin Reid's skill here, is in identifying some of the core concepts, demystifying them by explaining them in straight-forward language, and illustrating them by superb examples. All this at a comfortably manageable pace.
   
   
   
   So as you see, I like the book, I learned heaps from it so far, it got me over a hump, and I will no doubt be referring back to it again.

5 comments about Principles of Transaction Processing (The Morgan Kaufmann Series in Data Management Systems).

1. Transaction processing is a daunting topic, and this is one of the few books that provides the basics in a clear, understandable manner without overwhelming the reader. Most of the book is focused solely on transaction processing, but it touches on queuing as well, which makes it the ideal first book for anyone who is seeking details that extend beyond pure TP.

   I like the way that the authors use real products to reinforce key points made throughout the book. While some of the products are no longer mainstream (indeed, some were never mainstream), the fact that real world implementations are used makes the information realistic. If you are using CICS, MQSeries, Tuxedo or similar products this book will have even more value. I also like the way difficult topics, such as locking, high availability and database recovery are given entire chapters because these topics need to be thoroughly understood in order to completely understand transaction processing.

   After reading this book you will be armed with sufficient knowledge to make intelligent choices in selecting the right approach for transaction processing in a system design, or to understand the nuts and bolts of any TPM that you are supporting. I also agree with Cem Kaner's earlier comments that this book is an ideal resource for software test professionals who need to understand the entire environment that they will be testing. If you want to go deeper into TP, I recommend "Transactional Information Systems: Theory, Algorithms, and the Practice of Concurrency Control" by Gerhard Weikum and Gottfried Vossen, which drills much further down into the details of both transaction processing and queuing systems.




2. This book was written in 1997 which is often considered ancient in "Internet-years" but it is still very relevant because it focuses on fundamental principles of transaction processing (TP) rather than the latest whiz-bang technologies that optimize TP.
   
   For those of you who aren't TP experts, a transaction is a computer operation that meets the ACID test. ACID here stands for:
   
   Atomic - the steps that comprise transaction succeed or fail as one, there is no partial success.
   
   Consistent - the internal data structures of the system(s) remain consistent with business rules.
   
   Isolated - the data read or manipulated by the transaction is not altered during the duration of the transaction's execution.
   
   Durable - the results of the transaction are persisted
   
   Why does this matter to the system user or stakeholder? The canonical example is that of the ATM machine (or the "handy bank" if you're Australian). When you withdrawl money from an ATM, it has to go out and validate you have enough funds to meet the withdrawl, reserve those funds, and dispense cash - all within the same transaction. If the ATM failed after your bank account had been debited but before you'd gotten your money, you'd be very upset; conversely if the cash was dispensed but the debit procedure failed, the bank would be very upset. Ted provides very amusing analogy for this using a wedding ceremony but you can read that in his book.
   
   There's a whole lot more to transaction processing beyond ACID and the ATM example, including two-phase commit (TPC), high-availability, massive concurrency, and crash recovery. To find out about all of these topics, read the book. One thing to remember though is that most application developers will never have to deal with the extremely complex details of providing a working and robust transaction management implementation, but like any technology it's important to understand the technology's fundamental principles and mechanics to effectively use it.
   
   The book itself is extremely dense. The content of the book is "only" 324 pages long but covers a large amount of ground in a good amount of detail. Definitely read in a quiet place free of interruptions with a strong cup of coffee.
   
   One shortcoming of the book is that it was written in 1997 so it doesn't cover TP implementations in Java (e.g. JTA, EJBs, etc.) but it was nice to finally find out what the heck IBM's CICS and IMS products are.
   
   Interestingly enough, I have never had to deal with complex transaction processing (i.e. two-phase commit) in my short IBM career. This is probably because I've worked on business-to-consumer (B2C) applications where only one data source is involved rather than a business-to-business system where multiple data sources are involved. I'll have to ask the B2B guys if they get heavy into two-phase commit or if it's not an issue.
   
   The reason I read this book is because I've always been a bit mystified by Enterprise JavaBeans (EJBs). When I joined IBM, I knew the word, but I was not familiar with such topics as object-relational persistence, object remoting, and transaction processing, so to me EJBs were simply things that took four classes/interfaces to do what I could do in one simple POJO. Ted Neward, in a very interesting web interview on the Serverside.com mentioned that he used to think EJBs were completely worthless, but during the process of writing Effective Enterprise Java came to realize that they were not worthless but rather over-marketed. He said that they should have been called Transactional JavaBeans rather than Enterprise JavaBeans because transactions are what EJBs did very well. So, hearing this from Ted I decided to read a book on fundamentals of transaction processing, so that I could understand EJBs better. Now that I've read all about TP principles, I pick Richard Monson-Haefel's book again, and all of a sudden EJBs start to make a lot more sense.



3. This book is excelent for who want to deep his knowledge in TP. Is very practical with many examples and tips. Funthermore include examples of of transacctions for commercials TP like a MTS (COM + today), Tuxedo, CICS, etc.
   Is a book very very recommendable.
   bye.



4. This in-depth look into transaction processing provides a wonderful place to start when considering implementation in your application(s). Cover-to-cover, this is an EXTREMELY easy read and doesn't try to be "fancy" or use complicated wording as many other books on the topic do.
   
   Before reading any other transaction books or jumping into API document, this is a MUST MUST MUST MUST read. When developing an application that has transaction support, this is wonderful as a reference in order to include data in presentations, summaries, position papers, internal documentation, etc.
   
   No only will this benefit a general developer, but also benefit people not in the development environment. This allows for clarification of communication between departments without going into API-specific implementation details.



5. The title of this review is a quote from the book and it summarizes it very nicely. Indeed, the book provides a great deal of information in such a small volume, but many of the things that would have been nice to have are missing and many are just skimmed over.
   
   The best chapters of the book explain in very simple words the principles of transaction logging (along with recovery from a failure), two-phase locking and two-phase commit.
   
   The chapter on transactional communications is not as thorough as the just mentioned ones and pays most attention to transactional message queueing rather than synchronous RPC and peer-to-peer. On top of that, message queues are just transactional, period. No attention is paid to the message queues specifics.
   
   The chapter on transaction processing monitors considers only the three-tier environment with presentation, workflow and transaction tiers.
   
   Other problems ?
   
   The whole chapter with an overview of the existing transaction processing software was useless. You see, product Foo has features A and B, and product Bar has features C and D, so what ? As you read it, certain architecture similarities show through, but it's up to you to analyze it, the book gives no cross-product comparison, no analysis, just a list of acronyms.
   
   Samples in Cobol (duh !) or tangled C-like code. The pictures are less than perfect.
   
   But the biggest problem to me was certainly the lack of real-life information. Specifically, I would better be interested in interaction between transactional and non-transactional systems. An acknowledgement of databases and message queues being the only transactional systems (or not) and the implications of that. Two-phase commit in heterogeneous environment. And so on.
   
   A great introductory book.

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 Live Linux(R) CDs: Building and Customizing Bootables (Negus Live Linux Series).

1. A Linux live CD is more than just a portable Linux system: it is quite versatile, offering a live CD with photo slideshows, presentation capabilities, and customization options - and can run on nearly any PC. LIVE LINUX CDS tells how to use the free software and tools needed to create a customized Linux live SD. Its instructions are step-by-step and specific and offers plenty of tips on configuration and customization. An accompanying DVD includes a bootable live Linux CD set, too, making it a top pick for any user seeking the most versatility from a portable system.
   
   Diane C. Donovan
   California Bookwatch



2. This book explain some tools, step, examples and straightforward theoris that i need, this is good for beginers and intermediate Linux "distro-yer"



3. I recommend this book for those who want to learn not only how to make bootable linux cds/dvds, but to learn about linux as a system. It has nice tips abaout mini-distros. And it's good for fedora fans. Great book.



4. Best!! Best!!....
   
   Quick in time and superb in quality



5. What more can you ask of a book than to give you what it says it will? If you want to create your own customized linux distribution or to tweak an existing one for a special purpose, then this is the book for you.

5 comments about Macromedia Studio 8: Training from the Source.

1. Very good book. Shows all the fundamental required to create websites. Very easy to read and understand. I would recommend it to anyone starting out in web design.



2. Another must have book from what is now Adobe Press. You can pretty much forgo the small book that shipped with S8, and or if you bought S8 through a download you wouldn't miss much. This book is what every S8 user should be budgeting for and getting as a get started and whats new. This is a great starter and refresher course material book that offers up great lessons.
   
   Each section starts with an overview, followed by a time estimate, expected outcomes and anticipated time for the lesson. Some you may want to skip over, others covering newer material with the S8 release, you will want to get more involved with. Each lesson has associated materials in the accomanying CD so you wont have to waste time on creating items to learn with.
   
   If you're a one person studio, you might want to have this on hand as it deals with many areas that all producers have problems with. Let's face it, a good programmer is seldom great with a graphics tool and vice versa. This book shows how to use Fireworks, Flash and integrate items (beautiful or not) with common code elements and interface with Contribute and ColdFusion.
   
   Great for self starters and single or multi subject educational material.



3. 524 page book also comes with a CD filled with chapter projects that you work on throughout the book. Walk-through's, explanations, photos and screen-shots are all very helpful. Book is thorough and concise as you would expect coming straight from the source. Shop around though; I bought my copy on eBay for $18.
   If you have the Studio 8 software suite, you almost NEED this book! Language is NOT high tech and easy to follow.



4. This was the first book I read when I was learning Dreamweaver, and I still felt a bit lost afterwards! If you don't have prior experience with Dreamweaver, I would recommend first reading a book dedicated to just Dreamweaver. Once you are comfortable with Dreamweaver, read this book, which covers Dreamweaver plus the other components of Studio 8: Flash, Fireworks, and Contribute, and shows you how they can all work together.



5. You will actually build a web site using DW 8 and Fireworks 8 and Flash. This book , although it has few errors, is a very good and through intro to web creation.
   
   Fuddzie

No comments about Hands-On Exercise Manual for LabVIEW Programming, Data Acquisition and Analysis (National Instruments Virtual Instrumentation Series).

5 comments about Zend Studio for Eclipse Developer's Guide (Developer's Library).

1. The help files that you get with Zend Studio for Eclipse covers much the same info and covers many topics that are only glossed over in the book. Most "chapters" are less than ten pages. One of the "longer" chapers in the book is the chapter on configuring your program preferences. That chapter is only 17 pages long and should have been shorter because it could have been condensed down into a few tables. So much of the text was wasted on instructions to tell you where to click the mouse. If you need to be reminded to click on "Save" buttons, maybe you shouldn't be a programmer.
   
   The back cover annoints this book "The definitive, comprehensive guide to Zend Studio for Eclipse." That's a bit of a stretch. It'd be more accurate to say this book is an intro to Zend Studio for Eclipse and a few related topics. I don't regret buying it because it was helpful to me. It did what I needed it to do, which was get my jumpstarted on my transition from Zend Studio IDE to Zend Studio for Eclipse, but if you're looking for a real reference that you can study and re-use, save your money. This book is basic and stops where a real reference book would have started from.
   
   By the way, the book is considerably shorter than the 216 pages that's listed. It's approximately 200 pages including blank pages and the index. Cut out the blanks and the index and it'll weigh in at a slim 174 pages.



2. Computer libraries strong in Zend Studio for Eclipse for PHP/LAMP developers will find Zend Studio for Eclipse Developer's Guide an excellent survey of the core techniques and terminology that make up Eclipse applications. From code editing and galleries to unit testing, debugging and more, Zend Studio for Eclipse Developer's Guide is an outstanding addition to any Eclipse developer's library.



3. I've never been a big fan of Eclipse but I now use Zend Studio so I had to get used to it. I could not have done it without this book. Eclipse operates so differently than any other IDE I've used that it was like visiting a foreign land but this book was my translator.
   
   Thanks Pete and Ian, I owe you guys a beer if we ever meet in real life.
   
   =C=



4. I cannot recommend this book to any target audience.
   
   For experienced developers the book lacks any detailed information on how (for example) to get remote debugging working or to integrate any version control software. The sparse overviews provided have nothing you won't already know if you've ever used any IDE.
   
   For beginners the book is rife with the kind of errors (the text does not agree with the sample code or images) that will drive them crazy.
   
   The writing is clumsy and full of grammatical and spelling errors. The actual information doesn't go at all beyond what you can get by simply browsing the help files you got with Zend Studio for Eclipse.
   
   Other than being able to read this away from the computer (not the most effective way to learn an IDE) there's no value to this book.



5. Nice book, that helps me speed up PHP developing in Zend Studio for Eclipse.
   
   Good introduction into Eclipse IDE and advanced PHP development topics like debugging or unit testing.