5 comments about Game Programming Gems (Game Programming Gems Series).

1. I've found this book to be very useful in game programming. The variety of articles an concepts covered is very vast. In fact, that is probably the cause for its only (in my opinion) shortcomming - that many of the articles aren't long or complete enough. An excellent book if you're looking for an introduction to many different concepts.



2. I swear, this series is like programming crack. Succinct, no extra "learning how to program" garbage, no extra commentary. Code. That works. Well. Quickly.



3. I have been reading this series since this first book. I am about to purchase Game Programming Gems 5 because each book has given me so much incite to the many elements of game programming. You could easily take every one of these tips and gems and implement them not only in games but many systems that require optimization, graphics or sound programming.
   
   Hands down this series is the best format I have seen with regards to engineering books. The many authors contributing are industry experts and the hands on people who are doing the work. Even if you do not program games this is some great information for all software developers.



4. I have been trying to get into game development for a while, and finding books that are truly helpful has been difficult. Within the first hour of ownership I actually began to 'feel good' about game development.
   
   The format of the book is very unorthodox - it reads more like a very detailed "quick tip guide" than a book on programming - which was very refreshing. And the sections I have read have all been very personable, cut-and-dry suggestions:
   
   1. This is what you should do...
   2. This is why you should do it...
   
   I am a bit short of cash at the moment, but I guarantee I will be purchasing more of the series.



