Programming Books

This book teaches with extreme clarity everything you need to know to program for Director/Shockwave 3D. A rarity amongst programming books due to the didactics, organization, and clarity/accuracy of code. It is current with Director MX 2004 and I suspect it is current with Director 11 given the information Adobe just released. You cannot go wrong with this one. The only problem is that it is hard to find, I had to buy my copy from a reseller.

I have every book publish about developing interactive 3D using director. This is the best one of the bunch. After reading this book I wish I hadn't purchased any of the others. Although the book is for director 8.5 it still the best book for Director 3D +

As anyone knows reading this review knows Director is the only program that will allow you to create 3D games and programs for the web. Hopefully Adobe will update it rather than let a very powerful program fade away.

This is an excellent book for Director and Director 3D. It is very in depth and involved, although a bit hard to understand at times. This book is not for beginners and requires a lot of hard work to obtain its end results, but they are very much worth it.

Other reviews have captured the gist of this wonderful, accessible, and thorough treatment of Director's 3D functionality. What I would like to add is that Catanese's book is just as current with Director MX as it is with Director 8.5.

If you plan to do 3D in Director MX, either games or presentations, you owe it to yourself to read this book.

I'm an IT student and possessing VB & C/C++. I have never learn about 3D and Director before. So when I want to make a Director project (game), I need a book!
And this book is the great answer. Everything you need about Director 3D is in this book! (although this book doesn't cover about Havok Physics Engine).

This book tells you WHAT and HOW, I mean, this book not only tells you HOW to make something (ex: primitive object) but also explains about that thing. (ex: what is a primitive object). So, you're not only able to programm but also understand about WHAT are you doing.

This book explains from basic and the last page explains advance technique. So, if you start from first page and finish the book, you'll become an advance 3D Director programmer (even before you read this, you're nill in 3D Director).

OK, I'll tell you what I get from this book, here is my project: a Multiplayer First Person Shooting (FPS) game! (like Counter Strike, Quake, etc). Notice that this is my FIRST 3D Director project! And I got A!

NB: if you're NOT a programmer and don't WANT to possessing 3D Director programming SERIOUSLY, I don't recommend this book, for this book is code heavy, full of code programming, just try "Macromedia Director 8.5 Shockwave Studio for 3D: Training from the Source" (by Phil Gross).
Just a note: I learn about Multiuser form Director 8.5 Studio (you won't find about Multiuser in Director's Third Dimension).

It covers majority of the database topics and is a very useful reference.

I am a MS SQL DBA learning Oracle and this was the first book I read after going through the Oracle's official curriculum. Here are my thoughts.

1)This book is definitely not for the beginners. I highly recommend you start with a more basic book that gives you an overview of Oracle. Oracle tools are highly unintuitive and using them can be a frustrating experience especially for MS SQL DBAs *smirk*. Learning to just to connect to an Oracle database is a learning experience that will take knowledge on how Oracle's network and security function.

2)If you already have a working knowledge on how to operate an Oracle database, this book will no doubt provide a more solid foundation for your knowledge (except RAC). I particularly found its chapters on RMAN and IMPORT/EXPORT utilties particularly helpful.

3)Perhaps the best part of this book is that it encompasses what the author believes is the most essential knowledge to becoming a highly competent Oracle DBA. The book does not try to be a reference for every Oracle topic. Instead, the author has smartly picked the most important information needed and presented them in a readable format.

4)My only issue with this book is that it is wordy. The book is 1200 pages long and it could easily have been 1000 pages or fewer.

An excellent book covering all essential DBA topics for Oracle 9i Administration. Explained very well covering In-depth details, Illustrations and examples makes this book invaluable. I use it as a true source of reference and I will strongly recommend this book.

This is a great book. All Oracle people must have this.

I just got this book from the library and I decided to read through it before I buy. I think I will buy a copy of it. The book touched pretty much all the areas of Oracle 9i. It is a book to have on your desk as key reference. I will recommend this book to new DBA. The author did a pretty good job. The book seems too big but very useful. I give 4 stars.

A good book, very complete and full of infos. All topics are well and deeply explained. I give only 4 stars for two main reasons
1. I don't like the writing style. It is too friendly, I prefer a formal and clean one.
2. Some explanation is 'obscure' and needs to be rewritten, for example the SelectWith extension method.
Anyway it really worths to have a copy on your desk.

