Programming Languages Books

This book is loaded with information on how to code JCL efficiently. We cut the run time for a 12 hour job to 3 hours using this book. I highly recommend the book for IT Professionals working with JCL.

This book is loaded with practical and valuable information. Excellent tool--even experienced IT professionals will benefit from the tips and techniques.

This JCL publication has all the parameters and statements most often used. The book also presents the most efficient and effective means to code the most common JCL parameters and statements. Olivia Carmandi hit the bullseye, writing a book that contains practical day to day answers in an easy to use format and size, an appealing tool to the busy IS professional.

This is an outstanding book that addresses and responds to the needs of its target audience in a very time efficient, practical, and helpful manner. Five stars.

A good little book for the most commonly used JCL and ideal for someone who does not have to deal with JCL on an everyday bases. The format is easy to follow and book size makes is easy to slip it into you pocket.

The focus of this book is on developing your survival skills quickly, helping you grasp and understand major concepts and terms so you can be productive in days; not weeks or months. JCL is an intense and complex computing skill and highly-valued in the industry. Traditionally, learning JCL takes years, learning small components at a time. Many programmers and operators eventually give up the chase. This book will help ensure that you don't. To paraphrase the line, "this is not your father's JCL manual." This book is not a thousand pages of prose, explaining every conceivable element that might appear in JCL. Instead, it focuses on what is actually being used in the computing world and packages it for easy consumption. I wish such a book had been available when I was learning JCL many years ago.

Happy Reading!! David Shelby Kirk

I've always liked O'Reilly books, and this is no different. It's a small no-fluff reference that makes for a good read as well. The book is physically small enough to fit unobtrusively in your laptop bag without causing too much of a bulge.

Since it is written as a pocket reference, it of course doesn't have all the commands or even all the variants/options for commands. What is does have are the commands and syntax that you are likely to use the most with some good examples.

Just know what you are and are NOT getting. It's not a bible, a step-by-step, or a cookbook. It is (as it is labeled) a pocket reference, at which it excels. Highly recommended.

George Reese's MY SQL POCKET REFERENCE 2ND EDITION covers Version 5.1 and provides SQL statements, functions, and insights into its variations and utilities. Explanations are accompanied by tables and examples for maximum efficiency.

MySQL has gained a lot of functionality after this book was done, but if you are a infrequent developer and like to have a quick reference into basic MySQL functions this book is great.

Reese hits a solid triple to start the inning off and scores easily on the wild pitch thrown by the reader who says that the GRANT section is wrong. This book works easily and appropriately at your deskside. I found the book to be a very simple, easy-to-navigate reference text that presents the most important aspects of MySQL in the quickest, most logical manner. It is very easy to thumb through with every possible random page landing at a topic of interest. In a way, it was like working with a familiar dictionary, you know the kind, where you just kind of naturally crack it open near the word you're accessing and flip a couple of pages either direction to arrive at the exact reference location. In that vein, I'd perhaps recommend that the margins contain "bread crumbs" telling us where we are in the book, but it isn't necessary since thicker sections often obviate themselves with just another page turn. Each page does have the chapter title in the margin, so my point is really one of nit-pickieness rather than a true critique. To its credit, the layout of the book presents the content in a manner that follows the O'Reilly "risen bar" standard. It is easy to scan through the entire reference flipping pages as quickly as possible so that you are able to arrive at your sought information within as much as a second or two. The bold text draws your eye to the page and the size of the page allows one to capture everything in a single glance. In my usage of the book, I found it very accurate and useful. I am a regular MySQL user and the formatting is very familiar to me. I highly recommend this book. If you are already familiar with SQL and the basics of database schema design, this is the perfect reference. I found it amazingly faster than loading the MySQL PDF manual and searching through potentially dozens of hits for the keywords sought. Even at the full cover price, this book is a value-added service at my side. The sections on operators, functions, stored procedures and triggers make this book an invaluable tool for the DBA or programmer who knows the material, but fails to remember every single aspect about the syntax AND who is tired of seeing that familiar: "You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near..." The text also finds welcomed complement from the numerous examples of using commands and SQL keywords. They are invaluable for immediately deciphering the sometimes too-numerous options of a command. I don't know that the book has taught me anything new at this point, but it certainly makes finding the details of what I already know much easier. Because of its brevity and its ease-of-use, it has made me want to play around with some of the various features of MySQL that I do not regularly use. That alone is going to teach me something new sooner or later! If your budget is constrained to a single reference item on MySQL, you can't go wrong with this very portable pocket reference. The back cover says: "When you reach a sticking point, but have to get to a solution quickly, MySQL Pocket Reference is the book you need." I agree completely.