5. The book is very useful not just for game developers, but also for programmers that are looking to some C++ optimization. I have to admit, that most of ideas are somewhat new to me (and I'm a C++ programmer for several years now). Looking forward to read next part of GPG.

No comments about MCTS Self-Paced Training Kit (Exam 70-643): Configuring Windows Server 2008 Application Platform (PRO-Certification) (PRO-Certification).

5 comments about Python For Dummies (For Dummies (Computer/Tech)).

1. If you have programmed at the level of Visual Basic, or perhaps Excel macros, then this book is perfect for you. It's a pleasure to read -- with its variety of visual aids. In many books, the graphics just clutter the page. Not here. The concepts pop out at you and burn themselves into your memory.
   
   I doubt you can become productive in Python any faster than with this book.



2. From the Dummies title I expected that this was for beginners. The book itself claims that it is suitable for someone who wrote a few Basic programs at one time. I wrote a few Basic programs and it is not. An example: On page 20 it starts a discussion that turns on objects. This is a somewhat advanced topic by most accounts, but the chapter that deals with objects is hundreds of pages later.
   This book that claims that it is suitable for beginners, claims a few pages later that it is more of a reference, really. But it is very poorly organized, as the previous discussion illustrates. Strange stuff like the explaination of Scheme as a functional programming language: In Python for Dummies this is explained as using functions to write programs. Really! It;s that bad.
   The only audience I can imagine for this book is people who know something about Python, but prefer reading about it to programming. Reading it, they could pick up a fe pieces of information they hadn't seen before.



3. This is a pretty decent book for those with some previous programming experience, but is definitely not for beginners (or Dummies) to programming. The first 2 chapters contain terms and concepts that assume an existing knowledge base.



4. I agree with some of the reviewers here, it is definitely disappointing to see a bad seed among the good "... for dummies" series. I have previous experience with programming languages, although this is not my everyday task. I got interested in Python and wanted the book to guide me through the basics. After reading the first 7-8 chapters I started asking myself whether I missed something in the previous ones, as I lost track (and interest) in the book.
   I found the examples parsed in the chapters rather useless, and not practical. Since, I have found several useful on-line tutorials on www.python.org, where the user is taken through the chapters in a gradual, progressive way. The examples and exercises in a beginner's book should be based on what is learned in the previous chapters, giving the reader the idea that what is learned is put in practice, thus easily assimilated.
   
   I don't recommend this book for a complete novice, as she/he will lose interest in Python programming very easily! This book has the advantage of presenting the main and most important features of the Python programming language, but it sues a more advanced audience.
   
   The low rating is indeed due to the non adequacy of the book for beginners and for not following the good standards of the "...for dummies" successful series.
   
   Sacha



5. I have read a couple dummies books and usually they are more of an introductory baby steps type of book. This was not the case. It feels they tried to offer more and it ended up coming across as babble.
   
   I found myself getting bored at times. I can program in Perl and I started this book knowing I might be above the topics at times. I was looking to this book as an introduction to Python. The examples given were not as good as I would have liked. Overall, I don't think the presentation of topics were not good. For example, I thought two chapters on OOP was overkill for this type of book and probably should have been reduced to a chapter on the bigger things you may do.
   
   I mention the examples again as I usually like to enter them for the fun of it. However, they really don't give a good feeling for the power of python.
   
   I did like the spider example but it was lightly discussed.
   
   The last two chapters I think were most useful for the links and other modules that were mentioned.
   
   I should say glob was mentioned and I think the book should have talked about it more then just a passing mention.
   
   So will I suggest this book? Probably not. It really depends on the person. I think it has to be a person that is between beginner and somebody who knows how to program.

5 comments about Pro Apache, Third Edition (Expert's Voice).

1. In this voluminous title author Peter Wainwright covers the Apache web server in detail. Chapters include Installing Apache and basic configuration, building Apache the way you want it, configuring Apache the way you want it, deciding what the client needs, delivering dynamic content, hosting more than one web site, improving Apache's performance, monitoring Apache, Securing Apache, Improving Web Server Security, and Extending Apache. It has some excellent sections on advanced configuration, handling robots, dealing with errors and handling them correctly, name-based and IP-based virtual servers, and improving the performance of your server. The section on securing Apache covers authentication (including digest and LDAP) and using SSL (including some advanced configuration techniques).
   
   There are better books that deal with some of the specific areas of this text (for example, Hardening Apache is much more thorough on the subject of securing your server) but you won't find a more comprehensive text in a single volume than this one. Pro Apache, Third Edition is highly recommended and my first choice for anyone looking for a single book to learn how to setup and configure an Apache server or serve as their primary reference.



2. The book is very well written it has helped to go through with the apache server i will recomended it to manyone who is interested in these kind of books. Very explicitly described the content of the book.An excellent purchase



3. This is by far the best standalone book on Apache I've seen. It really is a very good reference for professional web server admins, as well as developers and others, who need help in managing Apache web servers. It's well-written too, something that is becoming increasingly rare in the technical book area.



4. This book contains some meaningful information but is largely obsolete.
   
   Some fairly informative chapters contain introduction to common configuration, authentication, configuring SSL, using WebDAV and subversion.
   
   But lot of space in the book is wasted on topics that were cool in the last century like compiling apache and compiling single modules, but not relevant anymore. Today you are likely not going to recompile you server every week, but you SHOULD install security patches every week, if you take your job seriously. IMHO there is only one possibility - to rely on the services of your linux distribution.
   
   By the way, Debian and derived distributions also do a great job combating the mess in the httpd.conf by meaningfully dividing it in multiple configuration files, so you have a good place to put your specific settings making an automated upgrade to the newer apache version easy. So do not listen to the author, never edit your httpd.conf. ;-)
   
   The author describes in detail topics, that are not relevant anymore in the web application development (assumed that you are creating an application, that goes besides "hello world"). Delivering dynamic content (chapter 6) used to be server-side includes and cgi but it is NOT anymore because of poor programming model and poor performance.
   
   Typical scenario nowadays is to use apache as a front end web server, letting apache serve the static content like pictures and providing a wrapper or proxy to a high performance application server (for example mongrel if you using rails) or using mod_python for python or using zope etc. In this context I would wish elaborative description on mod_rewrite, that is pretty complicated.
   
   My conclusion: if you are beginner, search for a better introductory book. If you are advanced developer/admin/hacker, then use primary resources like [....]



5. I own and have read numerous Apache books over the last seven years. I believe this publication to be the best reference book for the workplace.
   
   O'Reilly books are definitely well written; however, I find myself ALWAYS going to this book first, even though it was published in 2004. The Apache Directives, topics, and examples covered are timeless. It puts side-by-side code base 1.3 and 2.0, with strength of focus on the 2.0 code base. If you use the Apache Software Foundation (ASF) online documentation along with this book, then you will be able to perform in the workplace. Nearly everything covered in this book is relevant today and even translates to the 2.2 code base.
   
   I can't wait for the next revision to cover the 2.2 code base in depth. Unfortunately, publications can't keep up with ASF releases and the new and re-factored modules. It takes about two years for a solid book to be put into circulation after ASF makes a major release available.
   
   Well done Peter!

5 comments about Advanced Use Case Modeling: Software Systems (Addison-Wesley Object Technology Series).

1. This book has some powerful advice for those projects that use Use Cases to drive their analysis and design efforts. It lays out a good process to follow for developing the Use Cases so you don't jump right into the details without a plan. Much of the advice is good Software Engineering practices, but a lot of people seem to forget that it still applies even when making use of newer techniques such as Use Cases.

   The chapters pertaining to relating the Use Cases to other artifacts - such as test cases, the User Interface, and the Object Model - offer very practical and sound advice. You can tell that the authors have actually done it before and are speaking from experience and lessons learned.

   The chapter explaining Extend Relationships offered the clearest and most complete description of the Extend Relationship that I have encountered.

   All of the writing is very approachable and the examples sprinkled throughout the book and in the Appendixes are very helpful.




2. I strongly recommend this book!



3. It is refreshing to a read a text that caters for those of use who already have experience in this domain and are seeking to develop their skills - without reverting to acadamia style writing. Useful examples, balanced descriptions, and an excellent coverage are all attributes of this text.



4. I have found this book of tremendous help in my work.

   My first books on use cases focused more on UML rather than use cases. I did not give a hoot on use cases, because they look so simple on paper (and that's why I didn't buy a book specifically on use cases!) But as I grew as a developer, I began to believe that use case modelling if done well can significantly reduce development effort and bring about quality solutions. Use cases are the foundation to the understanding of the system that you are trying to develop. Use cases deserve serious attention.

   The main problem with use cases is that you either don't know how to start or when to stop. This book tells you both. It tells you how to develop your use case model systematically from scratch and how to make provisions so that your use case model can grow. IMO, that's the main draw for this book.

   The authors also give good insights on the possible approaches the reader can take to expand his/her use case model iteratively. It cautions the modeller to keep a balanced model so that stakeholders can understand, rather than one that specifies everything but gets bogged down by the details.

   Semantics, you can get it elsewhere, but this book discusses it pretty well too. The examples are clear and relevant.

   All in all, Frank and Granville did an excellent job covering the topic.




5. This book was nice .it was NEW.I never thought I will get a New book for less cost.

5 comments about Web Services Essentials (O'Reilly XML).

1. This book is really lacking on much useful information. It's mostly a high-level overview. For anyone seriously interested in web services I'd recommend getting a different book!



2. This book is really an excellent one for programmers who want to start with web services. It gives a compact overview of XML-RPC, SOAP, UDDI and WSDL. Especially Java programmers will find some good code listings. But don't expect more than an introduction to web services.



3. This book is based on obsolete specifications and older SOAP implementation which is not even available for download. The Apache SOAP is already a piece of junk and Apache recommends to use Apache Axis (which is not in the scope of this book). All other implementation examples such as XMethods and UDDI4J are also obsolete as well. The APIs are already deprecated and the code discussed does'nt make any sense.



4. First of all, to clear up someone else's comment:
   while the API samples, URLs, etc. in the book are all outdated but even beginners should be able to figure out the updates.
   
   The only word of caution: it does NOT cover REST.
   
   This book provides a wonderful set of core topics and values that are essential to understanding what is currently out there (at the time I'm writing this in close-to-mid 2007, anyway). Providing samples, history and general information on each topic covers allows this book to be a wonderful, thorough introduction to the world of WS.
   
   Samples focused in Java and Perl help keep things simple, while there is more of a focus on the Java world. The APIs changed, but since the author references primarily open-source, it is easy to figure everything out.
   
   I recommend this book at this time, but can definitely see it being completely out-dated by the same time next year.
   
   As with many emerging technologies, however, I think this is a must have in order to better understand and follow the evolution of its realm. Since it provides pointers/references to pieces of the puzzle(s) even before its publishing, you can gain even more insight and possibly make some educated decisions as to where the future will take it.
   
   Recommended for all, if for nothing else, as a general reference and "emerging history" lesson.



5. This is a well written overview for those that may have missed how Web Services rushed onto the scene earlier in the decade. Being 5 years old now, it is definitely out of date. I consider about 120 of 300 pages useful as an introduction to the subject to a developer who has been working in other technologies. It provides a good overview. The examples provided work well to illustrate the point presented. Keep in mind that the examples are outdated so skip liberally.
   After reading/skimming this as an introduction, find a more current book for more hands on examples to work through in the technology you intend to use.

5 comments about Pro Oracle Database 10<i>g</i> RAC on Linux: Installation, Administration, and Performance (Expert's Voice in Oracle).

1. This is a very hands on command line oriented book. Good understanding of RAC concepts. I found it extremly useful in my day-to-day work.
   
   Highly recommended.
   
   Thanks!



2. Very well written. No mater you are a Pro or a newbie, it will be helpful. A very well written book.
   
   
   Highly recommended.



3. This book delivers what it promises. It contains a great balance of technical detail,examples and theory. It encompasses all aspects of implementing/maintaing 10g RAC on Linux.



4. Many books around Oracle's advanced topics simply parrot the manuals. Julian avoids that. Instead, he describes Real Application Cluster technology from the ground concepts up to full implementation, with practical notes and tips. He gets into topics that the manuals never touch, and much of what he writes can be useful in any RAC environment, not just Linux.
   
   I whole-heartedly recommend this book and own both the paper and eBook version which I often reference.



5. This book can easily be used as a college textbook on Oracle RAC. I am studying for the Oracle Certified Master exam and this is possibly the most high level book on Oracle I have read.
   
   It has 3 major strengths which I found to be superior to any Oracle RAC books I have read (including the manual from Oracle).
   
   1)Technical Depth
   2)Comprehensive Overview and instructions
   3)Quality of writing
   
   
   1)Technical Depth
   The authors write about Linux and Oracle and are high level experts in the subjects. For example, the authors have a very detailed description of how Oracle Cache Fusion handles locking across all the nodes in a RAC environment (probably the crown jewel of RAC technology). They also discuss, in detail, different types of CPU, memory, and storage and contains detailed description of each architecture. Lastly, it contains vast number of "how to" install, configure, change, analyze, backup/restore, and utilize Oracle RAC and Linux.
   
   2)Comprehensive Coverage and Instructions
   No small amount of detail has been skipped. The book contains every utility (there are many) provided by Oracle to implement RAC. It provides a good step-by-step coverage of Linux and Oracle RAC installation as well what each step is adding to the RAC environment. To top it off, it adds how to performance tune, administer, troubleshoot, backup/restore, and use Dataguard in a RAC environment. I can't think of a subject on RAC which the authors did not cover.
   
   3)Quality of Writing
   I was pleasantly surprised how well written this book is. Although far from a Pulitzer Prize material, it certainly belongs in that category amongst the Oracle books. Every praragraph has been well organized and written. The proofreader of this book deserves major praise for their work.

