5 comments about Squid: The Definitive Guide.

1. Back in 1998 when I was running my own ISP, Squid was a lifesaver because it allowed me to provide excellent web response to customers over a very modest upstream connection.

   When I moved on to consulting Squid was the answer to a wide variety of client problems from employee Internet access control (Redirectors) to company website performance (Server Accelerator Mode) to plain old web page load times (Proxy Cache).

   Now that I've moved in-house in a large corporation (30,000+ employees) and I've found out what commercial vendors are charging for their solutions to each of these problems, I have gladly used my knowledge of Squid to save us money.

   Of course, that knowledge was not easily won, at least not for me. Because Squid was an open source project there was a lot of information available on the Web, but, of course, because Squid was an open source project, it was hard to find a definitive answer to my particular problem without asking a lot of dumb questions on newsgroups or making a lot of trial and error attempts tweaking compile time options, system changes and configuration file settings.

   I have waited for this book for a long time.

   I was concerned that it might be too detailed to be readable. Thankfully, Duane Wessels, the primary architect of Squid , has laid out this book to provide simple access at the Macro level. The chapter arrangement and organization are very intuitive. And yet the book still contains enough information to satisfy almost every question.

   The one caveat I would make to a reader is to maintain situational awareness while delving into a chapter because, without noticing it, you can suddenly be confronted with pages and pages of configuration file details. There's no avoiding it, when a book says `Definitive Guide' on the cover you expect to have full coverage. It's just that the book is so lucidly written that the transition from high-level discussions to detailed facts might catch you un-aware.

   And, really, it's that kind of feeling that lets you know that you're reading a very valuable text. I spent the first hour after I got this book skimming each chapter, happy at each additional topic I discovered. Then I went back and asked it the two hardest questions I have faced using Squid over the past year, in each case the answer was easily found and fully explained (Mr. Wessels deserves an award for making transparent proxying understandable).

   The wait for this book was well worth it. I highly recommend it to any person working with, or thinking about working with, Squid.




