5 comments about Real World Web Services.

1. 
   I was very disappointed with this book. I was hoping for something that would go into detail of the various Web Services solutions offered by Amazon, Google, etc. Instead it is just another Java book filled with mostly code (is it a sin to use prose anymore?) and lacking in any kind of detailed discussion at all. It basically talks about very specific problems, offers some code, then moves on to another specific solution. I found it completely uninteresting.
   
   The only person I would suggest this book for is someone who wants code to Cut and Paste without really understanding what they are doing. And good luck to them ;-)



2. Since Domino 7 will start to incorporate web services more readily into application development, I figured it was time to start getting a little more versed on the subject. To that end, I got a copy of Real World Web Services by Will Iverson (O'Reilly). Coupled with a detailed tutorial/reference manual, this is a really good selection.
   
   Chapter List: Web Service Evolution; Foundations of Web Services; Development Platform; Project 1: Competitive Analysis; Project 2: Auctions and Shipping; Project 3: Billing and Faxing; Project 4: Syndicated Search; Project 5: News Aggregator; Project 6: Audio CD Catalog; Project 7: Hot News Sheet; Project 8: Automatic Daily Discussions; Future Web Service Directions; Index
   
   While the book is smallish (206 pages), there's a lot of value packed in it. Iverson takes you from the beginning of simple HTTP request and responses, through data scrapping, into RPC technology, and then finally into web services. The overview really helps you to understand how we got to where we are. He explains how to set up a simple test development environment as well as what you'll need, and then it's directly into the example projects. Here's where the book shines. These projects connect to live data sources such as Amazon, Google, FedEx, and eBay, so you're not dealing with simple examples that don't translate to the real world. Each of the projects are applications that you could easily see yourself using on a daily basis, either exactly as written or with some moderate tweaking. And since you're learning the mechanics of connecting with that service, it's easy to extrapolate the information into the areas that might interest you more.
   
   If you have no background in SOAP or WSDL, I'd recommend you get a foundational book that has a good tutorial and reference material. You won't get it from this book, nor should you expect to. It's not his intended purpose for the book. But this is the book that will help you go from theoretical to practical, and that's worth its weight in gold.
   
   Very good book if you're looking to take the next step in your web services development...



3. Real World Web Services by Will Iverson is more of a "here's an example of something someone might want to do" type book. The book contains a lot of Java source code to connect to some web services from big names like eBay, Google, and FedEx. Whether these examples are useful or whether the reader can glean out other uses of the code depends on the skill the reader has in programming. The book also goes over some basic concepts and tools the reader can use to get started with web services. All in all, Real World Web Services will give you a taste of what web services are, yet leaves out the low level details of how it works.



4. I thought that this is a book very specific to certain aspects of web services and examples are overly detailed...I dont expect the book to be compiled mostly with elaborative examples.



5. While the samples are straight-forward, to the point and easy to follow, the book doesn't really provide enough under-the-cover view. Generally speaking, if you are looking for some insight into WS used with Google, eBay, FedEx, etc. this is a wonderful book.
   
   If you are looking into information for things such as "using Axis for real-world WS", this just scratches the surface.
   
   However...
   
   This book provided a wonderful set of quick, easy test setups for use against generic WS implementations (such as those provided in B2Bi software) for comparative results. The peer into the provider-specific details made it wonderful to have provide expected output and check the diffs on files.
   
   Recommended for QA, unit testing, automated testing, etc.
   Recommended for those interested in quick samples but not in a core understanding of the technologies.

1 comments about Foundation Flash Applications for Mobile Devices (Foundation).

1. This book will take a flash developer a long way towards publishing applications on mobile phones. I didn't see anything on utilizing web services (something that is easy to do with flash lite 2.x) nor how to create .cab files (which was why I actually bought the book), but it covers just about everything else to a good level of working depth.
   
   I wouldn't suggest this book to someone without any flash actionscript experience (or at least some object oriented programming experience) but you don't have to be a comp. sci. major either. Well written and not too witty (some programmer books can read like geek joke books) this book approaches the flash mobile development process from a practical hands on stance which works well with those who like to get their hands dirty while learning.
   
   Strongly recommended reading for next gen phone app development in flash.
   
   ~Gabriel

5 comments about The ACE Programmer's Guide: Practical Design Patterns for Network and Systems Programming.

1. This book is yet another great example of how the ACE framework can save you a lifetime of development. Within this book is the knowledge and experience to excell your applications to the next level and become more productive then ever. If your code base deals with networking or even if you just need to have cross platform compatibility then this book is a must have to teach you the ways of ACE.



2. A good book for you to get into the world of ACE.
   A good book for newer of ACE.
   
   During the first 2 month I am using ACE, this book give me great help. But later I found a little issue of the example code in section 7.6.3 which will cause spin-lock when the output socket is blocked/flow-controlled.
   
   I post my comments to this issue below, hoping you can avoid this mistake.
   
   You know, so many people are using this book as guide for ACE, and may copy the example code ( just as me ) in their work with ACE.
   
   Section 7.6.3 ACE_Connector
   int Client::handle_output (ACE_HANDLE)
   {
   ACE_Message_Block *mb;
   ACE_Time_Value nowait (ACE_OS::gettimeofday ());
   while (-1 != this->getq (mb, &nowait))
   {
   ssize_t send_cnt =
   this->peer ().send (mb->rd_ptr (), mb->length ());
   if (send_cnt == -1)
   ACE_ERROR ((LM_ERROR,
   ACE_TEXT ("(%P|%t) %p\n"),
   ACE_TEXT ("send")));
   else
   mb->rd_ptr (static_cast (send_cnt));
   if (mb->length () > 0)
   {
   // Here will cause message_queue notify reactor
   // And get into handle_output again immediately
   // which cause spin-lock
   this->ungetq (mb);
   break;
   }
   mb->release ();
   }
   if (this->msg_queue ()->is_empty ())
   this->reactor ()->cancel_wakeup
   (this, ACE_Event_Handler::WRITE_MASK);
   else
   this->reactor ()->schedule_wakeup
   (this, ACE_Event_Handler::WRITE_MASK);
   return 0;
   }



3. ACE is great, no doubt. This book is not. If I had been scanning ACE code for years and needed a reference, this book might be great, but like a kid in a foreign land, this book only confused me more than it helped. Here's why:
   
   READS LIKE AN UNABRIDGED NOVEL. In order to understand each example, you must read the book from cover to cover. There is so much detail in ACE that there are almost no "trivial examples" and a thorough understanding is required. What if I'm not writing a high-performance server application? What if I want to work with small examples and work my way up incrementally? This book makes it difficult to do that.
   
   EXAMPLE CODE IS CHOPPY. Each example is presented in such a way that code is provided piecemeal, along with paragraphs of explanation. This is ok, but it is very difficult to piece the examples together and write code. Also, it's not listed in the book, but the examples are online, here:
   
   http://www.cs.wustl.edu/~schmidt/ACE_wrappers/examples/APG/
   
   This link is not in the book.
   
   THIS BOOK JUMPS EVERYWHERE. For instance, check out section 7.5, Timers. We're given a quick intro on Timers while we're kneed deep in talking about the omniscient Reactor that ACE provides. Now, section 8.5 talks briefly about timers and to reference further documentation in reference to Reactor/Proactor, which is unhelpful and unnecessary. Finally, section 10 gives great detail into using Timers. Chapter 7 should have been called Reactor.
   
   My biggest interest was writing a client/server application in ACE. Chapter 6 started with a terrible example of socket communication, saying that Chapter 7 is a better pattern for the client/server. By the time I got done with Chapter 7, there was so much rambling of hypothetical situations that I completely forgot what I was trying to learn. The big picture is often lost.
   
   NO API REFERENCE. Maybe it is not appropriate to put in an ACE API reference in here. I think it should be put in as an appendix. When examples are presented, the new data types come out of nowhere. What is an ACE_Time_Value, specifically? What other parameters can it provide? ACE Doxygen documents can't provide enough detail and neither can this book.
   
   What I would love to see in a second edition:
   - More descriptions of the standard types.
   - Description of ACE_TMain and other OS functions.
   - A better mapping of types to GOF patterns and better UML.
   - An API reference, even if it is small
   - Table mapping Unix/Windows/VxWorks functions to ACE functions.
   - A more readible text. The code blocks could be encapsulated in gray to take it out of the text somewhat.
   
   Also, most of the other reviews on this book shown above talk about how great ACE is for development, and I agree. However, isn't this the section where we are supposed to be commenting on the BOOK (APG) and not the TECHNOLOGY? These reviews hardly talk about the book at all!
   
   Huston, et al, I encourage you to come out with a second edition. I still want to learn about ACE, but I need a more organized reference and clearer examples.



4. The ACE libraries are useful for developing cross-platform code, providing functionality such as loggers, configuration handling, communications, threading etc. Where ACE itself falls down is that the documentation supplied does not provide enough information about how best to use it and what it does under the covers. You might think that you don't need to know about what happens under the covers and for a simple application that could be true, but when you go multi-threaded and discover that in parts of the ACE library the code checks which thread you are calling from and behaves differently depending on what it finds, then this is something you need to know. Unfortunately the documentation doesn't give that level of information and neither does this book. Life-times and ownership of objects are areas likely to cause issues too - this book mentions an example of that relating to the logger, but there are others too. A library that decides ownership based on whether you pass a pointer to a method or a reference to that method is one where you want/need a good reference book, not just an introductory text.
   
   "The ACE Programmer's Guide" is a reasonable introduction to ACE, but it is certainly not a reference (despite the quote on the back cover calling it exactly that). Unfortunately, when using ACE the old adage about a little bit of knowledge is true. You can work from the documentation, this book and the books by Schmidt, and if writing reasonably complex systems you will still hit issues using certain parts of ACE resulting in you stepping through the library code to find out what is going on. I've therefore only given this book 3 stars. It's a reasonable introduction, but if you are doing anything significant with ACE, particularly if multi-threaded, you are likely to end up wishing there was a complete reference work (no, the HTML help is not thorough enough either) rather than just introductory texts and overviews.



5. 
   This book provides comprehensive tutorial for networked applications. ACE was my popular framework before Boost.Asio framework. Even though ACE has little dated approach, it is still the best framework for multi platform distributed application development and this book provides very valuable contributions to people needing to develop this type of applications.

5 comments about Why Software Sucks...and What You Can Do About It.

1. Although targeted towards explaining to ordinary people why computer software is hard to use, Why Software Sucks...and What You Can Do About It by David S. Platt is something that software developers would do well to read and understand how we blow it on a regular basis. Five words... The. User. Is. Not. You.
   
   Contents: Who're You Calling A Dummy?; Tangled In The Web; Keep Me Safe; Who The Heck Are You?; Who're You Looking At?; Ten Thousand Geeks, Crazed On Jolt Cola; Who Are These Crazy B@st@ards Anyway?; Microsoft - Can't Live With 'em And Can't Live Without 'em; Doing Something About It; Epilogue; About The Author
   
   Platt takes a look at software and web sites from the perspective of the user, someone who's just trying to get something done. And his overwhelming conclusion is... software sucks. In large part, this is because the computer geeks who design the software are completely mistaken as to who is the target user. They design something that works for themselves, thinking that everyone thinks and reacts as they do. They think that complexity is cool, and whiz-bang features should be appreciated in and of themselves. The reality is that the basic user does *not* think like a computer geek, and they get tired of sites that make no sense or make them work (or rework) for the reward at the end. Using good/bad site contrasts such as Google (guesses the language to use based on the IP address/location) vs. UPS (ask for your country EVERY SINGLE TIME before you can do anything), it becomes quickly apparent when a site's been designed by computer geeks rather than design/interface specialists who are able to think like a user. Armed with this book, a person can start to understand why things are harder than they need to be, and what steps can be taken to make your displeasure known. It may not change anything, but being silent isn't a viable option either.
   
   Now for computer software designers like myself, this book can be humbling. I think I've done a few of the things he condemns, and I found myself rethinking (*and* changing) a few of my website project features after reading this. I realized I was forcing the user to understand my world before they could do something. And if I couldn't explain it well, how did I expect them to grasp it? But aside from being a useful and extremely funny book, there's one chapter that was a joy to read. Ten Thousand Geeks explains the concept of software conferences and what they're like. Furthermore, he talks about what it's like to be a speaker at one; the joys, trials, and adrenaline rushes that come with being in front of people and mingling with your speaker peers afterwards. It was like reading my own story, and it was incredibly accurate. I would love to print out about five paragraphs of that chapter and post it with the title "This Is Why We Speak At Conferences." That chapter was worth the price of the book by itself...
   
   I wouldn't hesitate to recommend this book to someone on a number of levels and for a number of reasons... Well worth the time spent reading it.



2. This book was really funny and provided good insights into usability design principles for software.



3. An enjoyable read and I'm now encouraged to complain about all that annoys me on the computer, particularly bad websites. David's website, suckbusters, looks all good from the screenshot in the book, but I can never access it, despite trying several times from different computers. Waiting over 5 minutes while Explorer sucks power from my machine trying to access it really does suck.



4. I enjoyed reading this book immensely. There's nothing better than realizing you're not alone when trying to make sense out of the non-sense of computer software. However, I wanted more instructions on HOW to get around these difficulties and get on with my life. There just weren't enough of these examples. Also, I could've done without the liberal "preaching."



5. Most of Platt's criticisms are spot on, but page 87 contains a story about measuring the height of a building by using a barometer in creative ways. Platt claims this as a personal anecdote which happened to him, but the exact story has been around for decades. I remember my high-school physics professor telling me the same story, and Snopes has documented it back to 1958, attributed to a different author:
   
   http://www.snopes.com/college/exam/barometer.asp
   
   It seems highly unlikely that the exact events happened to Platt, too, in the exact order... Unless Platt was somehow the original author's student? I'd like to be proven wrong, but this looks sketchy.

5 comments about The Definitive Guide to Interwoven TeamSite (Definitive Guides).

1. First let me say that I have never seen a formalized methodology such as the Rational Unified Process wrapped into a book on Content Management, let alone such a title demonstrate how to incorporate those practices into CMS work. I found this to be a novel concept and one that I feel will add a lot of value to my future projects. The authors share their expertise, not only with technical TeamSite implementations details, but also with some softer skills related to everyday IT/CMS life ( i.e., project management, requirements management, project deployment, and marketing). The book is broken up logically enough into sections which map to the specific RUP phase being discussed. Detailed coverage is given to TeamSite 6.5, with some additional coverage of TeamSite 6.7. Most of the Interwoven products are discussed, explaining why certain products could be selected, what their purpose is, and the value that they may add to an implementation. The authors also provide coverage of how to define a taxonomy in MetaTagger, using OpenDeploy and DataDeploy, using LiveSite, TeamSite Front Office, TeamSite Search, as well as extremely handy FormAPI and FormsPublisher references. Thank you and well done!



2. It is not easy to give an overview of the TeamSite product line in 537 pages, but Hastings and McNeal do an admirable job of covering project methodology, an overview of the entire TeamSite product line, and a deep dive into TeamSite templating and workflow.
   
   This is certainly not everything there is to know. TeamSite is an almost infinitely configurable product, but you will not find as good an overview and introduction to TeamSite as this book. And that is not just because this is the only book on TeamSite out there; you won't find this kind of overview in Interwoven's manuals or Training materials either.
   
   I highly recommend this book now, but if it comes out in an expanded second edition for a little less money it will be a no brainer.



3. This book leaves out allot. Good luck trying to get some of the examples to work. Many of the files are missing. It seems like the main objective of the book is to make a dollar since there are not allot of books on the topic outside of the Interwoven community.
   
   An example of the poor quality of the book is in Chapter 16. The book talks about navigation and says it will go into more detail in chapter 15. However you are already in Chapter 16 and 15 is actually about workflows.
   
   The reality is if you are implementing Interwoven CMS you need to buck up and take their developers series class. If you already know how to program you will be fine. If you try to use this book as a resources it is pretty much worthless.
   
   Save your money and join the devnet community it's free and way more helpful.



4. The book is fairly helpful, and did bring to light a few new ways of thinking about interwoven. However, many of the examples seem to be incomplete and only scratch the surface, leaving the reader needing/wanting more information.



5. You have to understand first that I "grew up" in content management systems with "Joomla!," which is an open-source, fully-integrated application that gives you one pilot seat from which to build your web site. (www.joomla.org) With Joomla!, you create your information architecture, add in components, and pick out a template, and you have a fully-functioning web site in no time. You don't have the versioning and audit trails of other cms tools, but you have a whiz-bang web site that's easy to manage and incredibly extensible. Now faced with implementing TeamSite, I just can't believe that anyone would choose this behemoth over Joomla!. Nevertheless, the question that NO ONE can answer for me, not Interwoven and certainly not the "definitive guide," is "How do you actually build a web site with it?" It seems that Interwoven and this book assume that you have teams of programmers who have always built all their sites one file at a time. They start from scratch and script their little hearts out. This book may explain the installation and general templating procedures of TeamSite, but it doesn't explain the general approach to building a web site with it. There are many, many gaps, and it's not very helpful for non-programmers or first-time CMS builders. So, if you're buying this book as a pre-purchase decision, I'd suggest looking at Joomla!--chances are, you'll be happier with it, and it's free.

3 comments about Foundations of PEAR: Rapid PHP Development (Foundations).

1. The first thing I should address with Foundations of PEAR (PHP Extensions and Applications Repository) is the appropriate audience for this book. Since it is a book on PHP extensions and applications repositories the authors assume that the reader already has a basic understanding of PHP5. If you already know the rules of basic syntax, using variables, creating objects and similar items then you will probably be interested in looking at this book.
   
   After a brief introduction to PEAR including how to install and configure it the rest of the book is a compendium of PEAR packages, their content, and how to use them. For each package it includes information on common usages, related packages, dependencies, the API, and examples. The book is broadly divided into ten topical sections - Authentication, Utilities and Tools, Dates and Numbers, HTML, Images and Text, Database, Files and Formats, HTTP, XML, and Mail. Each of these sections contains several packages that fall under that category.
   
   The index is complete and detailed and makes the book a great resource. A solid reference book that is sure to be on the shelf of most PHP5 programmers Foundations of PEAR is highly recommended.



2. This book is lacking in both breadth and depth. Here is an example of each:
   
   1. In the XML section, only three of the 13 classes in the XML package are discussed. In fact, only ten of the nearly three dozen PEAR packages are covered.
   
   2. In the discussion of the File class, the third parameter is the file lock mode. The text reads, "The type of file lock to use," but fails to explain what those lock modes are.
   
   Considering this, I consider the book overpriced and of value only to the beginner who is having difficulty getting started with PEAR. If this is the your situation, I recommend looking for a used copy.



3. After spending about a half a day with this book and working on trying to get a simple exercise in the book to work on mime email, I've just about given up. This book reads like a dictionary giving very little explaination and leaving you to the Internet to find the answers.
   
   The book does have a lot of information, but if the examples don't work, then you're stuck. A little help from the authors on how to overcome common problems would have been great. Instead, it just goes on to the next definition of functions.
   
   I guess it's worth the $6 in the used category, but not $45 which is list.

5 comments about C# for Java Developers (Pro-Developer).

1. i could have sworn this book was from microsoft press. This book did a *great* job of being unbiased, and presented "just the facts". It did so in such a clear manner as well, straightforwardly laying out the similarities and differences between java and C#, and each's strengths and weaknesses (briefly).

   definitely recommended!




2. This was truely an amazing book, I've read many .NET books, all of which assume zero knowledge of programming, or very little. So when I skipped the first few chapters, or skipped them (Since I've been a Java Developer for several years), I missed valuable differences between Java and .NET.

   Be sure you do know your stuff in Java, or else this book will seem over your head. This is not a beginners book. But if you're a Java developer, or have similar programming experience, this book is 100% for you.

   My only quirk with this book, is that at times, it's more of a refrence/comparison, over how to use several key .NET features. And it seemed to jump around a little. So actually I'd probably rate this book a 4.75...but rounding up gives us a 5, which it pretty much deserves.

   I highly recomend this book out there for anyone who is NOT a beginner programmer, or comes from a Java background. This book is a MUST read for you.