5 comments about Write Great Code, Volume 2: Thinking Low-Level, Writing High-Level.

1. Back in "the day", you really couldn't write high-level code without at least some exposure at some point to lower-level code, like Assembler. Now, you can pretty much be completely ignorant of what happens in your Java or VB code "under the covers". But that doesn't mean you can't benefit from understanding how your compiler turns your readable code into machine-readable operations. Randall Hyde does an excellent job in explaining all this in his book Write Great Code Volume 2: Thinking Low-Level, Writing High-Level.
   
   Contents: Thinking Low-Level, Writing High-Level; Shouldn't You Learn Assembly Language?; 80x86 Assembly for the HLL Programmer; PowerPC Assembly for the HLL Programmer; Compiler Operations and Code Generation; Tools for Analyzing Compiler Output; Constants and High-Level Languages; Variables in a High-Level Language; Array Data Types; String Data Types; Pointer Data Types; Record, Union, and Class Data Types; Arithmetic and Logical Expressions; Control Structures and Programmatic Decisions; Iterative Control Structures; Functions and Procedures; Engineering Software; A Brief Comparison of the 80x86 and PowerPC CPU Families; Online Appendices; Index
   
   This is the type of book that will really excite you if you're wondering why a nested if statement performs differently than a case statement. Hyde explains basic compiler theory, and applies that to how your compiler of choice decides on optimization strategies. It's impractical to get a program optimized for all factors, like code size and speed, but there are reasonable trade-offs as well as compiler options you can use to prioritize one factor over another. You also don't have to be completely conversant with Assembler in order to work through this book. He uses a number of high-level coding examples from various languages (like C, C++, and Pascal) that should be understandable to most any IT developer. He then shows the translated code at the assembler level and explains why a particular compilation might be good or bad (depending on your requirements). Once you start to understand how (and why) your compiler "optimizes" your code, you can make more intelligent choices as far as programming constructs. There is often a dozen ways to do something, but a few of those ways will be far more efficient at the machine level than the others.
   
   If you're writing a program that runs in a second or two, these techniques may not necessarily have an immediate practical application for you. But that hour-long program may have the same underlying problem as your first program, and it could be that a slight change in program structure at your end could dramatically reduce the run time. This is one of those books that most serious software developers should have sitting on their shelves...