2. Squid: The Definitive Guide by Duane Wessels is a great book for someone with aspirations of setting up and getting the most out of Squid. It is lengthy at just over 400 pages, but that is to be expected and desired in O'Reilly's "The Definitive Guide" series. One point worth mentioning is that Duane Wessels (the author, for those with short synaptic cycles) is the one who started Squid and still works on it today. Each chapter builds nicely on subsequent chapters, so there isn't any skipping around. If you're just looking to set it and forget it, this book is probably not for you. Otherwise, read on.

   The first three chapters are pretty basic: history of Squid, downloading then installing. For those with no concern of going through downloading and installing, there is a nice section describing each configure switch and, while weighing in at a healthy 48 options, it may be helpful to have this as a reference.

   Chapter Four, Configuration Guide For the Eager, is an often desired, but often left out chapter in technical books. By just reading chapters one through four, it is possible to have a fully functional setup of Squid, albeit not very secure or ready for the pounding of the masses. You will, however, begin to understand how Squid operates. This chapter discusses the most often used settings, such as: minimum/maximum size of cached objects, log files and ACLs to restrict addresses, etc.

   Chapter Five, Running Squid, covers what you expect. It includes such topics as, boot scripts, chrooting and rotating log files. Again, basic stuff, but necessary for the sake of completeness.

   Chapter Six, All About Access Controls, covers one of Squid's major powers and attractions, access controls. ACLs give the administrator extremely fine-grained tuning. Some of the choice highlights for limiting access to addresses/domains include, but not limited to: filter by subnet, MAC, IP address or administrator assigned group. Furthermore, regular expressions can be used to filter URLs or URIs. A most likely seldom used, but very cool, feature is the ability to filter by BGP AS (Border Gateway Protocol Autonomous System) numbers. HTTP request methods such as POST, PUT, DELETE, etc. can also be filtered. Filtering by time or restricting access by user name is also supported. Each topic is assiduously explained and leaves little to be desired.

   Chapters Seven and Eight cover disk caching with chapter Seven being basic material and then Eight covering more advanced topics. Discussions on object pruning, size limits, cache replacement policies and many other cache optimizations are covered in these chapters and are necessary to thoroughly understand if you are situated in a relatively large environment or just want to squeeze every bit of performance from your Squid.

   Chapter Nine, Interception Caching, covers transparent proxying. This chapter discusses the benefits (no need to configure clients) and drawbacks (cannot do user authentication) of implementing such a system. It then goes on to discuss how to configure Alteon/Nortel, Foundry, Extreme Networks, Arrowpoint, iptables, pf and ipfw to perform the routing to the Squid box.

   Chapter ten, Talking to other Squids

   Scalability is another favorable attribute of Squid. Running in parallel with previous chapters, this chapter details the advantages (load balancing and increasing your cache hits) and the disadvantages (security problems with having to trust neighboring Squids) of a caching hierarchy. In addition, it explains how to configure connect timeouts and other tweaks to keep Squids aware of when their siblings are down.

   Chapter eleven, Redirectors, covers another great attribute of Squid. Redirectors can be used, among other possibilities, to remove advertisements in web pages or rewrite client requests based on their given URL or URI. This chapter details how they work, from a protocol level, and provides example configuration settings such as sending only specific users through the redirector or conversely, letting specific users bypass the redirector altogether.

   Squid can be configured to use various user authentication methods to allow or deny access. Chapter Twelve, Authentication Helpers, covers these options. Squid can talk HTTP Basic, HTTP Digest and NTLM. Each type is well explained in how it works and detailed in how to setup.

   Chapter Thirteen and Fourteen fully explain logging and monitoring. The logging chapter explains the type of information each log file catches, a full description of each error or information type (which is a great reference that I made full use of) and configuration directives that change what is logged or how it is logged. Monitoring Squid covers the Squid Cache Manger (A web front-end to many great statistics), a brief mention of using Squid-RRD and using SNMP. Such monitoring statistics include, file descriptor allocation, byte hit ratios, cache hits and cache misses and a wealth of other useful information.

   Chapter Fifteen, Server Accelerator Mode, explains Server Accelerator Mode, which is also known as Surrogate Mode. It is a neat trick where Squid stills runs as a proxy, however, the Squid server is proxying the world (or a select few) to your server. One obvious advantage includes performance (or Slashdot hardening if you will). There are several config directives explained here as well as some gotchas.

   Chapter Sixteen, Debugging, is the is one of the few chapters that I did not need to reference. Although, if you need to, there is some good information provided.

   Appendix A comes with a config file reference that actually provides more information then the comments in the configuration file (Holy moley!...they better trademark that idea before other authors catch on!).

   Appendix B briefly covers memory caching and optimization.

   Appendix C shows how to use delay pools to limit user bandwidth.

   Appendix D details file system performance benchmarks to show you filesystem and operating system differences.

   Appendix E discusses running Squid on Windows using Cygwin.

   Appendix F covers auto configuration of Squid clients to avoid needing to physically visit the many machines you administer.

   In conclusion:

   Pros: This is "The Book" for Squid. No skipping from chapter to chapter, the author was also the designer and still one of the maintainers, fuller descriptions of the configuration file directives that the configuration file comments. It is a great reference.

   Cons: Really the only thing that I didn't like was that he only discussed HTTP proxying. There is a brief mention of FTP and SMTP, but only a couple of sentences. To be fair, in the preface he did mention that he would would of liked to written on these topics but didn't have time.




3. For the new comer I recommend to buy this book if your finding an alternative for Microsoft box like ISA or MSProxy 2.0.
   
   Squid is robost and a very stable Proxy Server, you can use it even in Entreprise consumption..trust me I use it since 2001.
   
   If your looking for technical books or documents about Squid, this is the one your looking for...



4. This guide will pay for itself many times over. If you are considering a caching server for home, office or business you need this book.
   
   My previous experience with proxies was MS proxy server 2.0 and I was a little apprehensive of this project; not to worry. Forty six pages into the book, squid was running; total time invested including installation of the program was about 2 hrs.
   
   Another two hours of reading and precious few changes to config files and my log files are rotating, all ports I need exposed are open and the rest are hidden. I have already been able to tune squid to accelerate delivery of content using *only* this book as a guide. I haven't even had to look at the online documentation for squid (the first time I ever recall that happening).
   
   Not only is my internet connection now available to all users, but also every one is browsing faster than they were before on single dedicated dial ups.
   
   I can't say enough good things about the book or the program. In 14 years of networking I have seen the good, the bad and the ugly. This is one of those rare guides whose author is extremely knowlegable and the material presentation is flawless. I have a large computer science library and in my experience, it doesn't get any better than this.
   
   Bravo Mr. Wessels!



5. then get this one. I learned enough about the reasons for using it and also how to configure it to authenticate against an LDAP server.
   
   Well worth getting and keeping on your shelf.

5 comments about Data Binding with Windows Forms 2.0: Programming Smart Client Data Applications with .NET (Microsoft .NET Development Series).

1. .
   Actually, I am only an expert at buying books about C# and DotNet, but an expert none-the-less.
   
   After seeing the author's data-binding demo on dnrtv, I came here and read the reviews about this book - the reviews couldn't have been more accurate! With only two years of C# programming under my belt, I have found that chapters 7 (Understanding Data-Binding Interfaces) and 9 (Implementing Custom Data-Bound Business Objects and Collections) are alone worth the price of this book.
   
   This book is extremely well written and easy to follow. Not really a "How To", but more of a "How To Understand How To" data-binding book IMHO.