It's handy, but a little old and too brief with important parts left out. It needs to be updated and improved. Ie: The admin commands are poorly covered. Do not use this book to help you use Grant or Revoke. The Grant All section is simply wrong.

Nicolai clearly knows his material very well, yet is able to talk at a comprehensible level. He doesn't dwell on the basics (what is a loop?), and on the other hand, doesn't get into all the arcane features of C++. I think it is a good book for anyone who already knows some programming (not necessarily C or C++), but is still enjoyable and informative for people familiar with C++.

Most examples are complete, concise programs demonstrating the concept. Code is well written and commented. He first gives the file listing, then dissects each new piece to explain what it does and why. Common errors and subtleties are explained. Often he shows several alternative ways of implementing a feature, and explains the pros and cons of each. For instance, implementing an operator first as a member function and then as a global function.

Where a feature may be better implemented with topics covered later, or is covered in more depth later, a page reference is provided. For example, input is first covered with rudimentary error handling, with a forward page reference to the version with improved error handling available using exceptions.

Some of the design rationale behind C++ and the standard library is also given, such as why the std::stack pop() function doesn't return the top element, for exception safety. This helps the reader appreciate the inherent difficulties and to incorporate similar solutions into their own code.

He covers the standard library (STL) and templates in enough detail to be useful, but really a separate reference on these topics is required. In this respect, his C++ Templates book is an excellent companion. (I expect his book The C++ Standard Library to be useful, but can't yet say from experience.)

This is a quite good book for professional programmers who are new to c++. Especially for designers and architects. In other words, without the knowledge described in this book, you can never design professional quality software written in C++. Also good for those who want to graduate from 'C++ as better C'.

THIS IS A GOOD C++ BOOK BUT THE AUTHOR DOES NOT RESPOND TO E-MAILS AND THE BOOK SELLS FOR $55.00 RETAIL, BUT PRICED HERE AT $60.00.

In my point of view, this book is one if not the best book I have ever read so far in C++. The author knew exactly what the reader needs to know and presented them in a clear and concise manner. It has very well written & easy to read C++ code samples. For a beginner to intermediate in C++, I think this book is for you as it walks you through a step by step approach to learning C++. The knowledge you would learn at the end of reading will make you feel better and comfortable in using C++. There are books out there that I've found boring if not too advanced at my level, I wish this influence you not to put yourself into that experience.

Thanks Nicolai for putting this together, a wonderful book that will surely help many people that are interested to learn C++.

I am an engineer (not a computer scientist), and my primary computer language is Visual Basic. I have written a good amount of code and I appreciate VB technology very much. (The fact is that this technology works good and cheap enough in wide scope of practical needs).
I wanted to extend my knowledge in computer programming languages and I began to study C++ computer language. At some point I discovered about the existence of the Standard C++ and I understood that, in my case, the right approach must be studying exactly the Standard C++. Finally I did find my personnel "Entry Point" within Nicolai's very nice book! While I often refer to other books as well, I do use the "Object Oriented Programming in C++" as main base point.
The Author demonstrated:
1. Deep understanding of the subject.
2. Strong defending of the idea of the Standard C++.
3. Carefully marking the commons and differences between C++ and C programming languages.
4. Great attention to the detail.
5. Clear explanations of the definitions.
6. Perfect cross references.
7. Generous sharing with the reader.
8. Excellent style!
Thanks a lot for the excellent job!
The Publisher did a good job as well. The book is easy to read and follow. Thanks!

A great read. Much more practical and easier reading than some of the classics in the code inspection theme.

Practical is a key element of this book. Like Wiegers' other books, this one is well written and researched; it provides a concise guide to peer reviews along with a set of useful tools for the practitioner, or "assets" -- documents, procedures, and spreadsheets that you can implement right away to put reviews into practice.

It's amazing, but peer reviews are not a regular practice in many software organizations. Peer reviews are proven to save time, money and promote learning and understanding among project team members. Perhaps one reason for their lack of practice is that there has been, up until now, little in the literature that we can read and put into practice right away. Well, here it is!

One of the nice things about this book is that the author shows you how you can tweak peer reviews to make them work for your team or organization. He give due diligence, the psychological aspects of peer reviews. Wiegers explains all the roles involved, target work products to review, how to prepare for a review, what to record, what to measure, and even how to train on peer reviews.

The book includes a useful glossary, a set of troubleshooting review problems with symptoms and possible solutions, and those very useful assets on the author's web site(...). Example assets include: peer review process description, inspection checklist, spreadsheets for code and document inspection and a set of defect checklists.

Used in the context of careful reading of this book, teams can really do a lot to improve their products and relationships. This is a book to be read by analysts, developers, architects, project leaders and managers who care about the quality and cost of software.

I have attempted over the years to get various organizations to buy into peer reviews. We have lots of evidence why these reviews are highly worthwhile, but their implementation has not been anything to write home about. There's always many reasons why organizations don't buy in or give peer reviews half-hearted support.

In my opinion, this book is an important contribution to the field. I'm sufficiently impressed that I've passed copies of the book to a few busy software development managers, software engineers and business managers so far. They've taken the time to look at it, and they find the book talks to them -- it is clear, addresses their issues, offers practical solutions which they may not have considered before, and is persuasive. I believe the book will have a postive influence in their organizations.

I hope to see copies in lots more people's bookshelves.

Excellent up to date survey of the literature, excellent survey of the many methods and analysis of their differences. A rich insight into the area of peer reviews in general, including Inspections and their variations. Practical for the industrial user. Highly recommended.

Every developer I have known has experienced the phenomena of spending an inordinate amount of time searching for a bug only to have a colleague look at the code and find it almost immediately. Study after study has indicated that the worst review process for software is self-criticism and the best is to have other coders take a good look at it. Therefore, it is logical that a formal process for developers reviewing each others code be implemented. The problem is that the former is informal, making it "off the books" and not subject to review by decision makers. Being human, developers react differently when their livelihood is potentially at stake, which can cause problems and prevent adequate reviews of the code.
Creating a stable, scalable and structured peer review system is not something that can be done by fiat or in a short time. It requires clear managerial direction that inspires confidence and builds a sense of security for both the evaluator and evaluated. Creating such an environment is the key and that is the main point of value in this book.
Wiegers lays out in great detail how to create a culture where all involved are peers in the real sense. It is absolutely necessary that everyone in the review process understand that creating quality software is the only thing that matters. Therefore, posturing, ego tripping, ego inflating, ego protection and all related activities must be suppressed. These are the most difficult tasks for professional humans to engage in, and it requires a combination of carrying a big stick to move the process as well as a soft pillow for the necessary falls from perfection. Wiegers shows you how to do this with the skill of a counselor.
In my reading of the trade press, the recent rise in the concern for computer security has led to a great deal of coverage about errors in software. Responding to this pressure, Bill Gates has sent out a public memo noting that quality is now the number one priority at Microsoft. The best way to achieve this quality is to have an effective peer review process and in this book you can learn how to do that. In the new world order of software, your very survival may be at stake, so your plan of action should include a rendezvous with this book.

I am what the authors occasionally describe as a diehard C/C++/Java programmer and have taught this style of language for over 20 years. My experience with Perl is enough to be able to program at the reasonable level and I taught a course in programming with Perl several years ago.
To the programmer accustomed to the syntax of C-like languages, the structure and idioms of Perl can be difficult to understand. Using it well is similar to learning a second spoken language, where phrases that are superficially imprecise, such as "take a hike", can be difficult to translate.
Once you learn the language, the next and most significant step is to learn to test the code so that errors are reduced and hopefully eliminated. This is the step where knowledge of the idioms is most critical, because before you can successfully debug, you must understand.
That is the level at which this book is written, if you pick it up and are not familiar with Perl, then it will do you little to no good. However, if you do know the language well enough to program in it, then the tactics described here will be very helpful in your goal of creating a functional and error-free Perl program. While that statement is more applicable to the programmers that have come to Perl from other languages, even veterans of the Perl programming wars will find points of value.

Finally, a book not only on how to use the debugger, but when and why to use the debugger. Great quick read that will add another level to your perl programming that is uncommonly used, but incredibly powerful.

This book is a must for perl programmers. Throughout the book, the authors develop 46 "Perls of Wisdom". These guidelines will help you write code with fewer bugs and help you fix bugs when they do come up - and they will! I tend to enjoy software books with a little humor to them, and this one fits the bill. Here are the highlights from the book:

Ch. 1-

Gives some background on the perl language and good tips on accessing the documentation for various parts of perl on various platforms.

Ch. 2-

Kind of a touchy/feely chapter; however, there is wisdom in it. It helps you understand how your attitudes, beliefs, and behaviors affect your code. Don't skip it.

Ch. 3-

This chapter gives you some good advice on how to avoid bugs in your program. One of these is documentation. I've found that documenting something makes you think about things you otherwise might not have.

Ch. 4-

Gives some common sources of bugs in perl including syntax, precedence, and regular expressions.

Ch. 5-

How to get formatted printouts of variables in your using Data::Dumper. This is a step up from print statements, and is easy to use.

Ch. 6-

Includes good information on testing your code and the perl modules available to assit you in test harnesses and coverage tests.

Ch. 7-

This is the gem of the book. It is a step by step guide to using the perl debugger. If reading man pages makes your head hurt, you will find this tutorial much more user friendly.

Ch. 8-

An excellent chapter on interpreting the syntax error reports that perl spits out.

Ch. 9-

The runtime exception counterpart to the previous chapter. It contains a discussion of perl exception handling vs. that of java or c++.

Ch. 10-

This chapter deals with the tough topic of code that compiles and runs, but gives the wrong answer. It gives techinques for seeing how perl interpreted your code.

Ch. 11-

This chapter gives you advice for improving performance using the Benchmark module.

Ch. 12-

A nice comparison to other languages. If you are fluent in another programming language, it is helpful to know how the it compares to perl.

The examples in this book are what make it the most useful. They show you how to use various perl modules to make your code better. Being new to the language, I wasn't even aware that some of these modules existed. Unless you are a perl master already, you should find plenty of useful information in Perl Debugged.

The ideal reader of this book would be someone who's been exposed to most of Perl and knows about packages, modules and references (the Llama/Alpaca combo, for instance), but who isn't necessarily experienced with other languages. If you are that sort of person, this should be close to the top of your Perl reading list.

There's an abundance of good material to be found here -- yes, there's an entire chapter on working the Perl debugger, but don't let the book's title fool you, it's not just about debugging. There's also advice on code style and layout, common idioms and features of Perl such as the behaviour of $_, autovivification, local, and optional parentheses.

Additionally, there are introductions to logging (in the context of debug flags), unit testing, code coverage, and error handling. Rounding off the book are chapters on benchmarking, profiling and some simple optimisation techniques (e.g. don't shell out to an external program if you can do the task in perl, use pipes and fork instead of writing to a temporary file), a chapter of tips for programmers coming to Perl from Java, shell scripting, C, C++ and Fortran. Finally there's a chapter covering debugging CGI programs.

Throughout, there's also some more philosophical (or touchy-feely) material, with exhortations to being a good citizen of the Republic of Perl and your work environment. If you're a more experienced developer, and you've read the likes of Code Complete and Refactoring, much of this is either obvious or has been given in more detail in other books, which is why I think the less experienced you are, the more you'll get out of it.

If you've been around the block a couple of times, I think you'll find that while there is a lot of ground covered, it's not particular deep. It's good to have issues like unit testing, profiling, benchmarking and logging introduced, but you'll quickly have to look elsewhere for more detailed (not to mention up-to-date) information for use in your own code. If you've read the likes of Effective Perl Programming, Perl Testing and of course, the mighty Perl Best Practices, there's not a lot left to see. However, chapter 8 presents some neat puzzlers, where a seemingly innocuous piece of code is suffering from a missing, misplaced or transposed character, and some useful tips for interpreting the syntax errors are presented.

Overall, this is nicely written in an unfussy, friendly style which assumes the reader is not a complete beginner. Ungrizzled non-veterans of Perl should consider this well worth taking a look at, especially as a companion to Perl Medic.

I'm tremendously pleased with Perl Debugged. It's half a book about Perl debugging, and half a book with more general advice, all pleasantly blended together. Peter and Ed take you on an unrivaled tour of the ups and downs of Perl debugging. It's sort of like Effective Perl Programming's "Debugging" chapter except hugely and brilliantly expanded. It's comprehensive and imaginative without being pedantic. It covers the Perl debugger (of course), it covers the different types of errors you'll encounter in Perl programs, it covers debugging strategies, and (very important) it covers the always-icky topic of debugging CGI programs. And some other topics ....

Even experienced Perl programmers will enjoy reading this book. You may think you've seen it all but I guarantee you that you haven't seen all of the examples of weirdness featured herein. It reminds me of Kon and Bal's debugging "brainteasers" in Apple's now defunct Develop magazine.

I *highly* recommend Perl Debugged to anyone at the beginning or intermediate stage in Perl programming, particularly to programmers who have less than 2-4 years of debugging experience in general. An experienced programmer, on the other hand, will want to buy a copy (copies?) to browse and then hand to his junior co-worker(s) with stern instructions to "read first, code later." (Reminds me of the time I bought Bugs in Writing.)

Apparently the authors have a way with words. The prose is unusually good--not just by the standards of technical books--colorful, extremely clear, and enjoyable to read. (The illustrations by Peter's sister-in-law are great.) About the only thing that "bugs" me is the authors' use of "semantical" in preference to "semantic."

A must-have for anybody working 6.5, 7, and 2000 MSSQL. Very well scoped-out in its depth of coverage. Explains aspects of the RDBMS that will be required knowledge for any DBA coming from a non-MSSQL background. Covers differences from SQL 6.5 through SQL 2000. Sure, there is a lot that is not in here, but it is impressive how much is covered (from basics of physical design, to ACID transactions, to replication-related stored procedures). The smaller form factor makes it easy to carry around, which is an absolute bonus. The material in this book (and the "for Experienced DBAs" book in the Osborne series) must be distilled from a vast amount of real-world experience-- sadly, not out there yet for SQL 2005.

This is an essential book for anyone who works with, or is curious about SQL. This book covers all aspects of SQL from installation to Back Up and restoration scenarios. Covering all flavors of SQL from version 6.5 to current this book is compact and contains an unbelievable amount of knowledge into less than 500 Pages. I could not get over how detailed and clear this book is. After having read many other books on these topics it was truly refreshing to read a technical book that succinctly touched on all aspects of administrating a SQL box.

It was unfortunate to discover that some of what I had thought was good techniques were proved to be flawed, and when after implementing the suggestions in this book I was thrilled to see an increase in efficiency of Data Calls, and Network Load.

It is clear to see that the authors of this book have carefully and clearly defined all that could be needed in a small easy to reference book. This book is a necessity for any desk where SQL Server is running. It is a small cost to pay for so much knowledge, well worth every cent.

If there is one book that you are considering for SQL Server Administration, this is the one to buy. Covering all the major topics of administration, this book goes above and beyond other SQL Server books for several reasons. Not only does it live up to the promise of an easy to find guide for everyday tasks, it offers the ability to read up quickly on several advanced topics and gain knowledge rapidly. Taken into consideration, are the three latest versions; SQL Server 2000, 7.0 and 6.5, detailing out differences between versions where applicable. Everything is explained clearly. The authors have done an excellent job of providing a wealth of information in short and concise content. It is very refreshing to see a book that was obviously written to be as brief possible without skimping on important details...clearly no fluff here!!!! This has two benefits to the reader, 1; information is easy to find, no time is wasted reading through frivolous content, 2; the cost is lower than those 1,000 page volumes that contain less valuable information. Hopefully this is the start of a new trend in technical books.

In just a few minutes after flipping through, and reading up on backups, I realized that I'm not backing up my production data properly, and can substantially decrease data loss risk by backing up my transaction logs regularly with the data. Also, some security concepts I had a bit of difficulty fully comprehending became clear to me as well.

Reading through this book, it is obvious the authors have extensive experience with SQL Server, as this book has many insider tips that only experts would know through practice. It is also apparent that the authors worked well together as this book reads as though one person wrote it. Definitely a must buy and well worth the cost. I wish I could give this book more than 5 stars.

This was a great read! Very concise and packed with useful information that no DBA should be without. Whether you are a SQL specialist already or new to SQL altogether, this book is packed with great information in one, small and manageable format and an easy read. Kudos to Steve and Damir!

Even though I have read only the first two chapters so far, I can still say this book is definately worth owning. The amount of information in the introductory chapters alone make this book a worthwhile purchase, especially given its relatively low price. The author's writing style is conversational without being condescending or idiotically simplistic. Reading the book, I feel I have an experienced friend giving me many worthwhile tips and suggestions. I really think you will find this book to be a worthwhile purchase.

Although this book is over 10 years old, it could have been written this year. The concepts are still relevant.
The author concludes that there are 2 primary reasons to undertake a metrics program for software development -- 1) tracking progress and 2) identifying improvements. The book is divided into 2 parts, with the first part discussing project management metrics and the second part metrics to improve your software development processes. I particularly liked the goal/question/metric approach to validate the metrics you are collecting. The text is loaded with examples from the author's experience at HP. There are several charts and diagrams. This is not an academic read, but as the title says -- practical. The author also covers people issues, such as selling your metrics program to management and staff. It is a quick read and a very useful reference book.

This is Grady's first book and it sets the tone for his later two books, Successful Software Process Improvement and Software Metrics: Establishing a Company-wide Program. What makes this book so important is that it is one of the first to integrate software metrics with project management metrics.

What I particularly like about this book includes:

(1) Complete view of metrics that matter, and the chronicle of how these metrics evolved in a large company (Hewlett-Packard).
(2) Recognition that any software metrics initiative extends beyond the project that delivers the software - Grady examines post-production metrics and ties them back to not only the development life cycle, but the product life cycle as well. Ten years after this book was published there are still large organizations that are struggling with doing this, yet Grady's book provides a clear roadmap to achieving this elusive goal.
(3) Continuous improvement is the central theme in this book. Grady does not stop with collecting and analyzing metrics, but how to effectively employ them to spot improvement opportunities and develop a strategy to effect those improvements.

The book is written as both a story of how a successful metrics program evolved, complete with anecdotes that will prove helpful, and as a collection of data that illustrates what is and is not important to a comprehensive metrics program.

Among all of Grady's books I like this one the best; however, I recommend that his other two also be carefully read if software process improvement is your goal. He has much to say and backs it up with data and a chronicle of his experiences from real projects.

I bought this book about 5 years ago after getting certified as a project manager. This book give me a holistic view of how to intepret data collected from tracking the entire software lifecycle and manage and integrate best practices into a software business.

The author's vast experience in HP helps to provide good assurance that his concepts used were tried and robustly tested. Therefore, software failures, internal flags and customer feedbacks can immediately give you a fairly visible prognosis to the robustness of a release and flashes early warning signs of how you should manage that product to reduce damage to your business, etc.. Practical for technical managers having to manage the business operations.

Whether you're a fledgling company trying to design quality software with no guidelines to go by or a well-developed organization with processes in place, this book offers up many ways that you can improve your software quality.

I was introduced to Mr. Grady's work when I borrowed a copy of Software Metrics: Establishing a Company-Wide Program. Where that book interwove a storyline into metrics and how they support mature process improvement, this book is more like a desk reference. Mr. Grady has divided this book into two parts: tactical metrics, which are project-oriented, and strategic metrics which address process improvement.

The first part starts with a collection of practical rules of thumb for software managers. This collection of heuristics covers every phase of the development life cycle and are backed up with data gathered during 125 software projects at Hewlett-Packard. An example of one of these rules of thumb is that you will find 1 defect after software has been released into production for every 10 defects caught during testing. This, of course, is purely empirical, but is an interesting rule that I mentally filed away. Some highlights of the first part are: a good introduction to the goal-question-metric approach to determining what to measure based on your objectives, and a focus on project goals of maximizing customer satisfaction while minimizing project schedule and costs, and product defects. This is followed by chapters that address each of these goals. One of the best chapters in the first part of this book is work analysis. While I am more focused on the service delivery side of metrics (after the project has produced something that has been released into production), some of the metrics were very valuable to me - especially the ones that revolved around testing and QA.

Part 2 is squarely in my domain - production and application support, and service delivery. The best chapter, Dissecting Software Failures, was one of the most insightful descriptions of the defect life cycle I have ever read. It fully addresses defect data collection and analysis, and how to use this data to effect process and product improvement. Even better is the chapter on investing in process improvement. Here Mr. Grady gives a workable approach to using the defect data to developing a business case for process improvement. He guides you through developing a plan, selecting from among an array of solutions, and case studies.

This book is a quick read. It's main value lies in the many tables and facts provided on nearly every page. I use it as a desk reference, especially the appendices that summarize defect origins, types and modes, and metrics definitions. It spans both project and production metrics, and is as valuable to project managers as it is to application support professionals.

This book is outstanding. Not only does it guide you through on building online applications but it also drags you through the Zend PHP framework. I would recommend this book to anyone is going down the path of becoming a fantastic PHP developer. It is a good resource.

This is an excellent book and I have enjoyed reading it over the past day. For someone trying to piece together the various technologies like Auth, ACL, Config, Logging and Session it's a great resource for the first several chapters, going into detail about the configuration and setup of this simple environment without any of that padding and guff that a lot of other authors include. The book doesn't treat you like an idiot, which I certainly appreciated.

The only issue I would raise is that the Author has used his own classes for database Table access instead of employing the frameworks standard Zend_Db_Table and Zend_Db_Table_Row bases. This means that anyone wanting to adhere closely to the Zend Framework (for corporate reasons) will have to reverse engineer the approaches used. An odd choice for a book almost entirely based on the Zend Framework.

I have been working with PHP for several years now yet the first part of this book had me pulling my hair out (whats left of it). Setting up the environment is tricky and it probably would of helped me if I had a stronger background in OO programming. With that said, this is a good book and I would recommend it to any intermediate level PHP developer.

This book is easily the most useful and well-written PHP book I've ever read. It runs you through the complete development of a web application using PHP5, Zend Framework, Smarty, Ajax (via Prototype and Scriptaculous). It also includes a useful section on Deployment and Maintenance, which includes error handling/logging/reporting, database backup and restoration, and application deployment (dev, staging, production).

The book has a heavy focus on the Zend Framework, and does a better job of explaining (and using) the intricacies of it then any other book or online resources I've come across.

I would highly recommend this book to anyone looking to use PHP5 with the Zend Framework.

I won't repeat what the others have said about how great this book is other than to say I agree with them. In addition, as what follows will prove, I am relatively new to PHP. What follows below is answers to two hurdles that I had troubles with 'getting going' - the first having to do with php configuration, and the second concerning Smarty. I simply hope, if you are new like me, the following will save you some head scratching.

First - php settings... While the author does go to extraordinary length to try to spell things out for the reader, one gotcha centers around your 'include_path' settings. The author failed to mention that his default include_path includes a '../include' entry. Without that, any attempt to run the application will report an error with the Zend Loader. A work-around is to simply use ini_set to add '../include' to the index.php file.

Second - Smarty. Installation of Smarty for this project is demonstrated for a unix environment. Being ignorant of that environment, I missed the fact that the author was copying 'Smarty/libs/smarty.class.php' and the rest to 'Smarty/smarty.class.php', etc... In that I already had Smarty installed in php5/include/Smarty/libs, I missed the elimination of the libs folder. So, if you are going to buy this book AND already have Smarty installed, you can do what I did... Go to line 11 in Templater.php to change the require_once to point to where your installation is. In my case, 'Smarty/libs/smarty.class.php'.

This particular book provides the reader with a comprehensive view of PHP development. I was pleased with the vast amount of topics covered. This book is a very useful tool for developers.

This is a great book in that the author provides comprehensive coverage of a complicated subject, and does it in clear, concise and understandable language. The book should be a promary resource for programmers. I look forward to more contributions from this author.

'Pro PHP XML and Web Services' by Robert Richards is a great book to help you learn your way around these technologies. Packing in over 900+ pages, this book gives a broad overview of the subject matter which is outlined here:

01. Introduction to XML and Web Services
02. XML Structure
03. Validation
04. XPath, XPointer, XInclude
05. PHP and XML
06. Document Object Model
07. SimpleXML
08. Simple API for XML
09. XMLReader
10. Extensible Stylesheet Language Transformations
11. Effective and Efficient Processing
12. XML Security
13. PEAR and XML
14. Content Syndication: RSS and Atom
15. Web Distributed Data Exchange
16. XML-RPC
17. Representational State Transfer
18. SOAP
19. Universal Description, Discovery, and Integration (UDDI)
20. PEAR and Web Services
21. Other XML Technologies and Extensions

If you need a book that dives into the XML technology and doesn't look back, this is a nice pickup that gets the job done. Lots of other Apress books I feel are a bit too long, but this book at over 900 pages I have less complaints about. It's solidly written and a nice companion book to have on your bookshelf for anyone that programs with XML.

**** RECOMMENDED

This book is amazingly well written. The content is organized in an intuitive and logical fashion. The author explains base concepts and progresses into advanced topics, providing consistent depth of coverage along the way. The author's writing and concise examples get the message across on the first reading - unlike some texts that require multiple passes. It's also noteworthy that the Technical Reviewers, Christian Stocker and Adam Trachtenberg, are renowned PHP experts and authors. If you plan to study or work with PHP and XML, this book is a MUST HAVE.

This is first and foremost an XML reference. The author takes the reader through over 100 pages XML background in the first three chapters, then an overview of a few utilities like XPath and XPointer before he touches on PHP. Having provided some grounding in the basics, he then proceeds to develop the use of XML in PHP from the basic topics of DOM (Document Object Model) and XSLT (Extensible Stylesheet Language Transformations) to the more advanced topics of SOAP (Simple Object Access Protocol) and web services.

Along the way Richards introduces the reader to utility classes like SimpleXML, SAX (Simple API for XML), XMLReader. He also touches on PEAR (PHP Extension and Application Repository) utility classes and topics like security, RSS (Really Simple Syndication) and UDDI (Universal Description, Discovery and Integration). The author's examples are reasonably concise and readable; making the necessary points without getting carried away.

The bottom line is that this is a highly effective reference (that means fairly comprehensive, but dry reading; I read cover to cover, but it was relatively tedious) on XML and its varied uses in association with PHP. This is not a book for the newcomer to programming, nor is it a cookbook for examples for the casual programmer/web developer, although the author does provide PEAR examples for connecting with major web services like Amazon, Google and Yahoo (among others). My suggestion for readers is to review what you need of the first 11-12 chapters to ensure a firm grounding in XML, and then hop to the chapters specific to the problem being faced.
P-)