I read a lot of tech books and only write reviews on the ones I really think offer value. This is one of them. If you want to learn LINQ from some guys that know their stuff, this is the book for you. It's very readable with great code examples..VB coverage is much appreciated by me! I've also looked at some of the other LINQ books. This is the only one I took the time to read cover to cover. Very easy to read with great coverage of the topic. Highly recommended.

Mark Dunn, MCT, MCAD, MCDBA, MCSD.NET
Microsoft MVP, Visual Basic
Microsoft Regional Director
President, DUNN Training and Consulting, Inc.

If you want to learn Linq, whether its data stored in a database, in XML files, DataSets or just in-memory objects this is the book for you.

I found it so easy to understand, and really comprehend. There are lots of examples, but not too many. After reading the first few chapters you become comfortable with the concept and syntax of the new language extensions.

The authors style had just the right combination of light humor and serious programming. He seems able to express complicated issues with the greatest of ease, and obviously has enoumous knowledge on the subject.

If that was not enough, there are forums avalable where you can raise queries and doubts and the author will do his best to accomodate you, again with a nice and easy flowing style.

The book is a 'must have' to any serious Linq programmer (or want-to-be Linq programmer!) and will certainly occupy a prominent place on my bookshelf.

Highly recommended!

Regards,
Martin.

I've read every LINQ book that i"ve come across and on the whole, they are all really good. As a subject area, the coverage is amazingly well done. This book is a natural fit b/c in every important respect, it's excellent.