2. Brian Noyes studied the grid thoroughly and has written a readable book which guide you in understanding the datagridview step by step. For me it is however pretty hard to understand the code Brian supplies in C#. In my opinion VB is better suited for learning purposes especially. Sometimes Brian uses tough coding which I can't grasp.



3. This book had exactly what I needed in it, how to create custom objects that are plugable into user interface controls (like data grids) and have all the event wiring etc. to make them look and act like the do with datasets. This includes sorting, etc. Excellent book from a great author.



4. Hanvind books like this one allow people to stay in touch with the internals. Data Binding is a concept that not everyone explains in such details.



5. I'm not sure where that other reviewer got the idea that this book is only for data binding to datasets.One of the best chapters in the book has fifty pages on how to prepare an object model for data-binding, and the rest of the book gives pretty much equal time to binding to objects and to data sets.
   
   The object model chapter assumes that an application's domain model will contain the artifacts necessary for data binding. DDD practitioners will consider that to be bad practice, but the principles and procedures taught are easily applied to transport objects used in the UI. So, regardless of one's preferred style of OOP, the book provides good coverage.
   
   Having just used the book in building a DDD app with full data binding, I can recommend it without reservation.

5 comments about SQL Server 2005 Practical Troubleshooting: The Database Engine (SQL Server Series).

1. This book contains articles and code examples that are very handy, especially to those of us who are transitioning from SQL 2000 to SQL 2005. I am a fairly new DBA and have much to learn, but this book opened the door to some more advanced topics (index statistics and execution plans for example) and described the differences between how SQL 2K and SQL 2005 handle the same issues. Highly recommended.



2. SQLAuthority.com Book Review :
   SQL Server 2005 Practical Troubleshooting: The Database Engine (SQL Server Series) (Paperback)
   by Ken Henderson
   
   Short Review :
   Database Administrators can use this book on a daily basis in SQL Server 2005 troubleshooting and problem solving. Answers to SQL issues can be swiftly located using the index of this book.This book covers the topics and subjects which any other books, blogs or websites (including MSDN, BOL) do not cover. This book provides DBAs with solutions which can be used by user in highly dynamic environments to resolve common and specialized problems. This book tells user what to do when something goes wrong with SQL Server 2005. This book is an edge case, but is something that can make the difference between a SQL Server application meeting customer needs and it going down in flames. This book is a good place to begin troubleshooting expedition.
   
   Detail Review :
   This book will not teach you basic T-SQL from basic and it is not easy and interesting training text book. This book is more like guide to save the troubled time. This book must be read by all the DBA before hand to know what kind of bad (worst!) situation can arise and how this book can be used to prevent the situation or fix it if it has already happened. The authors obviously knows the product very well from inside out, many of the authors are working for Microsoft or MVP. The authors communicate the the topic very well, many places there is lots of code dump, however that is appropriately justified looking at the content covered in the book and direction of the topic taken in the book. The Authors unveils the secretes of SQL Server 2005 internals. We can easily understand how the SQL Server 2005 is working, which helps when something goes wrong.
   
   This book contains many interesting topics. Regular readers of my blog knows that my favorite subject is data corruption and recovery and server crashes and other critical failures. I enjoy writing and researching SQL Server errors and their resolution. It is extremely important to know the common errors and their solution. This book covers errors in depth and in detail. This book tries to cover many subjects in 480 pages, which makes sometime book little heavy to read.
   
   The book covers complex subject very easily and in simple words. For example,
   "Last Known Good - When was the last time DBCC CHECKDB reported no errors for this database? SQL Server 2005 saves in the database information about the last time a DBCC CHECKDB was run without errors on the database."
   "Run DBCC FREEPROCCACHE. This clears the procedure cache of any cached plans that are not currently in use."
   "No matter how accurate the planning or estimate is, you might still run out of space in production. The best practice here is to set up the SQLDiag service to constantly monitor the production system and take action before you run out of space."
   
   This book comes up with CD which contains some useful software (SQL Nexus; TraceBuster, DataDemon) and sample code of the book. I have yet to try the software myself.
   
   Rating : 4 and 1/2 stars
   
   In Summary, This should be a standard book on most DBA's desktops.
   
   Pinal Dave
   Principal Database Administrator
   [...]



