No comments about Microsoft Dynamics CRM 4.0 Unleashed.

5 comments about Programming Python.

1. This is my second-favorite Python book, coming in a close second behind Python in a Nutshell. Programming Python does a nice job of covering the "how" of Python, and an even better job of covering the "why" of Python. Some may give this the semi-pejorative label "advocacy," but I'd say it's acceptable when you're preaching to the converted (i.e. purchasers of Python books), and remember also that this book dates back to a time when Python advocacy was actually needed.
   
   Reading this book taught me a lot about how to write "pythonic" code -- code that not only works, but is idiomatic and follows the best practices for Python (and software engineering in general).
   
   Another great thing about this book is that it's also actually enjoyable to read. I found myself reading this one cover to cover, rather than getting in and out as quickly as possible, which is the norm with most of the programming-language references I own.



2. Programming Python by Mark Lutz was surprisingly high level. Unlike the other O'Reilly "Programming ...." books (like Programming Perl) it gives only complex examples. The reader is assumed to have considerable experience with Python to begin with. In that perspective, it is an excellent book, but it will disappoint the newcomer who expects something starting from the from ground up.



3. I bought this book a few years ago, and I think I have finally given up getting anything of use out of it. It has been with me through my entire Python learning experience, so you might think there would be a point at which I would have found it useful, even if that may not presently be the case. Unfortunately, I can say that this is easily the least useful Python book I own. In fact, out of the 6 or so Python books I own, it is the only one I wouldn't miss a bit.
   
   It's just that it never seems to have anything even close to relevant for me, when I'm working on something. I can remember several times where I thought to myself, "What's a good way to solve this problem in Python?", or, "Where can I get some background on why Python does things this way?". Invariably I have either found the answer in one of my other Python books, or on the web. It's not that I haven't tried to like the book, in fact each time a problem comes up, I think "well ok if the book can shed some light on this for me, I'll consider it a value", and yet after 3 years... nothing.
   
   Anyway, I don't want to be all negativity, so to anybody reading this, here are the other Python books I have gotten more value out of:
   
   The Quick Python Book by Harms/McDonald (Old, and yet, still really valuable beginning book)
   Python Essential Reference by Beazley (A great reference book)
   Python Cookbook by Martelli et al (what Programming Python seems like it wants to be, but in half the size and twice the value)
   Python Standard Library (I don't use this much, but it still has some value)
   Python in a Nutshell (I think that's the name, it's at work right now. Another decent reference)
   
   Finally, it pretty much goes without saying, but I'll say it anyway. This is just my experience. I am sure this book has been right on the money for other readers, and that's great, but for me, I think I may be donating this behemoth to my local library soon.



4. One thing I really wish O'Reilly would have made clear on the cover is the version of Python which was current at the time of publication. In this case, it's 2.4, so if you're looking for information on things like function decorators or the new generator abilities that 2.5 brought along, you're going to be as disappointed as I was.
   
   Aside from the fact that some of the information is dated, it's still a good overview of practical solutions to realistic problems which can be solved in the language. It does tend to spend way too much time developing TkInter GUIs (which I do not personally care about one bit) and overusing the usual array of extremely unfunny Monty Python references (which I personally stopped caring about around 1984). If you cut out both of these things the book would probably require about half as much paper per copy, and it'd be a good deal more digestible to boot. There's also lots of Windows-specific silliness and the author continues to operate under the assumption that OS X does not exist (every mention of the Mac platform refers to information that hasn't been accurate for nearly 10 years at this point).



5. This is not a terrible book, but I don't know what it's good for. The code examples are too long. This reminds me of the old programming tomes from the days before CD-ROMs and the Internet, where all details had to be shown in print. There is just too much code. If you find a chapter that matches exactly what you are trying to accomplish, then maybe this book is good for you. It is vastly improved in readability over the first edition, but The Python Cookbook is a much smarter purchase (even though part of that is available online).
   
   If you are just trying to learn Python, then Lutz's other book, Learning Python, is an excellent choice.

5 comments about ActionScript 3.0 Cookbook: Solutions for Flash Platform and Flex Application Developers.