3. This books hits the spot for java developers, the intended audience. A one page description on delegates, for example, has all the information you need to get started with delegates. The Oreilly book has a long winded chapter on it and the essence was lost in the obtuse example provided.



4. After about 5 years as a java developer, I took a new job as a .NET / C# developer. This book was a great starting point for me. Going from java to c# is a relatively easy transition, but this book makes it much easier and quicker. The book compares the two languages and highlights the differences which made it easier for me to pick up. I'm not a person who reads many books, for work or pleasure, so I don't have much to compare it with. But out of the 10 or so books in my work library, this is the second best book I've used. (The best I own is Effective Java. I'd really like to get one like that for c#.)



5. As an experienced Java developer who was "forced" to move into the C# and .NET world, I turned to this book to help me make that transition. I am very glad I did so. This book provided nearly all of the background I needed for that transition, and it still serves as my primary C# reference a year later. (By the way, working in the C# and .NET world is not as bad as I feared it would be.)
   
   If you are accustomed to Java and new to the world of .NET and Microsoft books in general, you will find the majority of these books to be written for a less sophisticated audience than you are used to. My advice is to be very cautious what you spend your money on, as many of the books about Microsoft programming topics are not worth the investment.
   
   This book, however, is very much worth the money you will spend on it.

5 comments about VHDL for Programmable Logic.