3. This book becomes useless on page 5 where it begins to reference sample code that is not provided. After registering my purchase with Safari and Addison -Wesley and reporting the problem, I was deluged with daily "reminders" to upgrade to a paid service. In all farness I should report I received a forwarded email from Safari in which the author states he would like to provide me with the missing code. That was months ago. Gee, do you think I ever received the code? In the meantime, the automated emails continue. This book is trash from a trash publisher. The other reviewers obviously did not read this book or they did not try to reconcile its contents with the propriety code that would make sense of it.



4. I cannot believe how much you get for your money with this book. Very informative.



5. The cd is missing the code from book.
   The author/publisher is ignoring my email.

5 comments about Purely Functional Data Structures.

1. This is the best book available on the implementation of data structures in functional programming languages (e.g. ML, Haskell). Unfortunately, much of the book covers esoteric data structures that will almost never be needed in practice. Hash tables are a major omission, likely because they don't fit well into a functional environment.



2. A correction to another review: Hash Tables are included, briefly.



3. Okasaki's slim volume is one of the best expositions on implementing data structures & algorithms in a functional language. After taking an introductory course on functional programming, this would be the book which tells you where to go next.
   
   This book doesn't just present a rehash/rewrite of imperative data structures, only written in a functional language. Instead, Okasaki makes sure to emphasize benefits which only functional programming can bring to the table. For example, many functional data structures can compactly represent not just their current state, but all of their past states as well--a feature called "Persistence". Also, functional newbie programmers might be wondering why lazy vs. strict programming is a big deal, and Okasaki shows clearly where data structures can benefit from either being lazy or being strict.
   
   For the advanced reader, Okasaki also presents several powerful techniques for analyzing the runtime of algorithms, including the so-called "Banker's Method" and the "Physicist's Method" for analyzing amortized algorithms.
   
   I hope that Okasaki comes out with a 2nd edition of this book; there is one missing piece in particular which I really wish he would have included: Although he presents an EXTREMELY lucid description of how to implement Red-Black trees in a functional language, he only presented algorithms for insertion and querying. Of course, deletion from a red-black tree is the hardest part, left here, I suppose, as an exercise to the student. If you want to supply this missing piece yourself, check out a paper by Stefan Kars, "Red-black trees with types", J. Functional Programming 11(4):425-432, July, 2001. It presents deletion routines, but you'll still want to read Okasaki's book first, for unless you're very much smarter than me you won't be able to understand Kars' paper until you read Okasaki's exposition of red black trees.
   
   Finally, this book is not just useful for programmers in functional languages; logic programmers, using prolog or a varient, will also find this book very helpful, because most of the techniques (all of the techniques, really, with the exception perhaps of the lazy programming stuff) can be directly applied in a prolog programming setting as well.
   
   After reading this book and implementing some of the data structures for yourself, you'll be amazed at how fast algorithms can run, even when written in a functional language!



4. The description of the book says it includes source code in both ML and Haskell. Unfortunately, the body of the text uses ML exclusively, and the Haskell code is banished to an appendix.
   
   I say "unfortunately", because many of the data structures used depend on lazy evaluation, which comes quite naturally to Haskell, and seems to require some sort of non-standard extension in ML.
   
   While the content is good, I wish it would have used Haskell as the primary exposition language.



5. If you are beginning to learn functional programming, this is a good book to study. It focuses much on the "no assignment" aspect of the functional style; a good place to start. And does this on one data structure after another allowing it to be easily understood by readers with a procedural background. For the more advanced reader, the algorithmic content of the book is good reading and I find myself picking this book every year or so just to entertain myself. The applicability of the data structures is limited in that most languages come with basic libraries that suffice most of the time.

5 comments about Large-Scale C++ Software Design (Addison-Wesley Professional Computing Series).

1. I read this book back in 1998. It is the foundation for my understanding of the design of object oriented software. Prior to reading this book I programmed in C++ for more than 8 years. It was apparent to me that there were gaps in my understanding of how to design medium and large scale object oriented systems. This is a huge and dense book, but as I read through it, many times a light went on in my head (those ah ha moments).
   
   The book also gives specific details about consideration for the C++ language. C++ has changed over the years, and the examples do not use newer language features. I do not feel that this is important. The code clearly illustrates the ideas, which are not limited by the state of C++ at the time the code was written.
   
   Regardless of the object oriented language you use to develop software this book will teach invaluable concepts that I have not found explained elsewhere.



