5 comments about Programming in C (3rd Edition) (Developer's Library).

1. This was the only text required for my college level C-Programming Course. I honestly didn't read as much of it as I should have. I did feel that most of the examples were thorough and helpful.



2. The book covers the subject matter very thoroughly, albeit in a very simplistic manner. The code samples perform very rudimentary operations and I found it difficult to combine find the syntax for combining multiple coding concepts into the most concise way. The writing style is easy to follow and the code examples are well explained - much like the Safari books.



3. I was required to purchase this as a textbook for college. As I have no programming experience, I really wish I had a way to check my answers to the exercises. Unfortunately, the link provided in the textbook does not work. The author has not answered my email. There is also no working link for errata.
   
   Don't buy it if you don't need to because it's useless without a working link for errata and answers to exercises. Hopefully that will change someday soon, but until it does, I can't recommend this book to anyone who is learning C.



4. I finally feel that I've actually learned and internalized C, after having less than positive experiences with many other C books. I absolutely feel like I really know and can use C now; It's finally "clicked".
   
   This book teaches by example, builds upon previous learnings, and won't waste your time on esoteric or irrelevant details that you can simply reference later if and when needed. This educational approach is absolutely effective and is very refreshing.
   
   I really love this book. If you read it, and do the exercises, this is the only book you'll ever need for learning C.



5. COVERS MANY TOPICS BUT DOES NOT GO INTO DEPTH ON THEM. USEFUL INFO ALTHOUGH

5 comments about Intermediate Perl.

1. I didn't like the storyline, but I did learn how to handle anonymous arrays better.



2. I picked up this book for a class that I was teaching at my office. The goal of the class was to train HTML/CSS/JavaScript and/or Java programmers to code in Perl since a large portion of our code base is written in Perl. Overall, I think that the book was a good choice for the class for a number of reasons.
   
   First of all, the book is already written with a classroom setting in mind. The authors have used previous versions of the book, titled "Learning Perl Objects, References and Modules", for their own courses. This updated version benefits from all of the hours of empirical testing that it has received in the classroom. There are many thoughtful additions like having all of the chapters close to the same size. This allowed for me to assign a single chapter per session and know that I could comfortably fit the lecture and discussion of the chapter into a two-hour session. There are also exercises at the end of each chapter and answers for those exercises (with discussion) in an appendix.
   
   This book is good for getting people just learning the language ready for the TMTOWTDI/TIMTOWTDI aspect of Perl. Take something simple like opening files... there are at least four 'standard' ways to do it. The book prepares you for all of the different versions of annoyances/features like this that show up in Perl code by walking through the evolution of the feature.
   
   Another reason that I like this selection of book is that data files and code examples are actually available for download. I've been shocked that some of the programming books that I've gotten lately actually don't have this addition.
   
   Finally, the course that I'm teaching is for people who probably already know how to program, at least a little, but they don't know Perl. I didn't want to drag them through all of the picky details of the language by starting with "Learning Perl" or something equivalent. This book has been a good choice for introducing programmers to Perl. I do have to stop occasionally and explain some fundamentals of the language, but not too often... maybe I just work with smart (or shy) people :)
   
   Of course, the book isn't perfect. As odd as it seems, one of the biggest complaints that I get is over the Gilligan references that are used in all of the examples in the book. There is also some coverage of packaging modules for CPAN. This is useful, just not for the particular class that I'm teaching, so we skipped that chapter. Of course, both of these complaints are pretty weak.
   
   In short, this is a good book, especially if you are doing a training session about Perl.



3. If you've mastered The Llama, make haste to read this one. Even if you only want to do scripting with Perl, you'll eventually find you need data structures slightly more complicated than just flat arrays and hashes, and you need to know about references for that. While The Camel does contain a fair chunk of material on just this subject, it was a bit too much for me to digest after The Llama. If Intermediate Perl (aka The Alpaca) had been around for me to read, I would have had a much easier time.
   
   Written in the same style as The Llama, this breeze through most of the rest of Perl, in particular: references, objects, packages and modules. These are the bits that you need to use Perl as a general purpose programming language, not just for scripting. In a similar pragmatic vein, it also covers how to use tools to build your own packages in the CPAN style, and there's a good chunk of material on using Test::More for unit tests. Probably the only thing missing is material on type globs and symbol tables, although hopefully, brian d foy's forthcoming Mastering Perl will fill in these gaps.
   
   The bottom line is this is Llama part 2, and you need to read it if you want to have any hope of understanding anyone else's Perl. But I can't give it five stars. The major problem is that the material is not very well organised. At the chapter level, objects are sandwiched between modules and packages. It would have been far preferable to keep the module and package information together. As a result, the distinction between modules and packages is rather muddied, and the introduction of objects in the middle just makes things worse. Overall, I found the explanations to lack the clarity of the Llama.
   
   A more minor complaint is that, while there are mercifully fewer annoying footnotes, the Gilligan's Island theme (if, like me, you had no exposure to this growing up, you might want to read the Wikipedia article first!) grates far sooner than the Flintstones flavour of the Llama.
   
   That said, make this your second book on Perl. Then, _still_ don't read The Camel yet. Avail yourself of Perl Best Practices first.



4. Successors are not always as expected. In this case you do get from this trio of authors, who are classics in their own right, just what you expect. In my own case, I needed to get good at OO Perl and fast. In three days, I covered the major chapters thoroughly, went off to my interview and in the end was told, "hey, you really know your stuff". This book intends and does indeed follow well the Learning Perl classic. If you finished the meat of the classic, this is the dessert. You'll recognize the writing style and flavour. There are no surprises. In my opinion, another classic.



5. This book has good perl examples and good perl code. It is a good choice if you have an intermediate understanding of the perl language.

No comments about Modern Systems Analysis and Design (5th Edition).

5 comments about Effective C#: 50 Specific Ways to Improve Your C# (Effective Software Development Series).

1. I agree with those who say that Effective C# is not for beginners. Even experienced programmers should go elsewhere for an introduction to the language and the .NET environment. While other books might serve as a comprehensive textbook for learning the rudiments, this one offers some in-depth insights into how to build solutions that are elegant, efficient, reliable, and maintainable.
   
   I also agree with those who are disappointed in the poor editing. The book is riddled with typos, especially word spacing problems. Mostly, these are little more than a minor annoyance but they make the book a really poor example of publishing quality.
   
   "Software engineering" has been described as finding the best solution for a given problem where "programming" is merely a matter of developing something that works. That's what this book is all about. Sure, there are going to be times when you don't need to build the kind of quality into your code that the author advocates. The need to get something done quickly will often outweigh issues like whether you're really getting optimal performance, whether accepted OO principles are always being followed, or whether your employing the best of all possible solutions. But this book is about how build "industrial strength" classes that can be reused without breaking or creating undue heartburn for the poor slobs who have to rely on them.
   
   Like most programming books, lots of the information is conveyed in code examples. However, this is not the book you'll want if you're going to cut-and-paste somebody's sample program and hack it into your own working version. In fact, the code examples are so brief and simple that they often seem almost pointless at first glance. As you read the explanations, which are more punchy and to-the-point than they are eloquent, you begin to grasp the essence of the principle being explored. Personally, I feel there's room for improvement in Mr. Wagner's writing style, which can be a little too concise to be really illustrative, but he does get his message across.
   
   Possibly the book's greatest strength lies in the rationale given for the recommendations offered, as opposed to the recommendations themselves. The fifty items are more than a series of "best practices" to be blindly followed whether you understand them or not. Good programming is often a matter of choosing from a set of alternatives by weighing the value of each approach, assessing trade-offs, and making intelligent decisions. That's where this book can really help.
   
   Evidently, this book carries on a tradition of "Effective" books in that it consists of a series of relatively short articles, each of which illustrates some very focused aspect of how C# code is compiled, the nature of certain .NET Framework types, and/or how the CLR operates. I, for one, think a more conventional format, where the content is broken down into longer chapters that go into major concept areas in depth might have been a better way for Mr. Wagner to share his obviously thorough knowledge of the subject. At first glance, this book gives the impression of being a set of little hints and tricks, as opposed to the serious technical book it really is.



2. Excellent book. My only complaint -- where's the new edition for the new version(s) of the framework?



3. While C# is pretty easy to get up to speed with coming from a C/C++ background, the similarities can lead to costly blunders! .Net/C# is a "real" language and as such deserves the respect of any self-proclaimed professional. This book is a great resource for getting that first glimpse to advanced topics that every pro should strive for. It's an easy read and the format (recipe) lends itself very well to quick reading sessions that stick in your mind. Your coding style will invariably change for the best upon closing this book. Simply stated this book should be mandatory reading for anyone joining a .Net project but coming from a traditional language (C/C++).



4. This book has helped me identify and made some performance improvements to my C# software code. One thing I like about this book, is that the author cuts right to the chase in his explanations and gives excellent supporting code samples in cases where needed.



5. This book would benefit greatly from a rewrite. It is often difficult to follow the authors' logic. I get the impression that this book was rushed to print. A simple example of this is the fact that all the left-hand pages are incorrectly indented so that they run into the binding of the book. Please adjust your publishing software!

5 comments about An Embedded Software Primer.

1. I am in embedded world for 8 good years and brought this book to know something which I dont know. This book is purely for fresh graduates out college.(that too only when they havnt worked hard in their courses) also if you have been in industry but didnt get chance to work on actual system then this can be of little help for you.
   
   Dont buy it if you have already spent a couple of years on actual systems. You wont benefit much.



2. I've done quite some application software design. But I'm totally new to embedded software design. I found this book is very useful for me. The whole book is very clear and illustrative. It provides many useful points in designing embedded software that my be overlooked by application software engineer like me.



3. I think microC/OS is a good example of small operating systems such as TOPPERS/ssp(smallest set profile). This book describe Hardware fundamentals for the software engineer (chapter 1) for examples VCC(Voltage Connected to Collector), And gates and Or gates and D Flip Flops.
   Advanced Hardware Fundamentals(chapter 2) describe Busses, DMA(Direct Memory Access), and Interrupts(also in chapter 4).
   Survey of software architecutres(chapter 5) is important articles.
   Introduction to real-time operating systems(chapter 6) include semaphores that is traditional technology.
   All of the contents are good for primer. In the CD-ROM there are answer of the problems(exercise or practice) and additional programs.
   ps.
   microC/OS is made by Jean J. Labrosse.
   He make a new book, microC/OS-II.



4. This book hits most of the major points in embedded software programming, clearly and concisely. It it almost 10 years old, though, and some of the discussion shows it (especially hardware). It would be great if they would do a second edition, as the book is a great read otherwise.



5. Many people would argue that the material in this text is far too basic. I think this is precisely the strength of this book. I enjoyed reading this book despite being an experienced embedded developer.
   
   There is no one-stop-shop in embedded software development. If you adopt it as a career, there are many things you will need to learn over time: architectures of multiple processors, a variety development tools, RTOSes and a lot more. For the most part the book stays clear of the specifics of all of these. However, it does teach you the fundamentals of all of them. The information about hardware interfacing, processors, interrupts, shared data problems, RTOS based design, and common mistakes is sufficient to get a new-comer started quickly. In my early days, I spent hours, sometimes days, chasing bugs similar to those this book teaches you to avoid.
   
   In short, the book is just what says it is: "What you need to know to get started with embedded systems development". I would highly recommend it to any newcomer to this field.

No comments about MCITP Self-Paced Training Kit (Exam 70-237): Designing Messaging Solutions with Microsoft® Exchange Server 2007.

5 comments about Professional SQL Server 2005 Reporting Services.

1. This is the fifth book that I have purchased from Wiley Publishing (WROX), and I must say that I have been very pleased so far by the overall quality of the publications until now. I read through the other four and still use each one of them as a relevant reference source.
   
   I am half way thru this book and the experience has not been pleasant to say the least. The inconsistencies between the text, figure's and examples are to numerous to be overlooked. And, to be honest, this is one of the most confusing approaches that I have come across in quite some time. He is obvious very knowledge about SSRS, but during many of his explanations he orphans the examples or doesn't tie what he is explaining back to the example. This makes it very difficult to reproduce in the actual development environment. You're just left confused!
   
   I am a twelve year veteran of Crystal Reports, Application Development and Database Design and I find this book very difficult to follow. So unfortunately, I would not recommend this particular book to others ... I am just surprisingly disappointed.



2. This will probably be an ok reference for some things in ssrs, but otherwise it has been a real pain to get through. There seems to be a huge amount of repetitive informatin in the first three chapters before we actually get to start writing reports.
   
   Unfortunately, once writing reports, it seems like the authors have ADD. They start talking about a walk through exercise but never actually have the walk through. They do have a couple of exercises where they show you how to go step by step, but these are not explained well.
   
   I think the writing, other than being repetative, is sometimes unecessarily chatty, but at other times way to terse for beginners.
   
   I have managed to glean some value from the book, but it's been tough. I would definitely recommend if you haven't touched SSRS yet to go through the tutorials on MSDN first. They do a better job of introducing you to basics, giving you plain instructions, and not overloading you with commentary that isn't all helpful in just getting you up to speed on how to create reports. Luckily I did this before I bought the book. I think if I was completely new to reporting and SSRS, I would have thrown this book down in disgust after the first 100 pages or so...



3. This book is about average. With that I am not implying that it is a bad book but rather that you could find the same information on the Internet just by googling a little bit. I guess I was expecting to find something really clever in it, something that it would make it more useful that simple internet articles. Again, not a bad book but also not one that will make the difference.



4. Almost impossible to do the walkthroughs as the writers can't decide if they are giving you instructions or just offering some general concepts. Chapters 1-3 are a waste of time. Go straight to chapter 4 to get started.
   
   The format is too conversational and often fluffed-out with irrelevant details.
   
   Overall, another disappointing Wrox text that has too many authors and no editor.



5. The reason for being so confusing is this book was written by so many authors, thereby the ideas presented are not coherent. This is not a learner's book, and if you're looking for one I suggest you buy Brian Larson's instead - great book, easy to follow and the author will patiently answer your inquiries regarding some minor problems.
   
   I bought this book yesterday hoping I could supplement the things I've already learned previously regarding RS, but no, I'll return this book today and ask for a refund.

4 comments about MCITP Self-Paced Training Kit (Exam 70-441): Designing Database Solutions by Using Microsoft SQL Server(TM) 2005 (Self-Paced Training Kits).

1. Be sure to prep for the 70-441 exam with the experts from Solid Quality. Everything, including good test questions, is in this book.



2. This is all you need to pass this exam. A good book with some good practical examples.



3. I used this book initially to supplement my study for the 70-441 exam.
   
   Unfortunately, each chapter was very short and had only a few review questions, and the topics were presented in a very detached and superficial manner, as though someone had simply summarized the online documentation without truly understanding it.
   
   The practice test supplied on CD did have more questions, but the test engine itself was buggy and hard to use. For exampe, you can configure the engine to generate a test on specific chapters and with a time limit, say 10 questions from chapter 5 with a time limit of 30 mintues, but it would just ignore your criteria and simply give you all 191 questions with no filtering and no randomization of the questions.
   
   After a couple of frustrating weeks, I realized the book wasn't helping me understand the material so I switched to the Sybex book by Victor Isakov, and I'm so happy I did.



4. This book really helped me prep for the 70-441 exam. I managed to pass it the first time. One thing the book itself doesn't really mention is that the exam questions are all case-study related, with "best answers" needed (when to use stored procs vs UDFs), not trivia-related issues (what stored procedure to call an when). The book could be improved somewhat to gear more for this test format.
   
   The practice tests in the book CD are case-study related, but I still found them asking more questions that are trivia, as opposed to best-fit answers. Fot those, I recomend Transcender practice exams.

5 comments about Microsoft® SQL Server(TM) 2005 Reporting Services Step by Step (Step by Step (Microsoft)).

1. I am migrating our databases from Pervasive to MS SQL. We have a large amount of compiled (V7) Crystal Reports that will need to be updated and I was hoping to use the 2005 SQL Reporting Services instead.
   
   The major problem with this book is the very first script used to load the sample database fails. From this point on you might as well trash the book since none of the exercises will work. To run the first script the author gives you the complete file path for the command and the sample database. This path is 8 layers deep. The actual SQL query used to install the sample database has a completely different path, so the installation fails. Ok....I figured out the path problem and moved the files to where the SQL query wants them to be. I ran the installation script again and now I able to install the sample database. The next problem....the SQL query also configures the user logins to the database.....it fails!!!! I am new to SQL so I am now lost since I can not configure the user logins.
   
   I bought this book as a learning tool!! Now it sits collecting dust!!
   
   In reply to Dr. Ribeiro Silva's comments
   
   Point taken, but you missed the point completely.
   
   I will try to explain it another way. You need to learn how to drive a car. You buy a training package from Eddie's Driving School. It includes a training manual and a used car. The package is delivered by UPS. You stay up all night reading the manual and the next day you are ready to drive. You get in the car and turn the key....nothing happens. The car will not start! You re-read the driving manual and find nothing in it about troubleshooting why your car will not start!!
   
   This is the problem with this book. It is supposed to teach you how to create reports from a 2005 SQL server. It is not a training course on installing and troubleshooting a 2005 SQL database. The book provides a pre-configured 2005 SQL database and the installation scripts to install the database. When you run the installation script, the installation fails with numerous errors. In other words, the provided database "engine" is broken and will not run!! Since the database is not installed properly by the provided software you can not do any of the exercises.
   
   Since I need to learn this subject, I took the official Microsoft SQL Reporting class. I brought the book to my class and the instructor spent his entire lunch hour trying to follow the directions in the book to install the provided 2005 SQL database. He could not.



2. I agree with the other reviewer that had trouble installing the sample files: there's no excuse that Microsoft Press should have let this book out the door without some basic technical review. In order to successfully install the files, you must manually edit the attach_databases.sql file to map the @physname paths to the .mdf files stored in your My Documents folder rather than c:\rs2005sbs (which is never created by the installer). For the intended audience of this book, that's an unnecessary hastle that the use user should have to go through.



3. I am new to SQL Reporting Services. I found this book very helpful with its step-by-step approach. I would recommend it for beginners.



4. I purchased the book well over a year ago and placed it in my library for future reference. Now that I finally need it to dig into SSRS further, I'm truly disappointed. Besides the well documented script to load the databases not working, I've found plenty of instances where I found myself truly lost in the "Step by Step". I really had to go back time after time to see if I missed something. Low and behold, I didn't miss a thing. This was an extreme waste of valuable time away from projects. What the book is missing is a really good technical review. Long story short, placed this one on the shelf and ordered Microsoft SQL Server 2005 Reporting Services 2005 by Brian Larson. Now I'm beginning to wonder about my SSAS Step by Step now. Then again, I'll just save my self valuable time and pick up another SSAS anyway. Hope this helps!



5. Microsoft® SQL Server(TM) 2005 Reporting Services Step by Step (Step by Step (Microsoft)) should be the best book in this topic. The reason that made me ranked this book at 4 stars is because this book missed just one sentence to tell their readers the exact folder to copy the source code to or how to modify the path in sql script.

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

1. 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.



2. 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. I'm glad it does. With a screenshot on every page, the book would be 50% thicker or have less detailed info.
   
   The console apps are self-contained little apps that generally demonstrate one aspect of a WPF feature. After a few chapters, I realized I needn't read every line of code carefully, since the author gives an intro on what to look for in the sample and often an explanation after the example about any non-obvious lines of code.
   
   Other books have their place. I have several others because I sometimes want to examine some topic from several authors' POV. But for taking a programming concept and building a full 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 easier to work directly in XAML rather than delete extraneous properties these tools add to your code.
   
   Some criticize it takes half the book before delving into XAML. Anything in XAML can be done in C# (or VB), so starting with the code is a logical foundation for understanding. For things that are easier to wire up in XAML, the author points forward to those chapters. By the time you get to chapters on XAML, if you know anything at all about it, you'll fly thru the pages, filling in gaps about how code and markup work seamlessly together.
   
   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.



3. This book is ESSENTIAL for any WPF engineer. There are so many topics covered in this book that will allow you to take your WPF applications to the next level. Charles' style of writing is fantastic and easy to understand. I wouldn't neccessarily recommend this to be the book to learn WPF fro but consider it an essential source for advanced topics.



4. Every book I had read so far on WPF sidestepped the basic premise behind WPF -- that it was a brand new platform and a new programming paradigm, which will eventually replace WinForms. How did they do that? By glorifying XAML and everything that it could do for you, turning Windows programming into that trash called HTML, which most Windows programmers stay away from. When I read Nathan Adams' highly touted book, I couldn't get past that 3rd chapter. Chris Sells? About the same. The problem was always the same -- each of the aforesaid authors unnecessarily burden you with XAML when you are already trying to get your head around the WPF, thereby glossing over some very, very important concepts!
   
   Charlie Petzold is that seasoned veteran that started doing Windows ever since Windows came into existence. He takes a truly novel approach in teaching you about WPF. He starts off by first telling you about WPF in the language you are most familiar with -- C#. He explains all the concepts, all the ideas, all the tenets. All in C#. And then, when you get familiar with all of that, bam! He hits you with XAML. He then starts showing you how you can do all of the things that he showed you in C# -- in XAML. But by this time, you are no longer struggling with the concepts of WPF. You already know what DependencyProperties and RoutedEvents are. You are already aware of virtual trees and logical trees. So now, when you see them represented in XAML, it makes so much more sense. And it's all easier to comprehend.
   
   The simplest analogy I can give is this: remember the time when you started learning calculus in high school? That was a new enough concept, right? Now imagine if you had to learn that in German (or your non-native tongue)! But once you learn all the concepts in English, you could very well proceed in a language you weren't quite as familiar with.
   
   To me this is the only way I could have learned WPF. And XAML. I was pushing off WPF all these days only because XAML was getting in the way of my learning. While a lot of Web-programmers will be happy for XAML, the fact is, declarative programming is not something Windows programmers are used to. To them, the only way to approach the subject is to first teach them WPF and then show them how XAML comes in the picture.
   
   Having said that, there are a two extremely irritating aspects to the book that start rearing their annoying heads by the time you get to the second chapter:
   1. There are no graphics showing outputs from the code. Granted you are expected to run the code samples (which can be downloaded from the MS Press support site), but I shouldn't have to run every single code sample. Moreover, there are times when I'm reading the book on a crowded train, when I can't really run the program on my laptop -- there's barely room to open the book as it is.
   2. Every program is a Console app. So after you hit the F5 key, the annoying console window gets in the way of viewing the main Window. You have to minimize the window, or move it in order to see the Window (Form). According to Petzold, it's convenient for him to hit Ctrl-C on the Console window to terminate the program. Note to Petzold: Chuck, have you tried hitting Shift-F5 on your IDE? I find this so debilitating that I had a utility converting every single csproj file in the folder tree from a console to a Windows application.
   
   Aside from that, the code samples run perfectly. I'm on Chapter 11, and so far every single code sample works.
   
   If you are a seasoned Windows/C# programmer facing similar mind blocks against XAML, this is the book for you. If you are a Web programmer for whom C# is subservient to VBScript, or JavaScript, and are comfortable with HTML, this may not be the right entry point for you (as evidenced by some of the low ratings that this book got). You may need to get in via XAML, and a book that overly emphasizes its importance (such as Adams or Sells) might be the way to go.



5. Over the last decade I've been reading books by Charles Petzold; until this one I enjoyed them all. I consider Petzold to be one of the best Windows development authors out there. He's been writing about it since Windows was became Windows. Most of his titles offer well thought out and presented material. This book did not.
   
   Twice I attempted to read this book as my introduction to the Windows Presentation Foundation. Both times I failed to advance my mark more than a few hundred pages. There are absolutely no illustrations, screenshots or pictures of any kind. This fact forces the reader to type up his numerous code samples to see their output. While I enjoy having many samples in a book about programming, I don't always need to type up the program myself to understand its meaning. Call it teaching to all the senses, but I like more visuals.
   
   My other complaint with the book is that while reading it I constantly feel I'm not moving anywhere. Most other programming books I've read I felt like I could go out and use the tool, even if it was only a fraction of its functionality. With this book I constantly felt like I had to wait until the 2nd half, the XAML discussion, to really use WPF. Yes, I could write a GUI by programmatically instantiating all the elements, but that isn't the way the technology was meant to be used. I would have enjoyed a brief introduction to XAML and its use throughout; only waiting until the end for diving into its deepest intricacies.
   In the end, I couldn't finish this book and purchased a different title.