First off, it's easy to read. Learning the basic mechanics of LINQ isn't all that difficult. Learning advanced LINQ mechanics is still pretty straightforward. However understanding why certain approaches should be used over other ones, understanding potential pitfalls (getting something back you weren't expecting) and ensuring your code performs well after you get back more than a few records, well, that takes some effort. I think this book helps you accomplish each of those in a manner that's very clear and very straightforward. [As a stylistic note, I think really understanding Lamda expressions, which admittedly aren't a linq feature per se, is challenging at first. This book did not shy away from them and went at them head one. B/c learning them isn't a linear process (at least it wasn't for me or anyone i know), you often make no real progress, then have a moment of understanding that gets you to the next level. That type of learning is best facilitated by seeing several examples - seeing several ways to accomplish something and then reverse engineering the differences. The extensive number of examples really makes that process a lot simpler].

Another really strong point is the examples themselves. In the LINQ to XML coverage, there's an example of how to create a RSS feed from a collection with one linq query. It's beauty is its elegance and b/c most developers have given writing RSS a try, it's a great juxtaposition to show how powerful and useful LINQ can be. That example isn't alone though - there are several others that extend beyond the cliche'd Hello World samples that leave people wanting for more.

The coverage of each topic is superb as well. At no point did I finish a chapter with unanswered questions in mind. Often, authors will make an assertion "you should do it this way b/c otherwise you'll open up security vulnerabilities" or whatever without explaining what the downside is that they are talking about. I know it's a seemingly unimportant thing, but I found that they always explained the points they make, even the minor ones. It's a typical example of the attention to detail the authors put into this book.

Having co-authored several books, I know how hard it is to write a book with a unified writing style. The editing for this book is done in such a way though that it looks like one author wrote it. Yes, there are some differences in their individual writing styles, but it's all close enough that it really does feel as though one person wrote it. That is a huge plus and again, it's just one of those small things they do that shows a serious attention to detail.

So it's easy to read, they cover everything really well, they selected great examples and explain them well and they start out with general coverage and move onto very detailed coverage - making it ideal for both a LINQ newcommer or a seasoned vet.

It's a great book and IMHO, the authors are to be commended for putting it together. Although I've found all of the LINQ books I've come across to be very good - this one made an impression and it's excellent from start to finish.

I am a newbie both in visual basic and Linq, and I have to say that this book is really great. It provides a LOT of understandable explanations, that are so useful for who's not a guru already.

There are tons of examples, plus quite a lot online resources that can be extremely useful.

Great book, probably one of the best on LINQ subject, and it's definitely worth the price

The problem I've seen with technical books is that either they are in tutorial/textbook format which includes lessons and then review questions at the end of each chapter, or they are purely reference type books ideal for looking up things on occasion and not really good for a beginner to learn the subject matter. This book was the first one I felt that was ideal in both textbook form as well as a reference book for looking things up.

The chapters were basic enough for the beginner to grasp the material, and the lessons were rife with hands-on examples which I thought was the best part. I like to try things out as I go through the lessons and so the material was very useful for me.

The printing of the material was interesting and draws the reader into the subject, important notes and pitfalls are highlighted between the text to avoid the paragraphs from becoming too long and drawn out. The writer's diction is sometimes humorous to avoid the reader from losing interest.

The book is kind of bulky and thick so as a consequence of regular use, the glue based binding gave way somewhere in the middle of the book so when I open it, the first half of the book is attched merely by a shred to the second half, so I have to be careful now when I lookup things in it. I wouldn't trade this book for anything.

I have never taken any instructional classes on Perl scripting and can safely say that everything I know about Perl scripting I've learned from this book. That being said I am able to write fairly sophisticated perl scripts and have the ability to understand fairly obfuscated perl code without difficulty. I use perl as a very strong and useful tool in my day to day tasks for scripting and text processing needs and I often dazzle and amaze my colleagues at work with the tricks I'm able to pull off by using perl scripting and I owe it all to this book.

In short, I give two enthusiastic thumbs up for this book and the 5 star rating that I gave this book was merely due to the amazon limitation on the number of stars you can give in your review.

I started learning Perl two years ago. I first browsed libraries, free tutorials, news groups etc... It was nice for the beginning but soon enough I understood that's not the way :)

I started looking around for good Perl books and somehow got to this one. I think I can clearly say, that this book did the work. Teached me Perl from the ground up. I'm now planning on buying "MySQL and mSQL" to start working with databases. I also consider buying "Mastering Algorithms With Perl" & "Programming Web Graphics with Perl & GNU Software".

Anyway, if you want to start learning Perl, buy this book. I also use it as a reference.

The book is a good and detailed tutorial for all novices who want to learn Perl. No hit around the bush stuff and the chapters were well thought of. Credit should be given to the author and the publishing group for these helpful information. The Source codes on the CD-Rom comes handy when when you want to test out the sample codes in the book. The questions at the end of each chapter is a good revision after scanning the chapter. I strongly recommend those who want to learn Perl to get a copy of this book as their first book.

After the Camel book, of course. This book is very well paced with well thought out examples. I needed it as a refresher last year, and now use it as a reference.

The only down side is that the Web Based interactive segment is no longer available. not a big deal since it's the same quizes as in the book, but there was a gee-whiz, isn't it fun factor to have it available online.

This book covers everything from soup to nuts. It starts the learner off slowly with the basic perl syntax and then smoothly moves into subroutines, OOP, DBI modules, Security, etc. all with the same interesting and amusing style.

I don't know if it's mentioned in the Editorial review, but the author is the Editor of The Perl Journal (www.tpj.com) which is a magazine devoted to the perl programming language. So Jon Orwant *knows* his topic.

I've read and use most of the Perl books out on the market today, but none comes close to getting you going well with Perl as does Jon Orwant's book. I still use it as a reference today, but it is the best any money can buy for learning Perl. I'm back buying another copy because I loaned mine to a friend and I miss it so much that I want to make sure I'll always have a copy handy. My old copy is so well worn that a fresh copy is enticing also. As for extras in the book: the quizzes are great for testing your understanding, and someone has done a great job at proofreading this book -- I don't know whether that person is at the Waite Group or is Jon himself, but I know that anytime I have questioned an answer, or a script, or anything in the book I have always found the book to be accurate on closer inspection. It is very much like the Camel Book in being authoritative -- what Jon says is Perl Gospel Truth - if I had to pick two Perl books, I'd pick this one for learning and the Camel Book for ultimate reference. Jon's book should be rated a 5 and a half star - this is the best that it ever gets!

No obtiene la quinta estrella por no hacer referencia alguna al manejo de los archivos BVH. Por lo demás, genial!

This book has become one of my references for Poser 6. It's clearly written and covers topics from basic to advanced. I recommend this book for anyone learning or using Poser 6!

It was very easy to follow and made it easy to learn Poser 6.

I avoid buying software books because many of my past purchases were a complete waste of money. The authors rehash the software's free manuals and provide explanations and tutorials so basic that it seems their target reader is somebody who bought their first PC just last week.

Based on strong reviews, I took a chance and bought Practical Poser 6. I'm not going to cover the content, which is already described very thoroughly in other reviews here. I'll just say that if you have tried to use Poser without any tutorial or learning aids, this book is for you. I had a copy of Poser 5 and had just bought Poser 6 a few weeks before getting this book. My measure of a good instructional book is how much it taught me that I didn't know already. I estimate 50-60% of this book contains info that I'd only have learned by painful trial-and-error, and was really useful to me. And this is not to say that it's for experienced users only -- whether you're just starting out with Poser or already have a few years of experience, there's some explanations, tips and general good reading in this book for you. Highly recommended!

I found Practical Poser 6 a valuable training tutorial into the world of 3D graphics. Not only did it explain the functions and usages of Poser 6 in understandable terms, it illustrated examples in easy to follow, step-by-step instructions. This book is a recommended must-have for individuals who are thinking about entering the realm of 3D graphics or serious artists who want to refine their technique and squeeze a little more 'mileage' from their programs. A first-rate, well written book in it's field.

This is among my favorite computer science books. I read the first edition straight through from cover to cover, even though I had some prior knowledge of the subject. I have since purchased the second edition, which exceeds the high standards set by the first edition. Scott's book would have made the programming languages course I took as an undergraduate much more enlightening, had it existed at the time.

As a software engineer, I tend to be picky about my books, but this one is very in depth and a good read. You will learn a lot about different programming languages, and why certain languages are better than others for solving different types of prroblems.

Over the years the Compilers: Principles, Techniques, and Tools (2nd Edition) (also knwon as the dragon book) has become the de facto standard for introducing compilers and related topics at universities. This is very unfortunate because "Programming Language Pragmatics" is in a completely different league and should be the one used instead. It gives the student (or the self taught) a complete and through overview of parsing, grammar, automata theory and other key language constructs. What really differentiates this book from others (and most notably the (in)famous "Dragon Book") is that it does so in a easy to understand manner and with lots of well written examples.

Many people find compiler and language theory to be dark magic, and it would be wrong not to acknowledge that these subjects are considerably harder than say creating a web page in PHP or writing a small Java/C# program. But much of the confusion also stems from the long history of porly written books which all have lacked explaining key areas or assumed that the readers just know some obscure CS topics beforehand. This book does not travel down that road, it is well written, contains both simple and advanced examples and is simply a delightful read.

Overall, "Programming Language Pragmatics" (PLP) is a very good book. According to the Preface:

"It aims, quite simply, to be the most comprehensive and accurate languages text available, in a style that is engaging and accessible to the typical undergraduate....

At its core, PLP is a book about how programming languages work. Rather than enumerate the details of many different languages, it focuses on concepts that underlie all the languages the student is likely to encounter, illustrating those concepts with a variety of concrete examples, and exploring the tradeoffs that explain why different languages were designed in different ways."

I'm not knowledgeable enough to pass judgment on "the most comprehensive and accurate" part. But, I'm pretty happy about the book meeting the rest of those goals. I read through the book on my own and have only a few significant gripes:

- Chapters 2 (Programming Language Syntax) and 4 (Semantic Analysis) are tough to get through. They're basically trying to teach enough about Alphabets, Languages, Regular Expressions, Context-Free Grammars, Finite Automata and Push-Down Automata for the reader to understand what the rest of the book is based on. I've read Cohen's Introduction to Computer Theory, which is dedicated solely to this material and I still had some trouble. With an instructor in a class to walk through the things, it should be doable. But, for a person reading the book on his own, ugh.

- All of Section III: Alternative Programming Models, seems to depart from the format of the rest of the book (as noted in the Preface) where the author talks about the concepts and then how the different languages implement them. Instead, he focuses on the languages themselves and almost seems to be trying to cram a primer into his text. Since the section seems to be a special case, it wouldn't be so bad except that the languages covered are a bit out of the mainstream and so that degree of depth gets pretty unreadable at times. Again, with a professor around, things would be better.

- At a more pedagogical level, the author has a tendency to merely explain what his example Figures are doing in general terms. The problem is that a lot of the code/pseudocode involves fairly advanced structures in several languages (many of which most people won't have run across). It would have made things a lot easier if he had walked his way through each of those Figures line-by-line and explained what each line did. Once again, this wouldn't be that much of a problem in a normal teaching environment since a professor could do it.

Other than those three things, this is a very good and readable book. I rate it at four stars out of five.

Every good programmer should know more than one programming language, that much is almost a consensus. But more than that, every programmer should educate himself about programming languages in general, what they mean and how they work. It's important to know at least the major programming paradigms, because they form the "mental model" of computation that is available to a programmer in a language from that paradigm.

And then it's always illustrative to know about the differences in many common languages, to see where different decisions have been made and what are the consequences. To know that certain legacy languages (e.g. C, Fortran) have features that were not designed because they were the "best" option (for some definition of best), but because the design was constrained by what technology was currently available.

This knowledge is not only required of compiler writers. It should be required of every good programmer. Compiler writers, of course, must know this, and probably in more detail. But Scott's book is a good resource about programming languages, in a level of detail that I believe adequate for all programmers.

There are two main kinds of books on programming languages: they are "survey" and "implementation".

Survey books show how things work in a lot of languages, comparing them along the way. Often the comparison gets down to small details that can affect the meaning, or semantics, of similar programs written in these languages. These books contain one individual chapter for every major topic, and inside such a chapter all languages are compared in relation to the topic. For example, one such chapter covers "subroutines" and then compare a host of different languages on how they implement subroutines.

Implementation books are different: they show how to implement many language features, usually by presenting code for interpreters and compilers. The reader doesn't learn that Ada permits nested subroutines, but instead how nested subroutines really work and how to implement them in a language, for example. A very good book of this kind is "Essentials of Programming Languages" by Friedman, Wand & Haynes.

I normally prefer the implementation books. I'm not really interested if Standard Pascal permits functions to be passed as parameters or not; if I do need to write a Standard Pascal compiler I'll look for a reference manual. I much prefer to know how to implement functions as parameters, and be done with it. Comparing minutiae about extant programming languages can sometimes be very enlightening, and sometimes be mostly dull.

Scott's book, however, really shines because it mixes feature descriptions and implementation details in the presentation. It does the usual routine of comparing a lot of different languages, most of the time the more popular ones like C++ and Java, but it then shows how the implementations differ because of differences in features. The book strikes a good balance between "language design" and "implementation" approaches, although it is clearly slanted towards design, and so more of a traditional "survey" book.

It wins over other survey books by including implementation information about almost every topic, and by the clear writing and style. Also, most survey books concentrate on mainstream imperative languages (nowadays C++, Java, C#) and leave other paradigms to chapters at the end. Scott's book is a bit better in this respect: the presentation often includes Common Lisp, Scheme and Standard ML in the comparisons. There are separate chapters about functional and logic programming too, but considerations about functional programming are spread in the whole book. This is important because paradigms change, and a good programmer must be able to adapt.

It's a good reference for language implementors and good education for most programmers. I look forward to the next editions.

While this book covers all the significant technology in the area, it is a much better read for all those things you wondered about in Sci Fi Could they really do that? Also the policy issues are critical to our privacy rights and conversly national security.

Anyone who uses a mobile phone, relies upon oversees Internet connectivity, or worries about personal security should get acquainted with this book. Mr. Vacca has once again produced a very accessible yet easily readable tome on the dangers and promise of satellite encryption. Pick it up and you'll learn about or government policies regarding satellite communications management and security. By the time you put it down, you'll understand everything from pagers to the electronic battlefield. It's a must-read!

Great book - detailed and technical, but still a good read

As always, John Vacca provides an incredible level of detail in a readable manner. The Internet implications are particularly applicable to almost any reader. In our case, where the line-of-sight constraints of radio transmission in our wireless WANs are forcing us to look at satellite options, this book is an invaluable resource. And the tales told herein about encryption break-ins and techniques make fascinating reading in their own right.

Technical from orbit to chip, and immensely readable as well!

I think that the tittle of this book is a bit misleading. If one reads through all the enthusiastic reviews of the book one can actually get a clear picture of what it is about. It is a general overview of politics of encryption with some technical information included in between. I cannot understand the reason for more than one hundred pages of information about different types of military equipment. Yes, this book is interesting but it is not about cryptography and encryption. These subjects are only a small part of the book. I returned Satellite Encryption after very thorough consideration.

The service-orientation modeling book is a non nonsense book that gives you straight answers to your service analysis and design questions. You'll not find any time wasting pages such as XML or WS* that mean noting to hands on professionals. I purchased this book because I expected to learn more about SOA modeling but most of the book discusses ways to categorized services, abstract services, analyze services, design services and architect services. The recommended hands on design method in the book focus on pure modeling and do not get off track. This is a straight forward guide that provided me with immediate answers for our projects (not only SOA). Amongst the most interesting topics that are in the book have answers to how to design services, how to connect services, how to crate a environment that supports multiple contracts.

I am a technical project manager that oversees about 25 developers, business analysts and architects. When I bought this book I had very low expectations because most of the SOA books on the market promise more than they can deliver. The wealth of information and the historical computing overview that this book discusses are valuable to any IT and even business employees. I'm still reading it, but so far, I have only one word that can describe my admiration for this work:

"Wow!"

If you are looking for a great read, a book that explains in simple words the principles of SOA modeling, service modeling, middleware modeling, or modeling SOA systems, you will find this book enriching, educational, and fairly easy to read.

This is one of the most fascinating and inspiring SOA books that I ever read. The author Bell both takes his readers through an entirely new service development process and also accentuates the strategies that drive design and architecture for projects. In point of fact, this is the only book that literally explains what service reusability, interoperability, and discoverability mean to a developer, an architect, or a manager. This book is, and will always be considered as the book that started a new era in software development. Why? Because most of the chapters are innovative and present a new vision and viewpoint for building components and services - chunks of code that transform into executables.

The modeling sections are easy to understand and implement. Managers or business people can study this language as well. This simple drawing method for expressing service structures and their relationship simplify and explain SOA deliverables.

I am a Java developer that recommends this book to the development community, to architects, to managers, to operations people, and to infrastructure professionals.

Very impressive text!

I believe that once in a millennium an article or a book can change your life. Why would anyone take the time to write a book that tells a different story, puts you in a unique and special environment that you have never visited before? Why would anyone peril his career, put his/her name at risk and unveil a technology that does not exist?

This author that has appeared from nowhere published an exciting, technical but also philosophical communication narrative about how should we correspond and collaboratively build software. But if you expect to read about a particular programming language or technology, this is not your kind of a book!

From the very first page you find a creative mind that drags you deeper and deeper into a virtual world, a software landscape, which is depicted as a 3D illustration that you can touch, manipulate, or mold to promote the business.

I have been questioning myself why this vision is linked to SOA and services. Why can't we just apply this method to design our overall computing word? Indeed, the author suggests that all systems, business processes, libraries, databases, etc, are services. But the major contribution of this book is the simple interpretation of our complex production and deployment environments.

To make it simple to understand, imagine that everything that we, IT people, have been constructing in the past 50 years, are software structures that fundamentally seem to comply with the author's geometrical 3D rules for software modeling: Atomic, Composite, and Cluster service formations. If this is clear, your computing world can be easily modeled, altered, aggregated, decomposed, subtracted, unified, and even transformed.

Brilliant Piece of Art!

Lisa McGuire,
USA

This is a comprehensive modeling book that delves into modeling aspects of services. The discussed topics address fundamental software development and architecture issues that are not unique to the SOA paradigm. The illustrated methodology tackles imperative software design practices as well.

Bell's modeling book also introduces a modeling framework that offers a communication language. This is a vocabulary that should be employed to offer remedies to organizational problems. The provided notation is easy to understand and enables people to exchange architectural and design ideas through a collection of symbols. These pictograms can be employed to foster software reuse, increase communication between silo organizations, reduce operational costs, and even carve proactive strategies to avoid business instability.

Like many people who develop ASP.NET applications for a living, I was extremely interested in learning about ASP.NET AJAX. This is the only book I bought on the subject, and it has been extraordinary. I can't recommend it highly enough. Read this book and you'll be an expert.

This book was a great introduction to the ASP.NET Ajax Extensions and Control Toolkit! Extremely well written. I especially appreciated the practical, real-world samples that were given throughout the book that actually worked.

If you are after further exploration and like to know how things work underneath the hood a bit more, I recommend Dino Esposito's book as a companion.

I have been reading this book for a while. While at Border's or B&N, I used to grab other ASP.NET AJAX books and used to read them too. But, no other bookes close to this books CLARITY and Detailed and Simple explanation. It starts from the absolute basics and chapter by chapter it brings the developers skill set at par with the pro's. Most ASP.NET developer's client-side scripting needs some work. This book understands it and addresses them in a very simple and elegant verbals.
I had been debating for a while which book to buy. After a lot of work, I decided to go for this book. And I am happy I made the right decision.
It also has the sneak peek of the CTP Futures too.
5+ Stars. Definite YES.

Take this book and the ASP.NET AJAX Framework with two grains of salt, if you're serious about AJAX then learn JavaScript and look into the alternative AJAX Libraries like: jQuery, Scriptaculous, Dojo, Mootools, and YUI.

This book lacks objectivity and often suffers from hype. The authors came across as lacking proficient experience with the JavaScript language, or exposure to other AJAX Frameworks / Libraries, or sufficient experience using the ASP.NET AJAX Framework in real world situations.

Comments like: "we recommend that...", "because it makes no sense...", "you must understand X,Y,Z to run complex client-side code without writing a single line of JavaScript" were discouraging, and always left me hanging. Good books answer more than the "hows" - comments like "you must rely on a special..." are a cry for more research.

The book skims over the technical details of why or how the ASP.NET AJAX framework is implemented. Instead it presented many examples of "how-to" implement the various ASP.NET AJAX constructs and patterns. It would have been nice to see some real world examples of why the ASP.NET AJAX client-side typing system is useful, or why the AJAX Framework's extended JavaScript objects are useful and how these contrast to what JavaScript already provides, or what happens behind the scenes when a class is registered through client-side code, or why the AJAX Framework prefers declarative syntax (XML) over imperative syntax, and to have some real in-depth discussions on performance implications.

In addition to these disappointments, the ASP.NET AJAX Framework itself has some serious technical flaws, it's too heavy weighted (bloated) for practical use. I fear it's a short lived framework, since many of the other AJAX Libraries already offer superior performance and better user experience. I was disappointed with the server-centric approach the ASP.NET AJAX Framework and this book take, and was disappointed to have JavaScript continually swept under the carpet as magic.

Very well written. Great examples. In depth as well as plain spoken author. Much to learn and easy to learn. Recommended.

I won't do a lengthy review... just read the other 5-star reviews and you'll get the drift. This book is so easy to understand you can learn without a PC in front of you (if you're a VB6 developer looking to understand .Net). The explanation of what ADO.NET is all about is worth purchase price alone. No chapter is super comprehensive, but it's a great text to get you rolling in VB.Net right quick. As an MCSD and MCDBA certified developer, I wouldn't write such a great review on just any book. Buy it.

There is so much that is lacking in this book. First, it is not user friendly. It is difficult to follow. Second, it simply does not cover enough information that one needs in order to truly be able to use .Net technology.

Cover to cover this book sails through the hype dispensing nuggets not to be forgotten!!! .Net and C#-aholics had breathed so much hot air, I was having trouble find a place to start. Once received I put everything else aside. I used to use arrays, types, RDS, and ADO to get the plumbing done but now its OOP, and serialization from now on!!! I got so many good pearls from this book its ridiculous.

This book has a very good intention and concept - to introduce VB6 developers to VB .Net. In general it is a very good book. Not very deep, but good enough to start working with VB .Net and bee reasonably productive. So, if not for sloppy writing, I would probably give that book all 5 stars.
What do I mean by sloppy? For once, author uses terms object and class interchangeably throughout the book. Sometimes it is contextually understandable what he means, but often it might be very confusing, especially for people relatively new to OO. Then there are errors and typos in code examples. Some of them are also very confusing. For example: on page 80 author introduces the new VB concept - delegates. For VB6 folks this is something fundamentally new and strange.
In code example author defines delegate type and calls it ProcessFunction. Then he defines variable of this type and calls it ProcessDelegate. After that on the same page he shows how to use delegates and assigns value to ProcessFunction and retrieves value from ProcessFunction.
From the context one should understand that in the last two cases the variable ProcessDelegate should be used instead, and that this is just a typo. Yet, given that VB .Net now supports shared properties and methods, when Class (Type) name can be used where one expects to see Object (Variable), this types of mistakes are very confusing and annoying.
I would not go here into more examples of books imperfections. There are some more. Not terribly many, but enough to frustrate.
Would I recommend this book? Yes, if you have patience and some other VB .Net book to resolve inevitable confusions.
This could become a great book in its next edition if author takes time to make it a bit more accurate and precise.

I have been programming in VB since 1992 and decided to move to VB.NET when it was released but found the learning curve was immense - until I bought the book of VB.NET. This book is my Bible, it sits besides my computer all the time. Without delving into the VB language, it simplifies the transition to VB.NET for the experienced VB Programmer. It's not for VB learners nor does Matthew propose that it is. If you know VB this is the book to ease the quantam leap from VB to VB.NET - explained in logical steps with excellent examples. I have had to EMail Matthew with a few queries and the response is always prompt and helpful.

There are certainly other books you need in your arsenal - such as Francesco Balena's Microsoft Reference - but this one is a must.