2. This book assumes you're already proficient in C++ and basic OOP design principles, and considers design at a level one higher than individual classes. You'll learn how to arrange your classes into modules and packages, and then how to organise communication within and between these higher-level constructs. Nonetheless, the book never forgets that the important thing is working C++ code, not diagrams and acronyms, so it's always practical.
   
   There are two core advantages to the designs discussed in this book: maintaining the correct level of abstraction, and reducing recompilation times. Performance issues always run the risk of becoming outdated fairly quickly, and to a certain extent, some of the timing material is no longer relevant. In particular, Sutter and Alexandrescu, in C++ Coding Standards, explicitly disavow the advocated method of external header guards. Additionally, although namespaces are mentioned, they are not used much, and the older method of using prefixes is recommended instead.
   
   The last part of the book drops down to more low level concerns, such as Schwartz counters, operators, and function arguments. This leans heavily on the likes of Effective C++, C++ Strategy And Tactics and C++ Programming Style, and to be honest, you'd be better off looking in more modern books for up to date best practices. For example, in this book assignment is implemented through the copy-and-destroy idiom, which is nowadays considered to be a mistake.
   
   But this is a big book, and you won't be buying it for the lower-level stuff, but for the large amount of higher level material that makes up the bulk. The main practices and metrics remain extremely relevant, the text is clear and well written. And there just isn't many other places where you can go and read about this sort of stuff. It's a must-read.



3. This is a superb book on software design. While clearly intended for those working on large-scale projects with a broad base of users, the principles discussed are rock solid for even the smallest project. It illustrates a higher level of C++ where objects are not just used because they can represent complex concepts nicely but because proper object-orientation is insurance against many coding evils - exactly the evils which can sabotage large-scale software projects.



4. I'll start with some negative points. Due to the age of this book, much of the example code is out ot date. In particular, no bool and namespaces. This means that the advice about not polluting the global namespace, and to use structs with static members instead ought to now be advice to use namespaces. There's little on the standard library. Coverage of templates (and their potential for code bloat and link time explosion) isn't great. Another issue is the enormous improvement in computer performance since this book was written. At the time, 100MHz single core subscalar CPUs were the order of the day. Now we have 2-3GHz multicore superscalar CPUs that are of the order of 1000 times faster. What sould have taken a week to build would now take.
   
   Some of the terminoligy used doesn't match that which I'm used to. For instance, I would tend to use composition and aggregation where Lakos uses HasA and HoldsA. I don't agree with what he calls internal linkage - basically it is everything that is not extrnal linkage. I'd add a third category, no linkage (e.g., macros, typedefs).
   
   Now some more positive comments. Part II is good stuff. There is a lot of detail on why components can become dependent, and ways of breaking those dependencies. He also explains quite well the disadvantages to such insulation (generally more code and/or slower). Unfortunately, I'm not aware of any easily available tools that generate the metrics that Lakos uses. Without such tools, you either have to perform lengthy analysis (or develop your own tool), or just guess roughly the state of your own system. The end of Part II goes off the boil a bit. Packages are just bigger components, and what is true for packages is also true for components. This leads to a bit of repetition. The section on startup issues is a bit fuzzy as to whether it is a logical design issue or a physical one.
   
   Part III is good enough, but a bit off topic I feel (again getting to logical design, whilst I think the book should have stayed more with physical design). Again, there are a few things that I don't entirely agree with. For instance, advice is given to be 'const correct' [good idea in my opinion], but to only use 'int' and to avoid unsigned types. My opinion on this is that just as you should be 'const correct', then you should also be 'sign correct'. You will have a hard time using just int in real C++ code. size_t is unsigned on all of the platforms that I know, and this is the type of sizeof, the dimension of arrays, returned by strlen and so on.



5. I have to admit, this book is nothing like I thought it would be. It has more C++ than anything else. It is not "large-scale software design with few examples in C++", no sir, it is "design of large-scale software specifically in C++" !
   
   Although not all of the ideas are restricted to C++, many of them do and the book is full of C++ code. Since I haven't done active C++ development for a while (currently digging into Python), it was rather difficult to read.
   
   In a single sentence, the book is about modularization techniques in C++. The purposes of such modularization are different, from speeding up the build process, having the program better understood or refactored, to allowing modular testing or reusing code. And the techniques are different in each case too.
   
   But it is all in C++. Friendship, inlining, const-correctness, abstract interfaces, .cpp and .h file naming, private/protected/public members and/or inheritance, pimpl idiom, initialization of static objects, signed vs. unsigned, that sort of thing. All this has rather limited usability unless you are practicing serious C++ right now.
   
   Again, many of the ideas behind do apply universally, but it is difficult to find them in the thick of C++. I have found a few interesting new ideas, but I have also skimmed over many chapters because it looked too C++-ish to read through.
   
   Worth noticing is that the book is dated (1996) and therefore does not cover such essential C++ features as namespaces and templates.
   
   Only if you are doing serious C++ development. Then it would be great.

5 comments about Data Model Patterns: Conventions of Thought.