2. The first 100 pages of this book were fantastic for concepts. After that, there were numerous code listings of various dialects of assembler that were each several pages in length. The premise is that you should learn to read assembler so that you can write better high level code. However, there is no tutorial on what the various assembler keyword instructions mean. This book feels like it was slapped together because it was the long overdue volume two in the series, and has so many references to the first volume that you practically need to own both. There is not enough on Java (or OO in general) as the reader's high level langauge of choice, and far too much on Pascal.



3. In this RAD time when anybody who knows drag-and-drop can proudly claim himself software developer, this is the unique book for true, serious, and hardcore programmer that writes native codes. I completely agree that, in order to write efficient and optimized code, you not only need to understand what your compiler can do for you,but also you should know, at least for a minimum level, what you can do for you compiler. In this regard, this book does an excellent job explaining the magic your compiler does for you and what you can do to become part of the magic. As such, I highly recommend this book to any serious programmers.
   
   The only thing I don't like about this book is that it appears to be giving too much space to HLA, which I suspect is a widely accepted assembly dialect that was actually used in any real-life project. And I just feel it is a waste of my time trying to understand and catch up with this HLA language. This results in my taking one star off with the final rate of 4 stars.
   
   Other than that, this is indeed a very good book.
   
   In a previous reivew, it is complained that Java is not touched. This is understandable while it really doesn't seem to be a problem to me. Java after compiling is translated into bytecode that has to be executed on the virtual machine. I guess that is really beyond the intended scope of this book, which is related to the world of native codes that after compiling can be directly executed by the machine.