I'm somewhat bewildered as to why such an important technology (WF) has produced an astounding dearth of good books on the subject. Thankfully, we have Mr. Bukovics' offering which would be a stand-out even if the book marketplace was full of options.

With this newer version of his book (yes, I did purchase the 3.0 version), we get very important information on (1) the two new additions to WF offered in 3.5 (2) WCF-WF integration and (3) advanced topics on Services. These topics smooth out the rough edges of WF 3.0. Comprehensive discussions of these topics, and others, are not readily available from any other source.

Therefore, this newer version of the book is a must-have; even for those, like myself, who purchased his first version.

I found this book to be an excellent introduction into Windows Workflow. I am very impressed with the author's detailed instruction yet easy to follow style. All the concepts are backed up with relevant examples. Very well prepared and executed piece of work. I have several other topics I would like this author to explore.

Last Friday, I passed the WF-examination with 900 points!

I'm glad that I bought this book. WF is a huge framework
and this book does a good job in explaining every aspect of WF.
This book offers lots of examples which are documented very well.
At times, it is difficult not to get lost in the details.

Following chapters of "Pro WF" were especially helpful:

9: State Machine
11: Workflow Rules
14: Dynamic Workflow Updates
15: Workflow Tracking
19 Hosting the designer

I used this book to look up the parts of WF which
were poorly documented by its creator.

This book is the book to have if you are going to get into Windows Workflow Foundation. There are no other books on WF out on the market that compare to the broad view and depth of this book.

I own the first version of the book and was reluctant to buy this version because there was not too much changing in .NET 3.5. I am glad I did. I like having the most current information on a technology I am working on at my finger tips. And not in electronic format. I have no idea how people can code all day and then read eBooks all night. Plus my other copy was pretty scribbled up with notes.

This version contain two new chapters. One titled Advanced Custom Activities, and the other titled Workflow Service and WCF Integration. Both new chapters contain a lot of valuable in-depth information.

The code samples are very well organized and add a lot of value to this book. However, as the author points out in the beginning of the book, he wrote it to be readable on the beach. Meaning the code is in the book, and you don't have to have it open on a computer to read the book.

The examples are simple yet he uses them to take you down into the weeds.

I highly recommend this book to anyone looking to get into WF. It is a great read!!!!

Absolutely the best book on WWF out today. So much more content than the others that there's absolutely no reason to consider a different workflow book. Workflowservicehost? Writing your own persistence or tracking services? Rehosting the designer? All here.