1. I can understand why this book has gotten some mixed reviews. The author addresses many common modeling problems. But readers looking for instant solutions to those problems will probably be disappointed. Those looking for oop patterns are reading the wrong book. And anyone looking for a beginner's introduction to data modeling will be completely lost. But if you've been feeling as if your database designs could be better, but you're not sure how, you need this book.
   
   Mr. Hay covers many real-world modeling problems. His discussions of these problems give incredible insight into the thought process of a professional data modeler. That is the true value of this book.
   
   I first read this book about three years ago and now I am totally embarrassed by every database I created before. I've re-read it many times since and my copy is beaten and dog-eared. Thankfully, it's a hardcover book.
   
   Make sure you read all the footnotes in the book. Some of them are hysterically funny.



2. I've done some data modeling, and much more process modeling, so I was familiar with Mr. Hay's objectives with respect to data and restricting the model to logical representations of data, whatever that may be.
   
   About six chapters into this book, I realize that while I could continue through to the end, I would likely find this more useful as a companion to a problem. I think the majority of non-academic readers, software practitioners if you will, will extract the necessary value from owning this book given a specific objective, i.e. I have to develop a work management model from scratch, and these are my (current) business rules.
   
   The book covers so many kinds of models that it's entirely possible a reader will have no practical frame of reference, such as the chapter on accounting. Modern accounting software is primarily off-the-shelf, so developing a data model for it isn't something very common today. However, the smart developer understands that living "in the spaces between" software is a very good line of business, so to that end knowing what an ideal data model might have is certainly valuable ammunition when weighing vendor claims and evaluating solutions.
   
   Because it lacks that sort of accessible readability, I am withholding a star. I'd have withheld a half-star if it were possible; I believe the book has great value to a developer or analyst.
   
   Fred



3. Very satisfying reading experience. Starting off rudimentary and keying into a maturity withing 5 chapters - hats off to David.
   
   I am looking forward to his new book on meta data.



4. If you have any interest in modelling domains, then you've probably already read, or are planning to read, Martin Fowler's Analysis Patterns. The models here share some overlap with that book, but this is a gentler introduction, so I would recommend this book for a beginner, before they read the Fowler book. A more experienced modeller should probably consider this as a catalogue of off-the-shelf models.
   
   This book covers modelling enterprises - e.g. businesses and government agencies, and the relationships between their employees, organisational structures and the products and services they provide.
   
   The fundamental models applicable to enterprises are covered here: the business itself, its employees and their positions; the products they produce and the equipment used to produce them; the activities carried out to produce the products; and the contracts between a buyer and seller that deliver the products and services. Later chapters cover some more specific examples, including accounting, laboratories, and manufacturing.
   
   It is true that the models aren't very detailed, but that's the point of the book - for pretty much any enterprise, these models can be used as starting points, while covering most of the relationships that are likely to be encountered. It's true that you won't get any advice on actually converting the models to a database or an object oriented design, but that's beyond the scope of the book.
   
   While an expert modeller won't find the in-depth treatment they might be looking for, I would definitely recommend this to a beginner. Unfortunately, there's no insight into the process of decomposing a domain, although the last chapter demonstrates wide applicability of the models by applying them to a theatre. What you do get are lots of simple examples of the finished output, which will provide inspiration, even if you have no particular interest in the enterprise domain itself.



5. In his own data modeling consulting, David Hay discovered that for all enterprises, there were common patterns of entities and relationships in various topical areas, whatever the organization. So he set about capturing those ideas in very high-level data models, and he put them together in a book.
   
   This book is quite an intellectual accomplishment, because he has boiled down many different areas into their essentials and has captured those essentials. If you face a data modelling problem, it's likely that one or more of his patterns will work for you and jump-start your efforts.
   
   These are high level models, and don't take you all the way to database design. You'll still have a lot of design decisions to make. But the framework given in these models will help you explore your own problem to discover if you've covered all the eventualities that Mr. Hay considered in his work.

5 comments about Foundation ActionScript Animation: Making Things Move! (Foundation).

1. I will atest that this is a great book IF you are an actionscript junkie, but if your not you will hate this book. I was looking for a book to help my students with thier Flash animations and this book was way beyond where I wanted to take my students.



2. I was tasked with producing eight Flash simulations for an engineering dynamics course this past summer. I programmed the simulations using ActionScript with algebra and calculus introduced to control the behavior of a variety of objects -- no small task if you consider that I am an English teacher and not a programmer or engineer.
   
   By doing and redoing the problems posed by Peters, I could eventually understand them well enough to be able to program similar modules for my project. No idea seems too difficult for him to explain in a manner a beginner can understand, particularly with the working models at the FriendsofED.
   
   I purchased nine books on the subject at the beginning of the project. I ended up using this one more than all of the others combined.
   
   I also recommend his ActionScript 3.0. Being the same book written for two different versions of ActionScript, the two books give us a really good opportunity to compare and contrast the two languages.