4. How Software Works would also be a great title for this volume. Any high level construct you can think of is analyzed in-depth at a low level. This is great for those interested in reverse engineering or writing cleaner code.
   
   This book is language and hardware neutral. Languages from Pascal to C++ to Visual Basic are covered on hardware from x86 to RISC to embedded systems. No matter what language you code in the innards are laid out for you. The author does a masterful job of the idiosyncrasies of different languages seamlessly without dwelling on the trivial. This book is heavy on assembled code, compilers, and interpreters. It's an absolutely great collection of everything you wanted to know about how software works that you really can't find elsewhere in a single volume.
   
   Although the subject matter is probably dry for some, I found this book surprisingly easy to read due to the clarity of the writing. This is at least as good, or better than volume one. With that said, there are a number of references to volume one, and I do recommend reading volume one first unless you have a solid background in computer architecture.



5. I read the first volume of this book, and it was a great, informative read. After volume 2, I have this to say:
   
   This book is not a cookbook for writing better code. Hyde explains why certain programming constructs are better than others (and in what cases), and backs it up with evidence from the assembly code (that is the entire premise of the book). Finally, solid proof of (and against) what I've been hearing all along from instructors and other programmers on message boards or face-to-face communication. That in mind, it would have been nice to have a summary of the tips at the end of the chapters, or the end of the book, as a quick-reference kind of thing. These concepts are the perfect thing to consider when fine-tuning your code. I take the stance that if you fine-tune as you go, you have less work later, so I took notes as I read and have started implementing changes for the better (with evidence that it is better) in some of my coding.
   
   Does anyone write code in Pascal anymore? Seriously? Hyde discusses examples in C/C++ and Pascal for the most part (favoring Pascal, by my estimation), so it is nice that the book is language-independent for the reader. The assembly examples in the book are in 80x86 and PowerPC...I think it would have been better to release two versions of this book, one where the assembly is 80x86 (because it is so ubiquitous, if for no other reason), and then another where the assembly is in PowerPC assembly. I didn't pick this up to become an assembly language programmer, and quite frankly, the PowerPC examples just confused me. It looks like my cat stepped on my keyboard and it appeared in print.
   
   The tone of the text is sometimes condescending (especially in the first 5-6 chapters), with a not-so-subtle "real men only code in assembly" message. It seriously reminds me of my parents/grandparents whining about how hard they had it growing up...walking barefoot to school in the winter...and only having assembly to work with in writing programs.
   
   So by the end of this book, I think I have met Hyde's goal for the readers. I can't sit down and write an assembly program, but I can read enough assembly to compare different versions of my high-level program to say what is better. As the subtitle suggests, I am "thinking low-level" now as I write my programs (in C...which most programmers would call low-level). I suggest "actively" reading this book and coding up a few examples with your compiler and examining the output, following along in the text. Doing that really made the material click for me.
   
   Overall, it's a good book and definitely worth it. This is a long one though, and takes some time to digest. See you in volume 3!