1. I haven't finished the book yet but upon finding so many error in the first few chapters I wrote to the author/company with the email address that they provide in the front of the book to see if there is a list of corrects or something for the book. They have completely ignored my emails... for example, in describing a PLD achitecture they describe it WRONG - you can see in the picture they provided it doesn't agree with what they wrote. So basically I'd give you a warning that the care that should have been taken might not have been.



2. No question, this book is good for EE student, it helped me a lot during college years. But when it comes to engineers, this book has too much theory or I should said it did not cover the real digital world. You only have an idea what is VHDL and some basics. You don't know what kind of programs, machines, brands and other things in the VHDL field. You can't have an idea what or how are the VHDL engineers doing today. If you are a gradute, try some other books that explain in the engineer way not a undergrad. way.



3. This book is the best book for VHDL hardware design. The author describes the hardware implementation of the VHDL design.



4. This is an excellent book to get you started on VHDL design for PLD or FPGA. It is clear and practical.



5. This book is an excellent introduction to VHDL. It covers a wide array of basic commands as well as their benefits and short-comings. It also covers more powerful commands which are good for large projects or creating reusable pieces. It also comes with a rather old program and examples that go along with the text of the book. Definitely a must have for anyone just getting into VHDL.

5 comments about How to Do Everything with Microsoft Office InfoPath 2003 (How to Do Everything).