3. Foundation ActionScript Animation: Making Things Move! is a surprisingly well-written book. I started with Flash 3, moved to server-side languages with Flash MX, and now, years later getting back into Flash has been a journey to say the least. This book, more than the five or six others I have purchased, has made the transition fairly easy.
   The author has done an excellent job in breaking down Flash math for those of us old school, tellTarget, gotoAndPlay, motion tween people. The best part of this book... the examples are error free. Which should go without saying, but in this day and age it is surprising how many tech books out there (their authors in a rush to publish) have irrelevant or incorrect example code. Highly recommended.



4. I'm only on chapter 5, but this book really lays out all of the tools you need to prototype and/or develop video games in Flash. At first I was a little upset because the author seemed to skip over some elements for the beginner, or rather the rusty flash programmer, but he explains just enough so that if you want to dig into it you can. This book probably isn't for the very beginner. You need to have had some Flash experience and/or some Flash programming experience to really get everything, but a couple of tutorials should be enough. Highly recommended.



5. I have read a lot of books, covering a lot of subjects. This must be one of the more complex subjects (trigonometry mainly), yet one of the easiest to understand. Keith Peters does an awesome job of explaining every little trig secret you never thought you needed to know.
   
   I was lucky enough to glance inside this book, just when I was starting with actionscript. I own this book for about a year now, used it's contents extensively and I'm still only halfway through; Busy exploring the possibilities from previous chapters while the most exciting stuff is yet to come. Seriously, there isn't a single chapter I'm not interested in.
   
   But the best thing about this book is how it breaks down all the fundamental concepts of movement into easy bits of math, so you're able to selectively use any one technique or a combinaton without having to untangle them from context or code.
   
   One of the most usefull and best written books I have ever read, you can not go wrong with this one!

5 comments about iBatis in Action.

1. The book is concise, good structured and it's enough expresivo. This is the first book that I read in English and I understand in its entirety.
   
   Congratulations Clinton



2. I now have a much better insight into iBatis because the authors provided both background design and detailed information about the product. It was much better than the documentation I found via the web (there's lots to be said for technical and editorial review of a book).
   
   The setup and code examples are excellent. I also like the writing style and structure of the book. Clear and logical.
   
   However, I would like an expanded section on using the Spring DAO with iBatis, as this is now the recommended approach over the iBatis DAO.
   
   Although I was already using iBatis, this book is a welcome addition to my library.



3. This is very good book with nice examples and I think this is even better book for users who have never used any form of ORM



4. claro y conciso..
   con ejemplos puntuales ,, este libro se deja entender a pesar de estar en ingles y de que mi nivel en java no es tan alto.



5. Since this is the only book available on Ibatis, so i purchased it.
   But the latest version of ibatis has a lot of changes and this book is based on the older version.
   I got a lot of information on ibatis online.
   Download ibatis and go through the docs( there is Ibatis_SqlMap.pdf ) and same some money ;)

4 comments about Programming Microsoft® Robotics Studio.