3 comments about Measuring the Software Process: Statistical Process Control for Software Process Improvement (SEI Series in Software Engineering).

1. This book gives a practical guidance on software process measurement: what should be measured, how to measure, the measurement process/procedure, the data analysis of measurement, and the application of analysed results. It's easy to read and understand. It would be better to include more "case study" information.



2. This book is a self-contained statistical process control (SPC) foundation in the context of software process improvement. Authors Florac and Carleton apply early industrial wisdom and some previous work at the SEI to a modern software development environment. The emphasis of the book is primarily on the use of analytical studies (predicting future outcomes) using the control chart as the primary instrument. There is only brief treatment of the use of enumerative studies (evaluating current situations) in this problem domain. Time-honored tools such as the Pareto chart, cause and effect diagram, and histogram, however, are given much less attention. The first half of the book directs attention to critical topics such as planning, managing and measuring. The authors adequately cover the material as it applies to software development, but the reader is cautioned that many statistical fundamentals are omitted from this work. In order to put these ideas into practice one should seek further instruction or consult a statistician for best results. A few annoying typographical and redundancy errors are present as well. Most bothersome about the book is that the authors do not seem to be 100% convinced that SPC for software process improvement actually works! This is somewhat alarming, given the long successful history of SPC in other industries. All in all, however, this book desperately needs to be read by anyone wishing to improve a software development process.