1. I have found nothing in this book that isn't available for free online or in downloads from Microsoft. I wonder why so many computer book authors feel that a re-editing and repackaging of free, widely available product usage advice provides ample reason to ask a customer to shell out money? It's a false promise. Even the "how to do everything" angle is frankly no more than a re-presentation of applications that Microsoft describes just as well for free (and with code) online.



2. Do buy this book if you've never heard of XML and you don't really want to know what it is or what it does.
   Don't buy this book if you want to know how repeating sections differ from repeating tables, or if you want to understand all the data validation options.
   Although this book does offer some simplified explanations of what Infopath does, it is as light on useful examples as it is heavy on screendumps. Simply repeating what's displayed on the screen is not terribly enlightening, and it's even worse when the text and the screendumps are continually 2 or 3 pages apart.
   Shocking spelling and simple grammatical errors detract from the little genuinely useful information presented, and make the whole book's pace seem rushed and incomplete.
   If you don't really like Microsoft, but you have to learn Infopath, find another book!



3. As an Excel power user now forced to use Infopath for internal forms, this book was helpful. Definitely pitched at office users as opposed to developers, but still a solid reference.



4. I started working through this book with high hopes but soon got very frustrated. Although the author probably does get through almost everything you can do with InfoPath, you have to do a lot of pushing and shoving to figure out how to do it. The author assumes that you have a project you will be working on with accompanying database or Web service, so you can follow along. The downloadable files included a couple of xml files, but no database. There were no specific instructions for finding a usable webservice to try things out.
   
   Most of the book explains things that any slighty advanced user of Office applications could figure out on their own. I am not sure the author really knows who he is writing for. Since he explains all about XML in a single chapter, he must assume the user is new to that, but somehow also knows all about web services. A book like this has to aim at fairly elementary level, with actual examples to work through, rather than "you can" do this or that.
   
   I have definitely learned a few things reading the book, but mostly through figuring them out on my own.