1. This book is a good start but I can't wait for the next edition (if there is one). The author attempted too much coverage for the limited number of pages (a little over 200). I have completed all of the Microsoft Tutorials for MSRS and this book is a refreshing change. The author begins with coverage of SERVICES and does not include any illustrations. Microsoft Tutorials and Powerpoint presentations have several great illustrations on SERVICES. Also, the coverage of SERVICES is completed in an orderly manner but not in the same order used in the coding chapters (chapters 5 and later). There are the expected typos, as you expect in a new book. A couple can cause frustration until you figure out what happened.
   
   I will say that MSRS books are very much needed. While MSRS is not a huge software product, it contains several new concepts for many programmers. I have a background in C, C++, C#, and VB. MSRS is best when using C#.
   
   In summary:
   1. I would have liked to have had a thicker book (like the one coming out in June from other authors.
   2. The author of this book made the decision to only do superficial coverage of MSRS subjects such as Simulation and VPL which I believe will be used quite a bit in academic enviorments and more everywhere in the future. The VPL feature of C# code generation is important and deserved move attention.
   3. The author's style of writing is great and very readable. I wish her well and look forward to a 2nd edition.



2. I bought the book because I thought the MSRS tutorials weren't descriptive enough. I was looking for a organized and detailed guide to start using MSRS. This book turned to be useless, it's continuously referencing the tutorials and it does not provide any addiditional information. It uses profusely links to explain things... the author did not realize the the book was going to be printed on paper, so readers could not open those links and would not go to their PCs to hardcode the links in the browser...
   
   There is lack of illustrations and diagrams.
   
   Sometimes I thought that the writer had never used MSRS... and simply,she cut and pasted sentences from the internet to come up with a book...



3. This book is not very helpful for someone trying to learn MRDS. You would be better off sticking to the tutorials on the MS website. There is very little detail about how to actually get started writing robotics software. The best I can say about it is it references other interesting projects. I wonder if this author is actually a MRDS developer because if she was she would have gone into much more detail about the nuts and bolts of MRDS.



4. This book, much like Professional Microsoft Robotics Developer Studio (Wrox Programmer to Programmer), gives good examples, but only for what is explained. If you are interested in doing something like converting hardware robotics applications to simulations, then this is NOT the book for you. Also, to do the examples, you would require to have the robots, and each chapter makes use of a different robot.
   
   If you are only interested in the hardware and not the simulation, then this book is excellent. However simulations (one of the KEY features in MSRS-MRDS) is sorely missed. Especially in conversion between hardware and simulation projects.

5 comments about POJOs in Action: Developing Enterprise Applications with Lightweight Frameworks.

1. Honestly I think this book is a little out of date, since the EJB 3.0 spec has come out. The author did go back and change some of the text to acknowledge that the EJB 3.0 spec is not as heavy weight as the older 2.1 spec, but was still heavier than Spring. I really would have liked to seen a deeper comparison between EJB 3 and Spring, but he seems to really push the Spring model.
   
   That being said I think there are some excellent points the book brings out about the different Persistence layers and how debugging POJO's is so much easier than the alternatives.



2. POJOs in Action describes how POJOs and lightweight frameworks such as Spring, Hibernate, JDO, iBatis make it easier and faster to develop testable and maintainable applications. You will also learn how to apply test-driven development and object design to enterprise Java applications. This book is all about implementing enterprise applications using design patterns and lightweight frameworks.
   
   This book is for developers as well as architects who are experienced in developing enterprise applications in Java using EJB framework and want to know how to use POJOs and lightweight frameworks effectively.
   
   This book consists of four parts. Part 1 which has 2 chapters is an overview of POJOs and lightweight frameworks. Part 2 has 5 chapters in which you will learn about a combination of options to design applications with POJOs and lightweight frameworks. In Part 3 you will learn about other approaches for designing the business and database tiers. Part 4's 3 chapter's looks at some important database-relates issues we normally encounter when developing enterprise Java applications. I should also mention that this book is not a complete reference for any of the frameworks like Spring, Hibernate, iBATIS etc.
   
   Chris Richardson has done an outstanding job; this book deserves 5 out of 5. I wish I could have given more. Once I started reading the book, it was hard for me to put it down. This book teaches you when to use and when not to use each of the frameworks while many other books blindly advocate the use of their favorite frameworks. It is a must have book for every Java developer as well as architect. This is an excellent book, go get it; should be in your library.



3. I won't repeat what other reviewers already said.
   The book is explains very good how to build enterprise apps using the pojo frameworks like spring, hibernate, jdo. It shows very nicely how to integrate these technologies. The code of the book is also awesome. It has a lot of examples.
   
   Before reading this book I knew only hibernate. I saw the hard way that hibernate was not enough for building a complex project. So this made me to read this book. Reading this book I was forced to learn Spring too. When I tried to run the examples I saw that the examples project are built with Maven. I liked how simple and elegant the project was structured using Maven, so I learned Maven too(the book's code is an excellent example of Maven usage too).
   I also saw that handling the concurrency in an (web) app is not an easy thing to do. The book has a good explanation of this topic in the last chapters. Chris is implementing some of the Fowler's patterns and that made me to get some more details about that so this is how I bought and read Fowler's book:Patterns of Enterprise Application Architecture which is by the way a excellent book too.
   
   I highly recommend this book!
   Good job Chris!
   
   PS: too bad that I didn't have this book 2 years ago.



4. Got the book alle the way up to ice-cold Norway in no time. The packing was a bit ripped up; probably due to ice-bear attack.



5. With simple descriptives words and plain-text explanations this book shows many simple but practical ways of designing and implementing j2ee solutions using POJOs with those great design frameworks like spring and hibernate. This book can be considered as an detailed overview of how to build an enterprise lightweight J2EE projects including some introduction on some useful and practical patterns such as domain model pattern, POJO facade, persistence patterns, optimistics locking patterns etc. Together with spring and hibernate this book completes most of the great design prototypes of lightweight J2EE enterprise solutions. Highly recommended.