5 comments about Macromedia Flash Professional 8 Hands-On Training.

1. This is a great book. It gives an introduction to learning flash for beginners. Easy to learn step by step instructions along with the CD exercises.



2. I bought this product for another person and they loved it. It helped them in their understanding with Macro media flash professional hands on training. I can recommend this book to someone who needs a better understanding of how this works.



3. If you are farmiliar with other Adobe/Macromedia software (like PhotoShop, Illustrator, etc.) the transition to Flash using this book should be realitively easy. I learned some new tricks/shortcuts and the sample files included on the CD are helpful. I am very pleased with this book and would recommend it if you know enough to get around in Flash but aren't comfortable.
   
   If you are completely new to image/animation or web design software I don't believe this book will help you.



4. I wanted to add some dynamics to my web pages and I got Flash 8.
   I needed a book so I bought this book. I found the book very helpful
   and useful



5. I'm always apprehensive about purchasing tech books so I normally go to the library and check them out for a few days before the purchase. With this book I didn't do that and I must say I am pleasantly surprised. The exercises are interesting and easy to follow. The tutorial CD is also quite good.

2 comments about Programming Windows Embedded CE 6.0 Developer Reference, 4th Edition.

1. In my opinion, it is a very usefull book.
   It contains good descriptions of many aspects of CE 6.0, with code example and nessessary details for good insight into underlying principles.



2. This is a very good book if you know C++. The indicated SDK that is required to compile, is not available so none of the examples work asis. I would have given the book 5 stars otherwise.

4 comments about C++ How to Program (6th Edition).

1. I started learning C++ with the "Teach Yourself C++ in 21 Days" book. Bad mistake. Stay away from the '21 days' books. The examples were bad, bad explanations, and bad programming practices.
   
   I then picked up Deitel's C++ How to Program 3rd edition. I learned much more from that book with it's good program examples and somewhat muddled writing. The 3rd edition had long winded, robot like explanations. It got the job done, but it was a bit of a hard read to get through.
   
   The new 6th edition is a must get for the beginner or as a reference book for programmers already versed in C++. Unlike previous editions, the great thing about this book is that it starts using classes from the beginning of the book and teaches the basic concepts such as control structures, stream I/O, functions, etc. through the use of classes.
   
   There are also new sections to this book. I am learning C++ as a hobby to create games, and the game programming section looks exciting. It uses the Ogre library (www.Ogre3d.org) to create a colorful game of Pong, and it explains in detail the code and introduces the general topics of sound, graphics, lighting, etc.
   
   If you're just picking up programming for the first time get this book, you won't regret it.



2. My teacher is using the 5th edition, but I have the 6th edition, and it is not a problem. The assignments are the same, so buy the 5th edition since it's cheaper. I think there are a few kids in my class that are using the 4th edition without any problem, but I don't know for sure.
   
   Programming is a hard thing to learn, so it would be unrealistic to think this book will magically teach you. However, I think it does a decent job with a very hard subject. The best way to learn is by trying to program, but if you get stuck, the book is probably not going to be much help.
   
   It also teaches about classes before you learn about functions, which makes almost no sense to me. If you don't understand functions, classes are impossible to understand other than in theory. And learning things in theory does not help you!! (It does later when it all comes together, but if you don't understand the first steps, you will never get there!)
   
   If you are buying this book to learn (and not for a class), get the 3rd edition because it teaches functions before classes. C++ has not changed significantly, so don't worry about it being old.
   
   The CD that comes with the 6th edition has Visual Studio Express Edition, which is FREE software that you can download from Microsoft anyway. If you buy used, you do not need to make sure you get the CD.
   
   I believe that previous editions actually had some content on them, like code samples, questions, answers, etc. (Again I don't know for absolute sure, because I don't have them.)
   
   The 6th edition has a code on the inside cover, you scratch it off and it lets you set up an account for the "Cyber Classroom." The cyber classroom has the entire book online, along with audio samples of people explaining things. (I have never listened to them, so I don't know if it's good or not.) If you don't have the book or your code has already been used, a subscription to just the cyber classroom costs $60 all by itself.