1. This book is a is a supplement to other ActionScript books, and a big help to people who can do some things in Flex or Flash, and can maybe even write some ActionScript, but are not yet self-sufficient gurus. The ideas and information can be found in other sources, but it's compiled here in a way that's surprisingly handy. For example, there is a chapter on programmatic animation. It's a good start, but for more detail, you really want Foundation Actionscript 3.0 Animation: Making Things Move!. Someone else already posted the table of contents, so no need to repeat it.
   
   The book is a collection of code snippets with explanation text. The authors assume that readers are building projects and want to add some features or capabilities. The code snippets demonstrate how to implement these. It's not exactly a beginner book, but it begins with ground-level concepts such as where to put ActionScript in a project, how to use mathematical operators, and how to trace messages. More complex topics follow.
   
   I like the way information is presented. It provides a nice counterpoint to other ActionScript books I've been reading, with a "You want to do this. Here's a way to do it" approach. I think this will be an excellent reference and I will use it a lot over the next several months. I can't give it five stars because the web support for the book is lame compared to what I've seen for other texts. I understand authors are busy, but I think the online component is important for these ActionScript books. If you are an absolute beginner with ActionScript, I also recommend Learning ActionScript 3.0: A Beginner's Guide. Thanks for reading.



2. For those of us who have experience in many programming languages (C, C++, C#, JAVA etc.) who were introduced to flash and to actionscript (2.0/3.0) - I HIGHLY recommend this book as your first choice! - it'll get you up to speed in a matter of a week or two!
   I highly recommend taking some time aside and read it thoroughly. This is the best cookbook I've ever read. Very clear, well organized, easy to understand - you name it! In fact, I don't know whether to consider it as a cookbook - as it is by all means an excellent learning textbook as well!!!
   If you wanna be an actionscript 3.0 stud - start with this book.



3. I've been a fan of programmer's cookbooks ever since the famous Perl Cookbook ages ago. It's a great way to get into a language and do away with any nagging thoughts that maybe you didn't solve a problem well.
   
   This specific cookbook falls short, though. I tried to read it cover to cover as well as individual chapters, but I found it oddly balanced. For example, the authors waste three recipes on about 10 pages about generating a random number (which is just one command!), and then describe event handling (the big thing!) on half a page. I also find it strange to read about trigonometry in a programmer's book, and I don't think recipes work very well for explaining basic language features (such as how to create a new object, or how to "trace a message").
   
   Mostly though, the book is outdated with the release of flex2/3. Yes, Actionscript 3 is still current, but you don't roll your own buttons as subclasses of sprite anymore!
   
   In short, I give it three stars for content, and subtract 1 for being outdated. If you want to read about Actionscript 3, Adobe has a very nicely outlined pdf online, which is an easy read compared to these confusing and stale recipes.



4. This book is about ActionScript ONLY. when I bought it, I was hoping to find cookbook solutions for Flash and/or Flex IDE and all the step-by-step color illustrations and the cool visual effects that you can implement with those IDEs. That is not really what this book is geared for. So when I first started this review, I really wanted to give it a less-than-5-star rating, but I realized I can't do that in all fairness, because it does serve the purpose it portends. If you want an unadorned, pedantic, O'Reilly-ish how-to on ActionScript, this their ilk. If you want something with easy-to-follow illustrations on the Flash/Flex IDE and flashy visual effects, look elsewhere. Buyer beware.



5. In theory this book could have been very good. There were a few things that I did like about it. I liked the problem, solution, discussion approach to learning ActionScript. The book covered all of the topics I was interested in. It used real world examples to demonstrate the points.
   
   The reasons I gave this book a poor rating were the fact that it was written for Flex developers and all examples used the Flex tool to build (not very good for me who uses Flash), and they continually gave examples and explained how to solve problems using their predefined, custom classes. The pages would have been better spent showing us how to build these useful Classes ourselves, instead of teaching us how to use them. Luckily for me, I was already versed in ActionScript and could easily understand that these Classes were not part of ActionScript. If I were not, I think it would have been rather confusing to try to pick out their custom classes from what comes with ActionScript 3. I'm trying to learn ActionScript, not the custom Classes the authors have created.
   
   If you are new to ActionScript and not a Flex developer, do yourself a favor and buy a different book.
   
   _t

5 comments about Beginning Ruby: From Novice to Professional (Beginning from Novice to Professional).

1. Cooper's book is by far the best introduction to Ruby I've read as well as to programming in general for beginners. He strikes (for me, at least) the right balance of showing how-to as well as the rationale behind it. It is neither too shallow nor overbearing, but steadily builds on previous lessons, always careful to point out where to find further/more up-to-date documentation.
   
   Cooper's writing style is concise and clear. Examples are explained well. After having worked through books on AppleScript and Objective-C I wish they had been written by Cooper as well.
   
   5 stars!



2. I had heard quite a bit about Ruby, so I thought I would see what it had to offer. I went looking for an introductory book and found this one. I was hooked before the end of the first chapter. The author has an engaging writing style, and has done a great job of introducing the language and the community. The book is logically organized and presents the material in an easily comprehensible style. This is a great book for getting started with Ruby.



3. I have dabbled in programming, but never really rolled up my sleeves to learn a language... until now. Both ruby and python seemed like great choices, and I looked for materials to play with them. Both offer some very nice features and the ability to get up and running with something useful and fun easily, yet offer plenty of room to grow. After a short evaluation period, I think I just like the "feel" of ruby better, but that's totally subjective. After settling on a language, I looked for a book.
   
   I checked out Chris Pine's "Learn to Program", and of course _why's Poignant Guide to Ruby, and then this book. This one is, by a large margin, my favorite. Both Chris Pine's book and _why's guide have their moments, but in my opinion Cooper's book has a considerable edge in clarity and usefulness. It explains complex concepts in clear prose and then by example. I feel that I can tackle useful problems after having read the book. It seems to hit the sweet spot for being clear but not condescending, complex but not overwhelming. The examples are very applicable to many real-world problems.
   
   This book is more of a tutorial than a reference, which is exactly what I needed as a new programmer. In addition to being a great ruby book, it's also one of the best "tech" books I've ever purchased. It's rare to see this level of quality in technical writing. I really hope Mr. Cooper continues to produce programming books.



4. I wanted to use ruby on rails for my web applications, but after some failed attempts I decided to learn a bit of the ruby programming language first. This book guided me to the language, even if you are new programmer I completely recommend it.



5. Beginning Ruby is one of the easier books to following Ruby, and get a decent understanding Object Oriented Programming (OOP). If you don't want to fork the money over yet for this book like I did not knowing if I would understand (I just now have grown a big enough interest into programming to want to study), then I would suggest grabbing the book called Learn to Program from Pragmatic Programmer Series. In that book he runs through basic ruby syntax, and programs that actually function more or less like a BASIC application would. Once you finish the short yet insightful Learn to Program book, this book becomes even easier to follow. Once you make your way through this book though, you will want to more then likely purchase the Pragmatic Programmer Ruby book (The Red Pick Axe Book, which the 3rd version is due out in October). But from a novice programmer perspective, this is an amazing book and is always by my side.

No comments about Practical Django Projects (Pratical Projects).

5 comments about Core JavaServer(TM) Faces (2nd Edition) (Sun Core Series).

1. It's an excellent introduction text to JSF. I like the examples which you can try and learn from the coding experience. It however, is a bit weak on theory, like for instance lifecycles details etc. which isn't a big deficit considering that can be looked up easily. However, I do think a bit more theory in the first couple of chapter would make this book a stronger offering. As for rest of the chapters, the examples are clear and well suited for learning the material and the author's logic/explanations clear and succinct. The chapters are arranged logically, which means by following its order it build you knowledge up nicely. You probably should pickup a book that explains the h: f: tags in more details after this. But this book has the skeletons of everything which wets your appetite for digging deeper into JSF. Overall, a very good introduction.



2. Yes, this book will answer most of beginners' questions about how JSF works. No, after it answers them you'll still be looking for answers why.
   Yes, if you need to know *how* to program JSF then book's long examples will benefit you. No, if you want to understand *why* things are done that way then a lot of pages could be skipped.
   This book is much closer to being specification than it needs to be, but beginner will get good understanding of JSF foundation topics. So for every 'yes' - it's good, there is almost always 'no' - it was not enough.



3. This book is just loaded with JSF material. Google is still my first choice for answering JSF questions, but when Google can't do it for me, I can usually find what I'm looking for in here.
   
   A good book to have.



4. I'm disappointed in that the book focuses to much on how to accomplish a task without telling much about the architecture, why and how JSF operates behind the scenes. This results in that you don't exactly know what goes on, and thus don't know how to solve other specific problems. This is primary reason why I'm looking for another book about JSF.
   
   The book contains a lot of complete file code. Not necessarily bad, but keep in mind that the book might have less pure written text than you might expect.
   
   What I like about the book it doesn't only cover standard JSF, but also well known third party frameworks, like Apache Tiles, Facelets, JBoss Seam. Although again, it's also on that part more a how-to.



5. I recommend this book cause really you will familiar with JSF and in all technology needed in web application, for me I review some issue with this book such as JDBC and LPAP.
   
   I will give this book 4 stars, the one start losing for this book, cause really don't focus and mention enough the life cycle of JSF, for me I refer to another resource to can understand the JSF life cycle.
   
   Although this book really great. I read some reviewer said the Sun Microsystems don't put their brand-name in product low level of quality, I agree with him. Allthing realsed from Sun Microsystems I believe it.

5 comments about Pro Drupal Development.

1. Just a little warning, don't buy this book (like I did), if you want to develop for Drupal 6.
   
   Right off the bat I got in trouble, and even the first simple example won't work in Drupal 6..
   
   
   So, I'm not complaining, but I was stupid enough to buy this just before version 6 got out, don't make the same mistake, read online-tutorials or find a book that's intended for the current version..
   
   (Maybe hardcore programmers will still find this useful, but I could use example-code that works, and this doesn't, so you're stuck researching just about everything online anyway.)



2. The book is well written and edited. The information is clear and well structured. If you want to make your own modules this book will give you a good start.
   
   There is little or no information on CCK (Content Construction Kit) or Views which appear to be emerging technologies on Drupal. Little information on how to encorporate media into Drupal. There are no example sites or site construction strategy.
   
   People involved building Web sites tend to wear Rorschach ink blots rather than hats -- the content of the book looks more like a hat. If you are a Web developer, not Web designer or Web editor the information contained is up your alley.



3. This book is strictly for version 5, which they conveniently forget to mention. The current version is 6, so if you buy this book as I did, it is practically useless, as they have significantly changed the Drupal API.
   It would really be nice if there was a law requiring publishers of technical books to CLEARLY state on the cover the Version number.



4. An example of the right way to provide documentation for community-developed software. A great resource.



5. Excellent book. Well structured, with clear explanations, and no extra wording. I have been looking for a guide to understand how Drupal works and how it can be tuned and I have found what I needed in this book. Before this one I read another generalistic book about Drupal that did not manage to add any value in more than 200 pages of reading... what a difference! Congratulations. Keep up with the good work.

5 comments about Designing the Obvious: A Common Sense Approach to Web Application Design.

1. No non-sense approach in putting the detail by the author. Good read for the people developing web applications for generalized users.
   
   downside, author quoted examples from 37signals, apple and google - sublimely bashing microsoft when ever possible. From my standpoint I dont care if apple wins or microsoft wins, except when I pay for a book from an independent author to provide a unbiased view, should not feel like someone that works for apple or google wrote this book. If thats what I want, I would have bought book from those authors.



2. Not essential reading, but a really good little book. If you diligently follow companies like 37 Signals or other smart web application development practices, you've probably already thought of most of this. But it's nice to have it in a single, well-written, volume. One problem is that the author talks about "common sense" and "obviousness" as if they were universal, when they're not. It would have been nice to have some evidence from, say, the science of human visual perception to support some of the claims made here.



3. This book is to web application design what Steve Krug's Don't Make Me Think: A Common Sense Approach to Web Usability, 2nd Edition is to website design. Many of the same concepts are echoed, the style is fairly engaging (if you can bear the occasional coy "dear reader" kind of aside), and the publishing format is similar.
   
   I agreed with much of what this book said. For example, the author advocates:
   * Accommodating the users' mental models instead of forcing them to learn new concepts/skills
   * Turning "beginner users" into "intermediate users" as quickly as possible
   * Building applications that do one thing, or just a few very closely-related things, very well -- rather than ones with loads of add on capability
   * Understanding users, but doing lots of (iterative) testing (incorporating feedback into the next version for testing) rather than a lot of research upfront
   
   I had a few minor quibbles, including:
   * Many of the illustrations seem rather gratuitous, making me suspect that they were thrown in there simply to increase the length of what is a slim volume. (A contrast with the Steve Krug book, where the illustrations genuinely add to the information content)
   * The tone was a bit arch for me in places.
   * For some of the points he made, I thought that there were better example applications than the ones the author used.
   
   Nevertheless, this is a very easy and thought-provoking read. It will only take you a few hours to read it from cover to cover, but its recommendations will stand you in excellent stead for many years.



4. old but still good. buy it used it s not woth to buy it new.



5. I love this book for it's brevity, clarity and simplicity. While everything in this book is obvious and common sense, it is still amazingly useful. You should not underestimate your minds ability to ignore and distort such obvious things, especially when we are emotionally invested in the product. Reading this book is helpful when starting or reviewing a product.

5 comments about Making Things Happen: Mastering Project Management (Theory in Practice (O'Reilly)).

1. §
   Perhaps only a little off-key since I am not a project manager -- altho my professional life is made much easier by working with some dedicated ones.
   
   I did not read the previous edition as the other reviewers did. In fact, I was not really intending to read this edition straight through. I was going to give it a good skim for those aspects of project management that intersect my own world as a Web application interface developer.
   
   I have to say that Scott Berkun is a real teacher because I found the *whole* book to be relevant to my work -- and it was fun to read in the bargain.
   
   This book is not in color and does not contain lots of fancy images. The illustrating and illuminating is done verbally. For once, this was enough for me because Berkun finds a way to make things both practical and vivid. From the text, it is reasonable to assume that his public talks are worthy events.
   
   This is definitely a book to read for people who may not be project managers but who sincerely want to build their teams by understanding this important role better.
   
   §



2. Scott writes good books, from his own experiance (credible) and they are fun and easy to read. I learn something with every book. Read them all.



3. This is an outstanding book that speaks in a very practical way to the thorny problems that all projects face.
   
   Many project management books are either theoretical or case-study based. Both approaches are valid and valuable, but Scott takes a third approach. He offers up a series of lessons and practice around the various classes of problems project managers run into -- especially people problems. "No battle plan survives contact with the enemy" (von Moltke) -- and Scott recognizes that the enemy most often is not entropy or planning software or supply-chain delays. Rather it is the spate of well-meaning folks who populate real-world projects and bring their various agendas into play. He shares useful and practical ideas about "winning over the enemy" where you can and working with and around them when you can't.
   
   The book isn't entirely about people issues, of course, but the title "Making Things Happen" is indicative. How do you, as a project manager, work proactively not to keep your project from failing but rather to drive it to succeed?



4. In the field of project management, 'Making Things Happen: Mastering Project Management' is one of the finest books I have ever had the chance to peruse. From gathering ideas to managing teams and schedules, everything and anything is in this book that is a MUST BUY for all project managers or group leaders that want to update or learn new techniques for creating widgets in the real world and doing so efficiently and successfully. I think a chapter overview would be helpful to help the reader get an idea of the wonderous content contained within:
   
   01. History of Project Management
   
   I - PLANS
   
   02. Schedules
   03. What To Do
   04. Vision
   05. Ideas and how they come about
   06. What do to with your great idea
   
   II - SKILLS
   
   07. Writing good specifications
   08. Good decision-making
   09. Communication and relationships
   10. Process, Email, Meetings - Don't waste people's time
   11. When things go wrong
   
   III - MANAGEMENT
   
   12. Leadership & Trust
   13. Making things happen
   14. Middle-game strategy
   15. End-game strategy
   16. Power and Politics
   
   I was originally going to Highly Recommend this book but I think it's so fantastic I'm going to up it to HPR. If you are any way related to making progress at your job or possibly even life this can be useful, this book is a must read... NOW.
   
   ***** HIGHEST POSSIBLE RECOMMENDATION



5. Making things happen fills one of the gaping holes in MBA education. I learned quite a bit through trial and error over several years post MBA but this book would have been a welcome addition to any of my courses. If you have any reservations about managing projects, working in and leading teams, or generally being effective, get this book, read it cover to cover, and put all the great tips and insights to work ASAP.

5 comments about C# 3.0 Design Patterns.

1. I bought several copies of this book to teach my development team design patterns. I have a copy of and like the Head First design patterns book, but my guys wanted to learn some of the new C# 3.0 features and judging from the other reviews I thought this would be a decent book.
   
   Boy was I wrong. Do not trust the positive reviews. The examples and coresponding code samples are flat wrong. I don't mean code won't compile, I mean they don't teach the purpose of the design patterns or blatently defeat the pupose of them. I am only up to chapter 3 and I am having to create cheatsheets that show how the patter REALLY should work. If anyone is reading this and really wants to learn the design patterns, I would recommend the Head First or the original Gang of Four books. Beware, if you don't know design patterns and use this to learn you will be shooting yourself in the foot.



2. As with all books on patterns, I had high expectations from this book. I was really hoping that the author would have introduced new patterns utilizing new 3.0 language features that I have not yet thought of on my own, but was disappointed to see that the book is mostly another poorly written book on design patterns that happened to use C#.
   
   After realizing that the book was what it was, I was hoping that she would have done something a bit on the cutting-edge side of things by fusing new C# 3.0 language constructs and design patterns, but again, disappointed. The application of C# 3.0 features throughout the book seemed to be more of a showcase ("hey look what I can do") as opposed to practical or necessary.
   
   If you understand that this book is just another patterns book and doesn't introduce new patterns or really take advantage of new C# 3.0 language features, this book is ok. On a positive note, the book is a simple read. But if you're looking for a really solid book on patterns for the bookshelf, the gang of four patterns book (1994) is still the way to go.



3. This book was poor. The source code has errors. It does a poor job at explaining the issue a pattern is attempting to address. Made me very sleepy. If you want a good primer get "Heads Up Design Patterns", if you want more get the GOF book.



4. Lets face it design patterns are something that we have to have but at the same token are usually difficult to understand where it should be used and how to create it. With design patterns C# 3.0 By Judith Bishop we have a little more help.
   
   From structural patterns to Behavorial we can all feel a bit better in designing our tiers for robustness and making things just a slight more easier on ourselves. When i had to create a protected class for an application that i was working on. I had difficulty creating protecting it from instantiation with the guidance in this book i was able to complete the application in less time and focus on other areas of code that needed improvements. I also found use for the decorator pattern, while i will admit some patterns in the book seem like a lot of work to include in an application Bishop makes the case for each one and also describes situations where patterns may be become anti pattern for example using the Singleton pattern to hold static information as a global variable.
   
   Overall, the quality of this book is top notch (figures since it is a O'reily book) and offers many sections on how to enhance your coding practices to make best of your limited time and also of your program. The examples in the book are superb and offer a introduction to what i feel is one of the more complex ways of designing a program. It also has a fair bit of UML diagrams and is "decent" practical guide to also adhering to UML based designs.
   
   Something though i wish they had in this book were more samples, at times there seems to be decent coverage on some of the easier patterns (singleton) and not so much on the more convoluted patterns like Model View Controller. While she does try to create a balanced ground sometimes, i have to re-read the section because she gets to technical sometimes. I guess with time and over the years her thoughts should become more clear.
   
   - Mike



5. Overall, the book seemed pretty useful. Some of the patterns covered in the book are probably rarely used in the real world, but others are design patterns that we use as software developers pretty constantly without realizing it. Getting a formal definition of what those are, and all the different parts involved ... as well as when it is a good idea to use it or what other pattern might be a better fit really offers some value. It was a pretty short book, so I thought it was worth the investment of time to read it.