5. The book is very objetive and task oriented. A powerful first approach to master teh Microsoft Office Infopath 2003. It makes easy to create, publish and analyse form data collected, and helps to take full advantage of InfoPath's key features.

5 comments about Beginning DotNetNuke 4.0 Website Creation in C# 2005 with Visual Web Developer 2005 Express: From Novice to Professional (Beginning: from Novice to Professional).

1. Well. If someone is going to buy a book on DotNetNuke in C#, probably that person is very unlikely to need a basic intro on the language.
   So, the topic actually starts at page 143 (which on a ~370 pages book it almost means half of it).
   Regretfully, I bought it since it has a chapter on modules programming in C# (DotNetNuke uses VB, so I liked the possibility of using another language). Wrong, the initial instructions corrupted my configuration files and the chapter got confusing. I basically ended up closing the book, got the official DotNetNuke documentation and figure things out on my own. I could have saved 40 dollars.



2. Not being terribly familiar with the Microsoft family of development technologies, I was completely unaware of what DotNetNuke was. My first guess would have been the latest virus du jour to hit Microsoft. But the book Beginning DotNetNuke 4.0 Website Creation in C# 2005 with Visual Web Developer 2005 Express: From Novice to Professional by Nick Symmonds does an OK job of introducing the reader to the basics of what you're dealing with... an open-source portal framework for .Net development...
   
   Contents: The Basics; The Express and DotNetNuke Combination; Installation; Basic C#; Visual Web Developer; DotNetNuke Basics; Creating a DNN Module; Finishing the DotNetNuke Module; DNN Permissions and Portals; DNN Hosting; Creating a DNN Skin; JavaScript and Ajax; Next Steps and Suggestions; Index
   
   Symmonds tries to cover quite a bit of material in this book, any one of which could take an entire book on its own. You would best be served to have an understanding of C# before you begin, as this is really not a C# tutorial. He does create a "time card" application in C#, which then becomes the basis for a DNN module in the later chapters. There's material on how to install the express versions of the Microsoft development environments for web and C# coding, but again it's not a definitive reference. It's enough to get you up and running, and then you can launch off from there once you follow the directions for this particular exercise. The main thrust of the book is to show how DNN can help you development portal-like web sites using the open-source framework, and how a program written in a language such as C# can easily be ported over to run as a web-enabled module. I don't think I'd want this to be my first exposure to web development, nor is it a book that an expert would use on a daily basis. But for someone like me who had no previous reference to DNN, it served a purpose... good introduction to understand the capabilities, and enough material to take me through the basics. If I were to decide that this was an option I wanted to pursue, I'd "know what I don't know" and could find additional material that would take me deeper into the subject...
   
   Given the right mindset, the book is good for what it sets out to do. But if you've already done things with DNN, you might find it a bit too basic for your tastes... I personally liked it because I came away with knowledge I didn't know existed prior to this...



3. This book is a brief introduction into the world of DotNetNuke. It will get you started, but it will not lead you into advanced topics. This book is geared towards people curious and interested into DNN. This book is not for developers, unless DNN is completely new to you. The author is good about making steady progress throughout the book, not losing his audience. I must say, this book is for Novice to Competent User, not proffesional. Good Luck.



4. This is supposed to be a book on developing a web site. He promises that you do not need to know programming or useless information about .NET. Then he devotes half the book to doing a Windows form for entering hours work, explaining basic HTML tags, reviewing the history of ASP - ASP.Net and uses some complex C# examples in object oriented techniques which have nothing to do with DotNetNuke and are never implemented again. This is what someone does who is paid by the publisher per word! This is supposed to be a Web form book! This book does not take you from "Novice to Professional". Read the DotNetNuke documentation instead. I'm sorry I spent the money.



5. Basically the book is a collection of the most common information already provided on the DotNetNuke site. Module development was basically non-existent.