3. Picked this book up two weeks ago and I've been reading several different sections.
   
   Negatives:
   1) Examples are too long.
   2) Chapter on classes too early in book. Several basic chapters occur afterwards.
   3) Structs aren't mentioned till almost page 1000
   4) Bad need of chirp short points
   5) Lacks harmony in layout - subjects appear somewhat disjointed.
   6) I find the miscellaneous tips and points distracting.
   7) Horrible index, if one word is listed in a table, there's a page number for it.
   
   Positives:
   Easy to read, the multi-color is awesome when reading the code and staying focused.
   Good chapter on STL and templates
   Full examples are sometimes useful for full understanding.
   Explanations on subjects seems good, as long as the sample code is short.
   Book seems to include everything on the subject of C++. And some more.
   Lots of details on each point
   
   This book is dying to become a standard, but it misses the mark. It can't decide weather to be a reference book or tutorial. It would be nice to see a split design on the chapters with some quick examples.
   
   I think I rated it a little low, but I could not give it 4 stars. I have another Deitel book on C#, and while this one is a little cleaner, (and in color), they could cut 20% out of this book and still have a good product. However, with that said, if I could only buy one book on C++, this might be the one.



4. If you want to learn C++ and C++ in OOP, then this is not the right book for you. This book is written so badly that it is very hard to understand it. I suggest for any students or even programmers to pick up the C++ book that is written by Tony Gaddis and it is so well written that is #1 book among students, teachers and programmers. I have lost all my respect for Detiel books for any programming languages. I don't know why they even teach Detiel books in Colleges and Universities when all proffessors are saying is that this book is not well written.

5 comments about The Non-Designer's Design Book.

1. This was my first book about design. To the point, the book discusses the four basic principles of design with good/bad examples to make his point: contrast, repetition, alignment and proximity. It's an easy read and will provide the nessary foundation to move on to more advanced material.



2. My son needed this book for his 1st year at the community college. The book store didn't have it and I found it online with Amazon. It is exactly what the instructor required.



3. I started reading this book yesterday afternoon because I wanted to spruce up my business card. The author's introduction & explanation to basic design principles was clear, easy to understand, & illustrated with plenty of visual examples. I've always been a hobbyist designer, initially relying on MS Publisher templates to put things together but then gradually started making my own designs from scratch over the years, so I thought my initial design for my business card was pretty good. But as I read through this book, the author gave several examples of amateur mistakes, many of which I was guilty of. But then the author also gave examples of how to fix these mistakes by employing the design principles she explains. This is probably one of the most useful books I've ever purchased!



4. 
   Once again when a real expert writes a book the complex can seem so simple. This is a gorgeous book. She shows you exactly what to do about keeping items with intellectual connectivity proximate. She holds forth on how to best use Alignment, Repetition, Contrast and Colour for print, web and all types of content. Thoroughly done asd 100% enjoyable ot read. I loved the sections on Fonts; begone Arial/Times Roman !



5. The Non-Designers Design Book is well thought-out and organized. I come from a programming background and my ability to design visuals is limited, so whenever I find a book that can shed light on how designers think and put it in terms that a programmer can understand I am all for it. If you are a designer I think this book would be too basic for your liking, but us non-designers it is as simple as it gets. Do not get the wrong idea the information may be presented in a simple organized way, but the information is very valuable. I would have liked more examples for the web, but the concepts can easily be translated to the web. It was a pleasure to read and I recomend it for any non-designer. I give it four out of five stars.

5 comments about Lessons Learned in Software Testing.

1. My opinion about this book is that this is very useful in order to learn about the facts that happens when you need to lead a group of testers, basically. To read this book you need a previous experience as a tester, in order to understand very clear the ideas. If you have this experience , great!!!!! The book is very very graphic about the facts that happens when you do your job as a testing leader.



2. Lessons Learned in Software Testing
   
   As a new QA tester I have found that books written by Cem Kaner and associates are extremely helpful. This book in particular (Lessons Learned...) has been a wonderful help to me. I was able to be on guard before I had to learn the lessons the hard way. This book is easy to read and to the point. It is written in a way that the layman can easily uderstand it. This book is extremely insightful and is a good buy for anyone new to the field or not.