3. This book contains the keys to meeting core CMM level 5 requirements, which defines key processes for optimizing and continuous improvement, and for achieving 6-sigma processes. However, you need not be striving for either (or both) of these goals to use the techniques and approach in this book to full advantage.

   Implementing and employing statistical process controls are the basis of this book. The authors lead you through the steps and techniques necessary to implement and use SPC, starting with background information on processes and a process measurement framework, and moving through topics such as planning your measurement strategy, data collection and analysis, and developing and interpreting process behavior charts using common SPC chart types. The most common controls are x-bar (mean) and r (range) charts. Be aware that any SPC approach requires two conditions to be met: (a) defined processes, and (b) the processes are in statistical control (meaning that the data points being measured have settled into a normal distribution that are randomly clustered around a mean and have defined upper and lower control limits). New processes, or processes that are not managed well enough to have these characteristics are not candidates for SPC.

   This book requires knowledge and skills in basic statistical analysis. If you require a refresher I recommend reading "Visual Statistics" by Jack R. Fraenkel before tackling this book. I also recommend "Applied Statistics for Software Managers" by Katrina Maxwell, which not only teaches the basics, but also approaches measurement from the perspective of multi-variable analysis, regression analysis and other basic measurement techniques, which nicely complements the SPC material in this book and gives a broader picture of metrics.

5 comments about Expert C# 2005 Business Objects, Second Edition (Expert).

1. This is an exceptional book. It provides both the examples of how-to use the framework and how it is built. This internal view of the framework provides invaluable insight into the internal workings of reflection and gives real world perspectives to using objects consistently in a distributed architechture. I like the book!



2. This book has a very good discussion of frameworks and includes the details of the CSLA (Component Scalable Logical Architecture) framework. However, I don't believe the book is worthwhile for the discussion of frameworks alone. If you're required to use CSLA, then this is the book for you.
   
   I give the book three stars because its contents can't be separated from the design of CSLA. The problem with CSLA is the layers. The use of "fat", fully encapsulated business objects has fallen out of favor recently and is not the best architecture for enterprise applications. Despite what the author says, I don't believe CSLA is truly a layered architecture, either.
   
   The book lacks a discussion of when CSLA is a good choice and when another architecture is better. Choosing to use CSLA pre-determines your architecture (the "A" stands for "Architecture", after all). You should always choose your architecture based on your requirements and never select an architecture in advance.
   
   That said, CSLA can be a good architecture for smaller projects. New developers often have issues understanding true multi-tiered architectures. Because CSLA uses an encapsulated architecture that's similar to the OOP training they had in school, those developers may find CSLA a good choice because it's easier for them to understand.



3. Author spends too much time in theory and less time showing real examples. Author wants you to down load code and spends time discussing bits and pieces of each section. Very, very, very steep learning curve. Not a good investment - wish I could find a CSLA book that teaches you step by step....



4. The book itself is somehow disappointing. Sounds like the old vb6 bo book, rather outdated.
   The main concept involved as a guideline on design is the fat table module object arbitrarily called business objects by the author, when the market is more oriented to model domains. Why should we choose fat objects instead of other solutions? It is not discussed on the book.
   A big issue is the way the book is written. He assumes you are a vb6 person. The author is not fully aware of the asp.net architecture. Look at this paragraph about keeping state on the page:
   "There's no automatic
   mechanism that puts all state data into each page; you must do that by hand. Often this means creating
   hidden fields on each page in which you can store state data that's required, but which the user
   shouldn't see. The pages can quickly become very complex as you add these extra fields.
   This can also be a security problem. When state data is sent to the client, that data becomes
   potentially available to the end user."
   
   So he's completely unaware of viewstate object which address all these issues. I think asp.net has gone a long way now and this guy don't even know one of the basic revolutionary concepts brought up by as.net.
   I have constantly the sensation that he is addressing a vb6 developer, but vb6 is long gone.



5. A good written book, it's a step by step trip in the author's mind: from idea through design to coding of his framework. You may not agree with all choices (such as heavy reflection use) but you always know why he did. A good start point to build your own businnes objects and a rich bag for your developer's toolbox.