3. Through a series of nearly 300 "lessons", the authors share their accumulated wisdom about how to test application systems - not so much which buttons to press but more how to establish and manage a test team, plan the work and dynamically adjust the testing process according to what is found and how much time is left.
   
   The chapter titles ably illustrate the book's scope: 1. Role of the tester; 2. Thinking like a tester; 3. Testing techniques; 4. Bug advocacy; 5. Automating testing; 6. Documenting testing; 7. Interacting with programmers; 8. Managing the testing project; 9. Managing the testing group; 10. Your career in software testing; 11. Planning the testing strategy; [Appendix] The context driven approach to software testing.
   
   I would definitely encourage anyone who thinks `test automation' is a great idea and is perhaps contemplating the purchase and use of automation tools, to read chapter 5 before they commit the budget and finalize the project plans. The authors eloquently explain the advantages and disadvantages of common automation techniques such as user input replay tools, providing a real-world counter to the tool vendors' optimistic sales pitches. They don't say "Forget it", rather "If you can live with these significant drawbacks, automated testing may be useful for a certain subset of testing activities". This is a good example of the pragmatism and wisdom found throughout the book.
   
   The book is not an academic treatise full of theoretical constructs/models and testing methodologies. Nor is it a step-by-step manual on how to test a system. It is an excellent read for testing practitioners who are seeking or at least open to advice on how to do their jobs more effectively and efficiently. "This book is for anyone who test software, anyone who manages testers, and anyone who has to deal with testers in their software development projects. That includes project managers and executives." The hints and tips plus career development advice are valuable for testers, especially if they have a few years testing under their belts already. The technical content is minimal and should be readily understood by any IT professional while the management advice should be appreciated by those with management experience or who aspire to become managers.
   
   The book strongly encourages testers to work with developers and project managers, becoming an integral and valuable part of the team rather than an impediment to progress and a threat to delivery deadlines (lesson 12 is typically direct: "Never be the gatekeeper"!). The subtitle's reference to being `context driven' introduces a dynamic approach to testing, relating test activities to the development lifecycle and promoting those that will be of most help to the project at any point. The approach is described further in the appendix but is only subtly referenced elsewhere, unlike certain other books that insist on pushing their One Big Idea down the reader's throat at every possible opportunity.
   
   All three authors clearly have solid testing experience, some 60 work-years between them. There are also numerous (but not intrusive) citations to other helpful resources, further demonstrating the authors' pedigree. Cem Kaner, a consultant and IT professor at Florida Institute of Technology, was the lead author of Testing Computer Software, 2nd Edition, one of my all time favorite IT books. Cem also practices law. James Bach is the founder of a software testing and QA company with silicon valley experience. Bret Pettichord is an independent consultant who edits the Software Testing Hotlist and founded the Austin Workshop on Test Automation.
   
   The "lessons" format leads to a somewhat disjointed flow in places although overall the book is well-structured. At times, successive lessons are directly contradictory, again emphasizing the need for readers to be both alert and open-minded. This is another example of being `context-driven'. Which lesson you choose to follow depends on the circumstances facing you, a form of contingency planning if you will.
   Unusually for a published book, several critical comments from reviewers of the draft, as well as occasional differences of opinion or approach between the three authors, are included as footnotes or asides. The authors openly acknowledge the ambiguities and leave the reader to think about them and make the final decision - I like that. This is a book for grown-ups. There are valiant attempts to describe and promote `the tester's nose', that seemingly innate ability of experienced and successful testers to sniff-out aspects of the system that are likely to harbor serious bugs and to design targeted tests that will reveal them. The advice on unstructured `guerilla testing' is not quite so useful, in my opinion, but I'm impressed that the book even tackles such ephemeral concepts.
   
   Even if you only learn something new from a few of the lessons, this book is well worth the purchase price. Testers relatively new to the profession will learn more than grey-beards but even they will probably find some of the suggestions make them re-think long-established ways of working (habits) and subconscious assumptions (prejudices). In the main, the lessons are pragmatic. Some are a bit contentious, perhaps deliberately, and most are both thought provoking and helpful.
   
   Bottom line: recommended for any thinking person involved in application testing including development project managers and IT auditors.



4. This is a good text on how to avoid time consuming mistakes in software testing. Experience is the best teacher around and this encapsulates that. This would be a good book for the novice to learn from. It may save you from going down a "rat hole" in your testing thus wasting time and resources.



5. *This book is a must for those organizations that has trouble figuring out how to slash down their budget without sacrificing their effectiveness in shipping quality software.
   *This book will open your mind that spending much time in creating test steps is Good but not excellent.
   *This book is unique. The author will not force you to follow what is written inside but instead give you idea to invent your own model cognitively.
   *This book will never be obsolete because the lessons stated inside is generic. I always bring this book wherever I go until I memorized it all.
   *I have so much to say but to make it short this book passed my criteria in my own idioms.

1 comments about Microsoft Visual Basic 2008 Express Edition: Build a Program Now! (PRO-Developer).

1. I've tried several MS press books in the past and found them not really very useful. I'm from the Java side and familiar with the concepts and approaches for .NET, but have never used any Visual Studio based products directly.
   
   This book was perfect for my needs. I was able to get the Express C# package up and running quickly and build out the projects in the book in about a week. I thought the level was perfect for me. Just the right mix of hand holding and intro to most of the general concepts. I think MS did a great job with this book and also with the packaging of the Express Edition software.
   
   For a very small investment (dollars and time) one can get a great feel for the MS development environment with this book.

No comments about Struts 2 in Action (In Action).

5 comments about Applications = Code + Markup: A Guide to the Microsoft Windows Presentation Foundation (Pro - Developer).

1. Written by a professional for the professional! This book reminds one on how things aught to be done in C# and gives an insight of WPF and its mechanics. A must have book for the serious developer and even the amature will benefit from Charles Petzold insight.



2. I think that Petzold was reading my mind when he wrote this book. I don't like XML, and I don't like "cheating" with XAML when you can write good clean C#. The first half of this book is entirely C# programming in WPF. I am using this book to help me write an abstraction layer above WPF. That simply would not be possible with XAML, which in my opinion places the design of the application at too low of a level. Petzold leaves no stone unturned, and whenever something seems weird, he doesn't ask us to trust him that it makes sense; he explores it in depth for us. I can't imagine that many other authors go through that kind of trouble when they're writing on tight deadlines. Petzold tells it how it is, and he includes the "why." Therefore, I recommend this book to anyone who strives to become a bit of an expert in WPF, not just a get-the-job-done programmer. I would consider this an advanced book at times because I find myself reading and re-reading sections to understand it. The explanation is there, but it's not trivial, and with so many pages in the book already, there is no room to be wordy.



3. I've been a Windows developer for around 10 years or so and have read dozens of developer books. This is only the second one I can remember returning.
   
   I had previously read Programming Windows Presentation Foundation (Programming) (which I recommend) but was looking for more. At 900+ pages, and with the good reviews and experience of the author, this book looked like a good choice. Unfortunately, after the first 450 pages, I decided that my time would be much better spent simply rereading the the Chris Sells book instead.
   
   The main problem is the style in which the book is written. It could easily be edited down to half its size. How many times do I need to read "Button btn = New Button()" in a code example? I know some people prefer fully functional examples over code snippets but after a while it really got ridiculous. The code examples eventually became almost useless to read because it became so much work to sort out the irrelevant and insignificant details. On top of which 90% of the code samples are examples of THE WRONG WAY to do a UI in WPF (i.e. in C# instead of XAML). I understand the second half of the book is all XAML, but spending 450+ pages on techniques you would NEVER ACTUALLY USE is a waste of my time.
   
   A lot of bloat also came from a lack of focus on who the book is written for: experienced .NET/C# developers. I don't need to have "using" statements explained to me, I know how .NET dialogs work, etc... From the "Printing" chapter: "The Print dialog also includes a Number of Copies field. Enter a number greater than 1 in this field and the PrintVisual method prints multiple copies." Really. I never would have figured that out on my own.
   
   There is a lot of good information here but it is simply not worth the time it takes to extract it from "Button btn = new Button()" statements. Maybe this book is a demonstration that you're never to old for an editor. I'm going back to O'Reilly books.



4. This book seems to have had several negative reviews.
   The gist of most people's complaints seem to be:
   
   (a) "There's no XAML until Chapter 19" and/or
   
   (b) "There aren't any pictures".
   
   The Complaints - are they justified?
   
   a. No XAML
   
   People making this complaint have in my opinion totally missed the point for several reasons.
   
   Firstly, this is not Charles Petzold's "How to Write XAML" book. It's a book whose title explicitly tells you that it will approach WPF from both the code (C#) and markup (XAML) perspectives. Unusually (actually I think it is uniquely) he doesn't mix and chop up the two approaches, but deals with each of them in isolation.
   
   Secondly, WPF is not XAML. You can use XAML, sure. You'd be silly not to in many situations. But XAML is only one part of the big picture. As this book clearly shows, you can successfully create an awful lot of WPF output with code alone.
   
   b. No Pictures
   
   Normally I would have some sympathy with Complaint (b) because it's always nice to see what the code samples should produce. But if you use this book as the author intended and actually run the samples yourself you will gain far more than any quick glance at a screenshot would give you. You will gain insight and experience in how to master this new technology.
   
   The Book
   
   This is a book that very carefully works its way through the requirements needed for the reader to achieve a thorough understanding of the major concepts. One of the reasons why I recommend reading it - and using it - from cover to cover is that, even in the early basic chapters little gems of code and explanation are slipped into the narrative or the examples. Often these begin to deal with more complex topics that you will come on to in more detail later.
   
   It is crammed full of detail. Mostly it's the kind of detail that you really need once you've got past the "let's play with WPF and see what you can knock out in a couple of hours" stage. The detail you need when you move on to the point where you want to do something that isn't necessarily easy out of the box, but is achievable if your understanding is built on stone, not sand.
   
   If I have a complaint, it's a minor one: occasionally he lets the Math geek get out and play a bit more than strictly necessary, but even that is fairly rare.
   
   The code samples are in C# only. However, Young Joo on the VB Team at Microsoft has organised for some chapters to be translated to VB.NET and there are more to come. You can access them from here: http://blogs.msdn.com/vbteam/archive/2008/01/07/petzold-wpf-book-sample-conversion-new-chapters-young-joo.aspx .
   
   Summary
   
   If you are committed to fully understanding WPF then this book is one you really should buy. By all means get others too. I already have several; they all serve their purpose, are very useful and I refer to them regularly. But when it comes right down to the "roll your sleeves up, go sit in a quiet place with book and PC to learn, really learn, WPF" then I think Charles Petzold has produced a (not so little) gem that will be truly helpful to you in your learning endeavours.



5. Each chapter is well thought out and develops like a good narrative. Chapters are typically 20, 25 pages and thoroughly explain a central concept. They often end with a nice lead-in to the next chapter, like "this works, but what if you wanted to ...?"
   
   When first published, no one knew what WPF things like StackPanels looked like, so people wanted screenshots everywhere. The book uses a series of concise console applications to demonstrate WPF concepts, and I'm glad it does. With a screenshot on every page, the book would be 50% thicker or have less detailed info.
   
   Other books have their place. I have 4 or 5 because I like to approach a new topic from several points of view. But for taking a programming concept and building the explanation in clear, logical steps, no one does it better than Mr. Petzold.
   
   Whether you are going to build next-gen Windows apps or develop Silverlight 2 applications, learning WPF and XAML is essential (just as web designers must sometimes work directly with html).
   
   Visual Studio and Expression Blend make assumptions when you drag elements onto the design surface. It's just easier to work directly in XAML usually, rather than delete extraneous properties the tools add to your code.
   
   Some criticize it takes half the book before delving into XAML. It's worth noting that anything in XAML can be done in C# (or VB), though some things are simpler and more readable in XAML markup. By the time you get there in the book, if you know anything about XAML, you'll fly thru the pages, filling in gaps about how code and markup work together seamlessly.
   
   I cannot imagine thoroughly understanding WPF without having this book's comprehensive explanations available to me. I think it's a terrific book that will stand the test of time.

No comments about SQL Queries for Mere Mortals(R): A Hands-On Guide to Data Manipulation in SQL (2nd Edition) (For Mere Mortals).

5 comments about Oracle Database 10g PL/SQL Programming.

1. This is book did help me learn PL/SQL; however, it did it in a very painful manner. The book could have easily been condensed to half the size and still convey the same information, only clearly and to the point. Many of the chapters have long coding examples that are followed by a line-by-obvious-line description about what is going on. It's tempting to skip the code explanations; however, there is the occasional hidden piece of useful information in them that forces you to sift through the junk. To make matters worse, much of the code is needlessly commented. You know what type of comments I'm talking about; there will be a comment that reads '-- declare a variable of type varchar' and then a declaration immediately afterward. Wow, thanks for doubling the code size and killing some more trees. Topping that off, in some of the examples, the comments don't actually match what the code is doing. Grrr.
   
   I invested a lot of time in reading this book and after it was all said and done my feeling on it was, meh, I guess I learned something. The book is pretty good, it's just needlessly big, too big and time consuming for the value that it brings to your skill set.



2. This is the best pl/sql book ever!! It's a complete reference for PL/SQL programation lenguaje, that covers from the basics topics like data types to advanced fueatures like inter-session comunication. Its includes hundreds of examples, online code and a complete reference for Oracle 10g packages and utilitys. This is the ultimate PL/SQL book.



3. When I started studing PL/SQL...
   I got recommanded this book.
   Now I satisfied my choice because of contents of this book.
   I recommand this book.



4. Let me start by stating that I agree with Frank N. Loreti's review of this book, and one part in particular: this book was not written by educators. And I would like to add that they don't seem to be terribly good writers, either.
   
   Some examples from the first three chapters (plus one page of chapter 4) to illustrate my point:
   
   On page 72, it reads: "Boolean variables, when combined with an IF-THEN block, do not need to be provided with a comparison value if only comparing to TRUE." First, Boolean variables aren't "combined" with an IF-THEN, they are *used* as part of the [Boolean] condition of the IF-THEN. And second, writing that they don't need to be provided is, educationally speaking, not very wise; it suggests that it's a specific feature of the language, a short cut if you will, when in fact it's a mere consequence of how the evaluation of Boolean expressions work.
   
   On pages 108 and 109, I think it's a glaring omission that the writers don't mention whether the PL/SQL CASE statement uses 'fall-thru' or not. For several reasons, I don't expect this to be the case, but if it's not used, how is the 'CASE with different variables' treated? In other words, in the example at the bottom of page 109, is only Steve printed, or all names? Come to think of it: in the example before it, what happens if the conditions in the CASE overlap? (E.g., change the second WHEN-condition to
   v_price BETWEEN 30 AND 50
   What happens then if v_price equals 35? Will only the first WHEN-statement block be executed? Will both be executed? Will an exception be thrown? Less likely, but not impossible: maybe a compile-time error is given?) It's hard for me to understand how any decent programmer can overlook the fact that these 'details' need to be discussed.
   
   On page 110, loops are discussed: "We cover three different types here: Simple loops. The most basic kind of loop, they include LOOP, END LOOP, and some method of EXIT." Since 'different types' of loops are discussed, the plurality in 'Simple loops' suggests that there are several types of simple loops --and it seems they are called the 'LOOP', and 'END LOOP'... or something. Of course, this is not the case: there's only one type of simple loop. It starts with the keyword LOOP which is followed by a statement block that may/should contain an EXIT statement, and it ends with the keywords END LOOP.
   
   You don't have to be a professional writer to sense that you can't end a section with a couple of bullet points (just like, apparently and unfortunately, you can't end a chapter without a useless summary) so you'll need at least an extra line of text, but unfortunately the writers of this book don't have the finesse to cross that bridge unnoticed. For example, at the beginning of chapter 4 a list of topics for that chapter is given in bullet points, followed by the following recommendation:
   
   "As these features are demonstrated, think about how they can be used to improve the functionality, performance and design of your applications."
   
   It's suggestions like these that simply make my toes curl.
   
   Add to all this the absence of a decent structure (the books keeps jumping from simple features to advanced features and back, fragmenting the explanation of both), and the authors should consider themselves lucky I'm still giving this book 3 stars...



5. I "subscribe" to this author and publisher for texts on this topic. I like the writing style and layout of the book. There enough explanation to be thorough, and enough practical examples to be useful outside of pure theoretical discussion. Plus, there are plenty of references in the appendix, so those pages are essentially a "Nutshell."
   
   However, I think I prefer the layout of the 9i edition. The flow was nicer: a structured outline, then some examples. In the 10g edition, the flow seems to have changed: a briefer description in paragraph form, then a lot more examples.