5 comments about Using Excel Visual Basic for Applications (User Friendly Reference).

1. I needed a quick course in Visual Basic for Excel. This book did the trick. I was tired of reading others' macros and trying to figure out what meant what. With a college course in Fortran77 providing me the basic framework of how to program, I found this book easy to follow and easier to learn from.

   I don't know if someone with absolutely no programming experience would find it as helpful, but it was an excellent book for me. I can now create my own code without having to use the recorder, and I can figure out other's complex code with the foundation the book provided.




2. This book is at a very beginning level, telling you how to use the macro recorder,defining a variable ("where programs store values"), defining what "calling" a procedure means etc. If you are at this beginning level, the book is excellent EXCEPT it is out of date. For example, the menu arrangement described in this book for inserting a module sheet is different if you use Excel '97. The dialog sheet is used here for designing dialog boxes, a method replaced with UserForms in Excel '97. So although intended to be a very handholding approach, for users of Excel '97 it is no longer so straigtforward. Probably John Walkenbach's "Microsoft Excel 2000 Power Programming" is more useful, but unfortunately at a more advanced level.



3. This is the only Visual Basic book I have seen which allows users to program in VB without first learning the intricacies of the language. Which makes this book the only convenient source (that I have found; after repeated trips to book stores and libraries) for anyone who is attempting to make useful programs in Excel. While it was written for Excel 7.0 the applications (amazingly) still work in Excel 2000. I would recomend this book to anyone who works with computers and wishes to save some time by avoiding tedious data entry.



4. Numerous examples and suggestions in the book were not accurate using Excel 97. For a self-paced, self-taught learner, look elsewhere.



5. This is a very good book to begin programming in Excel VBA, but not to end if you will. The book sort of gives you a push and YOU! have to then take the ball and run with it. The book is analogous to how a mother bear chases her cubs away once they are big enough to take care of themselves. The cubs, though with enough skills to survive, are still left with new and open possibilities before them. The reason why is that most of the examples are too easy, making them too unrealistic for the real world. The other is that the book is based on an older Excel version. This book is really great for those people who are scared of programming and want to make the transition, but are not sure of what road to take.

5 comments about Microsoft ADO.NET (Core Reference) (PRO-Developer).

1. After reading many tutorials and books on ADO.NET, I must say that this was the best one so far.
   Not only does it explain everything there is to know about ADO.NET, it does so in an entertaining and well presented manner.
   The code samples are in both VB.NET and C#, and above all, they are complete, or at least complete enough to understand without having to refer to the code samples on the CD.
   I was able to read and grasp the concepts explained in this book in less than a week.



2. The book will definitely show the ins/outs of getting connected to databases. The samples in the book show you how to use the drag-n-drop objects as well as using only code to manage your database applications. Samples in book were very realistic and give you a complete view of what goes on with database applications. Each sample gives you code for both VB.Net and C# which is nice since I am also interested in learning C#. You pretty much get the code for both languages for the price of one book. If you are unsure of what book to buy, go to your local bookstore and look at the contents, then come back to the NET to make the discounted purchase. Why pay more in a store retail?...



3. Unlike other tomes I have used, you walk away understanding the underlying principles after using this book. It was proofread and the code samples actually work. Having the "book online" feature allows you to cut and paste the code into Visual Studio and run the snippets for better understanding of the concepts. This book is the first that I have encountered that is assembled in a logical order as well. You will be ready to do professional ADO.NET after going through this book if you understand either C# or VB.NET.



4. For approx. 1 year, I had been utilizing ADO.NET in a limited way. It confused me the switch from ADO to ADO.NET and I wasn't that strong on ADO to begin with, so I dug my feet in about learning the rest. Then one faithful day I hit a wall in my abilities with ADO.NET. The trusty READER wasn't going to bail me out and only VIEWING data in a DATAGRID wasn't going to cover my hiney either. They wanted to modify the data. They wanted to delete data. They wanted POWER....
   (Shaking in fear...) Really LEARN ADO.NET????!!!!
   
   I looked through many ADO.NET books and found this one for me was easier to read. He gives a indepth explaination on each of the components in their respective chapters. While he only utilizes the OLEDB and SQL connections, the explaination he gave regarding using OLEDB over ODBC was convincing for me to switch.
   I learned more about the DataAdapter than I had thought existed and now enjoy playing with ADO.NET. It really has empowered me.
   
   While the code he gives is not for complete programs, but to accomplish the mission he is discussing. So, when you read the code. Don't expect to be building a program. Expect to be learning how to accomplish a task by looking at the section of code that handles it.
   
   I recommend this book to any one who has a limited experience with ADO.NET and feels that it is time to expand their knowledge to fully embrace the power of .NET
   
   (I know this recommendation comes at the closing of a chapter. The ADO.NET has been replaced by its 2.0 version. We are still currently programming in Studio 2003. If the 2005 book meets the level of this - you will learn from it!)



5. This is the best ADO.NET out there. Do not confuse this with Rebecca's (that would be a tragedy).
   
   This has in-depth coverage and has helped me so much, I can't thank David Sceppa enough. I look forward to his 2005 coverage and I hope it is as good as this.

5 comments about Managing Windows(R) with VBScript and WMI (Microsoft Windows Server System Series).

1. I bought this book based on other customers' reviews. The book talks very generally about scripting for Active Directory. The book contains the word "VBScript", as well as "Managing Windows". However, it covers very little about the in's & out's of what it possible. The sections on ADSI are watered down and virtually useless. The script examples are simple, and aren't thorough at all. I found more information on Microsoft's web site.

   For an experienced system administrator, this book is not for you. If you are an absolute beginner and want to learn a few simple tasks using VBScript, have at.

   As for Mr. O'Connel's comment above, perhaps I should have been more specific. For example, while the book does show you how to create & delete users and OU's (incidentally with error-ridden scripts), nothing about the underlying ADSI object model is discussed. There are hundreds of ADSI objects available through LDAP, few of which are covered in this book. For the ones that are covered, there is no discussion of the attributes or methods of these objects.

   So, yes, I did read the same book as Mr. O'Connel. However, I was seeking "way more detail" from a book entitled "Managing Windows".




2. Was Joseph DeMarco (previous review) reading the same book? The book has several chapters on AD scripting, and they showed me how to create users, delete them, create OUs, and more. The book has THIRTEEN chapters on learning VBScript, which I didn't know and now I finally do. They're clearly written and they're not super-deep, so I got through them quickly. If you're a professional developer, this book isn't for you. If you're a systems administrator, I can't see how this book wouldn't be helpful.

   The book has several "Putting it All Together" chapters which sum up everything that came before and show you how to design, write, and debug a complete script. I took a previous review's advice and checked out the authors Web site and there are GOBS of additional script samples, tutorials, and more. The book doesn't, for example, go into remote scripting - which I think would have blown my mind when I started - but the Web site has a good tutorial on it and several user discussions on it.

   I bought the Micosoft Windows 2000 Scripting Guide and thought it was WAY too deep. Every time I started to learn something it would go off on a tangent. That book is starting to be useful to me as a reference, now, because it contains SO MUCH information, but Don Jones's book showed me how to make sense of everything.




3. This is a nice introduction, reasonably well written, introduction to using Windows automation through VBScript. About a third of the book acts as an introduction to the basics of VBScript for use in this context. He covers basics like variables, conditionals, functions, error handling, and more. The other two thirds of the book covers a variety of topics like shell extensions, ASP, XML, active directory and more. This is up-to-date stuff.
   
   On the downside the exposition depends a little too much on code. But if you like that sort of thing you will do well with that. It's not unusual for tech books, but it's enough that I took a star off for it.



4. I was up and running in no time. Finished this book in a couple weeks, and was automating my companies Terminal Server user environments and Active Directory tasks in no time. I recommend this book to any beginner, as well as to someone just needing to solidify some concepts they may have missed while "frankensteining" their scripts. You know we've all done that!



5. Very Good Book for Admins who are not very comfortable with programming. Covers from the Basics till Advanced topics. Good buy if you want to take control.

5 comments about JSTL in Action.

1. Review
   One way to develop dynamic page content on a web application is to use JavaServer Pages technology. This allows you to embed bits of Java code, or scriptlets, within the HTML page. The web server interprets the scriptlet when the page is called and produces the content that is coded. This is all good, but there are common tasks (such as looping) that each developer had to reinvent from scratch each time it was used in a page. To prevent this repetitive coding, a common set of JSP tags were created to allow developers to concentrate on business logic instead of coding structures. This creation is known as the JSP Standard Tag Library (JSTL). That's what this book is all about...

   The book starts with an examination of how JSP and XML tags come together to form the basis of JSTL. This is followed by a number of chapters that cover the different tags that are used to control branching, flow, text formatting, and other various structures. After the basics of JSTL, the author looks at a number of common tasks encountered by JSP developers and how they would be coded using JSTL. Finally, the book wraps up with reference data needed on a regular basis as you use JSTL, such as the API.

   The writing is clear and concise, with an abundance of diagrams and code to illustrate the points. The mix of reference, tutorial, and practical examples is perfect, and every developer will be able to use this book in a number of situations.

   Websphere developers (both web application and portlet development) will get the most out of this book when it comes to the IBM/Lotus world. The use of JSTL will reduce the code complexity of your JSP pages and speed up your development efforts.

   Conclusion
   If you are developing JSP pages and haven't looked into the use of the JSTL area, get this book. It will save you time and effort in your coding, and you'll be glad you did.




2. This is a good book to learn about how to use JSTL. It has an excellent reference section, and the body of the book explains how to use the JSTL tags with many good example. On the whole, a very useful, readable book. One negative: The author has a sense of humor which some might find odd, and he interjects it throughout the book; at times it's distracting. But if you can get past that, you'll find this to be a good resource.



3. This book was very helpful for getting up to speed on JSTL. My company is about to kick off a new struts project, so we needed to get up so speed on using JSTL with Struts. There wasn't much coverage on this, but overall the book was good.



4. I have not read the book, nor do I plan to. But I do know that Shawn Bayern is the shiznit. Can anyone deny his caustic, "adult" wit? One look at the sultry wench on the cover will inform you of all you need to know if its contents.
   
   Huzzah!



5. It's hard to describe with mere words how incredible this book on JSTL is. Truly Shawn Bayern is the second coming of our Lord and Savior, Jesus Christ.
   
   While this book is great in helping people to learn about JSTL, it's also the latest testament of the Son of Man. Mr. Bayern's writing is excellent, and it so happens that it will be he who leads his flock to glory after the apocalypse.
   
   Those of us who purchase his book will find salvation. The others will be left below.

5 comments about Beyond Java.

1. This books doesn't say Java is dead. It points the problem that the platform and (mostly) tha language has and try to show alternatives.
   
   Although totally relevant, this shouldn't be a book. It should be presented like a series of articles in some website or something like this, this book is totally temporal.
   
   Anyway, if you follow the JCP and the path Java 5,6 and 7 are following you see thar Tate is not far from the truth.



2. There is a lot to like in this book, and a lot not to like. I'll talk about the negatives first and then discuss the positives.
   
   The style of the book is extremely annoying. The author is a kayaker and a mountain biker, and he introduces each chapter with a kayaking/mountain biking story meant to serve as some kind of analogy to the programming topics he'll cover in the chapter. I found this unnecessary and distracting (I don't need sugar coating on my technical reading), and it felt like the real purpose of the stories was for the author to demonstrate how cool he is. In addition, the author uses the phrase "a perfect storm" over and over and over to describe the factors that led to Java's position of dominance in the programming world. I hated that expression even before I read the book; it has to be the most abused expression of the last few years.
   
   Despite the fact that the book is ostensibly about programming languages, the author is by no means an expert on the subject. To his credit, he admits this freely, but he also makes numerous small and not-so-small mistakes when describing programming language features which may lead more knowledgeable readers to wonder if he's really qualified to write this book. For instance, in several places he describes the advantages of static typing as being mainly for early error detection, without also pointing out another big advantage of static typing: faster code (there are other advantages as well). In another place he makes the blatantly false statement that "Smalltalk is where all the continuation research is happening", ignoring the fact that Scheme (a Lisp dialect) has had continuations since 1986, and that there has been and continues to be active research on continuations in Scheme ever since. Then he says that "In Lisp, everything is a list." Wrong again. He also seems to assume that statically-typed programs will always be verbose, indicating that he is unfamiliar with statically-typed languages like Objective Caml which have type inference. The bottom line is that he often doesn't know what he's talking about when he compares the features of different programming languages.
   
   The author's programming expertise appears to be primarily in the domain of small to medium-sized web applications. This is an important domain, but it's far from the only programming domain. So the book's subtitle "A Glimpse At the Future of Programming Languages" should really be "A Glimpse At the Future of Programming Languages for People Who Exclusively Write Small to Medium-Sized Web Applications and Nothing Else". If you want a broader picture, or are primarily interested in another domain, look elsewhere.
   
   The author is clearly aiming the book at programmers who primarily program for money. Not that there's anything wrong with that, but given the author's expressed fondness for open source software (which I share) it might have been nice to acknowledge that some people also write programs for the joy of it in addition to (or in lieu of) the financial rewards.
   
   Now that I've covered the bad, let's look at the good. The author seems to know his domain well, and he makes a good case that Java frameworks for writing web applications have gotten so baroque and tedious that they are simply miserable to use and lead to very slow development cycles. This might be just the fault of the frameworks and not the language, but the author makes a good case that specific language features (or the lack thereof) are what make Java so clumsy for writing web applications. He contrasts Java primarily with the Ruby language, and specifically with the Ruby on Rails web framework, and shows that several features of Ruby make for a much more productive programmer experience. For instance, Ruby's ability to express configuration information inside the language obviates the need for much of the XML that clutters up Java web applications. The author spends a lot of time discussing Ruby's metaprogramming capabilities and how they make it possible to write much more concise code with much less repetition. An example is a class which reads from a database and populates itself on-the-fly with methods to access specific database fields. (Small gripe: the term "metaprogramming" has a variety of semi-related meanings, all coming down to the notion of code being automatically generated instead of being written by hand, but the way that e.g. Lisp or Scheme macros or C++ templates represent metaprogramming is very different from Ruby's metaprogramming, and the author doesn't discuss that.)
   
   The most interesting chapter by far is the chapter on continuation servers. The author gives a clear (though short) description of continuations, which is no mean feat given that they are one of the most difficult-to-explain concepts in the entire universe of programming languages. More importantly, he discusses how they turn out to be extremely useful in web servers, allowing web-based programs to be written in a much more natural and concise style than is possible without them. He uses the Smalltalk language as an example, because there is a continuation server written in Smalltalk. (Another gripe: while I'm happy to see him acknowledge that Smalltalk is a good language, I might have liked it better if he also mentioned that the Scheme dialect of Lisp also has continuations (as I mentioned above), and that there is also a web server in PLT Scheme that is also continuation-based).
   
   The take-home message of the book is that writing small to medium-sized web apps in Java is rapidly becoming more trouble than it's worth, that more dynamic languages like Ruby have features that make it much easier, and that therefore there is a good chance that these languages will take over much of the programmer mindshare. I agree with all of these points, and think that today's Java web programmers are well advised to look at other programming languages. However, I also feel on general principles that all programmers would do well to learn another programming language every year or two, so for me this book just reinforces my pre-existing view.
   
   On the other hand, the author mentions, but doesn't emphasize the fact that the JVM has many capabilities which far outstrip those available in Ruby or Python or indeed most other languages. He does point out that many advanced features of Java frameworks are only useful for very large scale web
   applications (the domain that J2EE targets explicitly), and are unnecessary for the majority of (smaller scale) web applications. He leaves open the extremely important question of whether frameworks like Ruby on Rails will scale well to larger applications, or to smaller applications when they need to grow larger, though he seems to believe that they will (if not now, then later when the language and its implementation or implementations mature).
   
   In summary, I think this book is a decent read with a lot of food for thought, if you can handle the irritating style, the mistakes and the omissions. This book is far from the last word on this subject (the reader should be aware that there are lots of interesting computer languages that are not even mentioned in this book, with Objective Caml and E being two obvious candidates), but it's interesting nonetheless.



3. What held me back from 4 stars was the repetition. This is a small book -- easy to read in one sitting -- and I felt that there was some repetition in a few places that would have made the book tighter, smaller, and a better read.
   
   That said, repetition is the mother of skill and I think the author is making a very good point here in his speculation.
   
   Java is growing 'old' and while the future and present has shifted away from EJBs and toward lightweight containers and aspects, this may not be enough.
   
   There is a 'next big thing' looming on the horizon... the trick is, what is it?
   
   Ruby with Rails is the author's guess. It isn't made by Microsoft and it addresses the 80-90% of distributed applications that need to bolt a website to a database. It'll be made to scale and hit up against enterprise needs (eventually) but it's sweet spot is commodity and indeed smaller apps.
   
   While I think the author discounted MS a little prematurely, and PHP as well. I agree with the point completely. There will be a 'next thing' in application programming, it will be web based, and Java and JEE are too complicated to win this battle.
   
   A good read.



4. No doubt about it, Java is king of the hill right now, as of this review, I'm trying to hire 3 Senior Java/J2EE people in Atlanta and I'm not having much luck. Well if that's true then why am I reading a book about what's next after Java?? Bruce spells it out pretty clearly in this book, Java made developers much more productive than C++ developers for about 10 years now, but if you look at accomplishing some simple tasks like sticking a Web UI in front of a database it requires a lot of plumbing and knowledge.
   
   Does it have to be that hard? Not really, he really keys in on Ruby and Ruby on Rails to meet the needs of middle tier, those just trying to get a database driven application in the web. One thing he did not present, but is a big issue driving PHP and Ruby on Rails is how hard putting a Java App is on a shared hosting platform; in fact I gave up and went with Ruby on Rails.
   
   So where does that leave the hard-core Java/J2EE programmers? Well right now that leaves us at the enterprise level, where Java is still king talking to all the legacy systems. This is not a bad place to be though, since large companies are the ones with the big development budgets but you still need to look out for what's next.



5. This book was a quick and enjoyable read. I think the premise is right on: Java is too complex and has become a hindrance to productivity.
   
   I liked the conversational style of the book. The author makes some good arguments against Java, and provides alternatives. He attempts to make a strong case for Ruby. After reading the book, I will definitely give Ruby a look.
   
   I have several problems with the book:
   
   #1 It is highly repetitive. This is more noticeable because the book and its chapters are very short, so it can be read in one sitting. It doesn't feel like any research went into the book (aside from personal interviews) so the scope is only what the author is most familiar with (ie. he mentions Hibernate/Spring/Tapestry over and over again. He brings up static typing impeding productivity many times over the course of the book...obviously a personal gripe of his.)
   
   #2 It is not an objective analysis. After reading the book, I believe the author to be a Ruby evangelist. In particular, I didn't appreciate a section where the author shows an example of how Ruby outperforms Java. He clarifies by saying the evidence is unscientific (the Java implementation was not tuned for performance.) Well if that is the case, then it doesn't belong in a technical book (from O'Reilly no less.)
   
   The author suggests the possibility of fixing Java, but it strikes me as an obligatory mention. Beyond Java is this author's (well informed) opinion, no more no less. It did not convince me to throw out the Java baby with the bathwater. Nonetheless, it provided some interesting food for thought.

3 comments about SQL: Access to SQL Server.

1. I read a lot of books covering topics from Access, SQL Server, to VBA. This book covers all of the "required" Access topics. It covers them better than any other book I have ever seen. It then goes on to cover topics I have not seen in other books or classes. While reading the book you will catch yourself saying why have I never seen this before, or hey I can use this! It uses Jet, Transact & VBA. Do you want to build better applications, do you want to know more than the competition, do you want to be a better developer? If so, this book is a definite purchase.

   This book is already my favorite book of all time, replacing "The Guru's Guide to Transact-SQL
   by Kenneth W. Henderson, Ken Henderson". (You should get that book as well). I also just purchased "Microsoft Access Version 2002 Inside Out (With CD-ROM) by Helen Feddema" and I think that book will also be in my "top three" books to reference/read.

   If you are serious about being a top developer, get this book.




2. This book is well written and easy to follow. The explanations are written in clear language and instructions are written out step by step. The book is well organized which means it's easy to use it more as a reference book. But, it is such a pleasure to read, you want want to skip a single page. This book covers both very elemental aspects of SQL, but also has much to offer the more experienced user.



3. I own about 30 books about Access (all versions). This book tops all of them. If you are using Access 2000 or 2002(XP) and you like to know about SQL Server (2000), trust me this is it. Try to read it from begining to the end. It's written in english language (not technical slang) and it shows you some cool tricks even for those Access 97 users. Hope to see more books from these guys. Thanks

4 comments about Assembly Language Programming for Intel Processors Family.

1. Lungu gets you up to speed on assembly programming for the Intel chipset. It is the dominant family of microprocessors for the desktop, giving you ample incentive to learn to code it.
   
   The book goes through some elementary concepts in generic assembly programming. Things that are common to any von Neumann architecture. But the bulk of the text is directed to Intel-specific instructions. A powerful set of commands. The book is bulky because these use a CISC approach. And indeed, some commands can be quite complex to invoke.
   
   The amount of information to assimilate is nontrivial. I once programmed the Intel 8085 in 1982. The increase in complexity in going from that 8 bit chip to today's 32 and 64 bit Pentiums is astonishing. The hardwired multiplication that a Pentium can do might seen mundane to you. But we had to code our own multipliers back then. Plus being able to run a Pentium at multi gigahertz clock speeds nowadays gives so much computational power. Versus running an 8085 at 1 MHz.



2. It has been my experience that the best programming books teach by presenting increasingly sophisticated examples, starting perhaps with the ubiquitous "Hello, World!" and moving on to more complicated topics. In this book, however, the first significant programming example doesn't appear until page 229, over 1/3 of the way into the text.
   
   While it is clear that the author is an expert on the topic, his presentation of the material leaves much to be desired. The book is also rife with typographical errors, and I felt that many of the diagrams were sloppy- both things that might be frustrating to a novice.
   
   For a book on modern computer architecture, I'd suggest the classic text, "Computer Organization and Design" by Patterson and Hennessey. For Intel-specific assembly language programming, check out the book by Kip Irvine.



3. This was my first ASM book I've bought: it was the first original edition in Romanian (didn't read the English translation yet).
   I must agree that it has many typographical mistakes and some of the schematics are not very easy to understand.
   It is made up of two parts the first one being the Intel processor architecture and the second the assembly language and integration with higher level languages (FPU, SIMD included).
   By combining the information in this book and Ralf Brown's Interrupt list one can learn and do almost anything with x86 CPUs without waisting your time with unwanted details found in other ASM books.
   If you are a beginner (never touched asm) you should consider reading this after you get bored with those thick ASM books and keep it as reference.



4. I believe that this book will be able to "whet your beak" if you are starting to study the Assembly language, but I wouldn't say that it is a complete beginner's book. It is entirely true that this book is full of typographical errors, however, because it was translated from Romanian, the tone of the text is neutral and the author does not sound pretentious (My library of computer books outweighs 2 average-built people, and it is common for the American software developer writers to sound self-absorbed). I felt that the subjects of this book were covered in detail. I believe this book has the power to widen perspectives on the Intel machine hardware architecture and will be of help in studying the Assembly language itself.
   
   The first part of the book which constitutes to about 150 pages or so is all theory, and we do not see code examples until the mid section of the book. I don't believe a book should be all about code, and felt it was a reasonable approach. Where there is no code, the author gives extensively deep detail about the subjects he is writing about. I was impressed by the introduction that contained detailed information on the history of the processor, and some of the key points that no other book I have talks about.
   
   One thing I would wish for is a closer analysis of the MMX instruction set and more on practical implementation, to which the author dedicates only several pages. He does however talk about it throughout the text here and there.
   
   Another great book that I recommend for beginners is Assembly Language Step By Step by Jeff Duntemann which is also written in a non-pretentious tone and simply is a joy to read whether you are a serious programmer who wants to know details or someone who is interested in how the computer works on a lower level. http://www.amazon.com/Assembly-Language-Step-step-Programming/dp/0471375233

2 comments about Essentials of 80x86 Assembly Language.

1. I received this book in August 2006 from amazon with the assumption it would be as up-to-date as possible since it was just published. Inside the book, it says copyright 2007 --- *six months in the future*. Wow, this book should definitely be the most up-to-date information anywhere, right?
   
   NOT. This book contains ZERO information about SIMD, SSE, etc. No SIMD instructions, no MMX or XMM registers, nothing-at-all. Furthermore, it contains ZERO information about 64-bit opcodes or architecture.
   
   In other words, this 2007 book is intended for programmers who have time-machines and want to send the book to themselves about 15 or 20 years in the past. For that purpose, it is reasonable.
   
   I believe this book is intentionally organized to fake people into buying it on false assumptions. Typically, modern books begin with statements of intended audience and conventions. Then, people who browse the early pages of the book online can understand what they are buying.
   
   True, an advocate of this book could argue the term "80x86" should tell us this is a review of ancient history. However, that is merely a sound-bite cover-story, since they know many other assembly language and CPU/programming books refer to the whole series of 8086 through current Intel/AMD CPUs with this exact term "80x86". For example, "80x86" is the term Leiterman describes these architectures in his assembly language book, which includes architecture and opcodes through SSE3.
   
   And of course, the author and publisher "accidentally" (my foot) forgot to make the table-of-contents, index, and early pages reviewable on the amazon web-site. How convenient! For them.
   
   So, if you have a time machine handy, or only want to code for ancient CPU chips, and you prefer to hide from every efficient and modern feature added to CPU chips over the past decade, this is a simplistic presentation appropriate for total beginners.
   
   Consider yourself warned.
   
   I almost forgot!!! The same author has a seemingly identical book with a title that begins "Introduction to 80x86..." instead of "Essentials of 80x86..." on the amazon site, and scheduled for release on November 30, 2006 (it says). The same tricks seem to apply - they want us to click the "pre-order" button for yet another 80x86 book without table-of-contents, index, etc. Until we have some actual information, we must assume this is another ancient-history book. What's the cliche? Twice burned, shame on me? I say, shame on the author and publisher! To them I say, "make the TOC, index, into pages of your books visible". Frankly, amazon should force these guys to do that.



2. I highly recommend this book. I bought this book not to learn but to review Intel 80x86 assembly language programming. But, I believe it would be an excellent test to learn from. The author provides a working copy of MASM and a Windows Debugger to trace the execution of your code. You can see first hand what your instructions do as they execute. Also, there are PLENTY of hands on programming problems for you to code and run. This gives you the confidence to know that you actually learned something.
   
   A SPECIAL SURPRISE for me was that Richard (the author) provided a whole chapter on FPU assembly language. Something that few texts cover. And the very few that do scarcely touch on the subject. So if you want to learn Intel FPU programming this book is for you. (FPU = Floating Point Unit).
   
   WARNING: This book is NOT an advanced assembly language book. So, if you're looking to learn MMX technology commands and OS programming, this book is NOT for you. The title of the book is ESSENTIALS of 80x86 Assembly Language. It covers the basics of Intel 32-bit flat memory model console programming stilled used today. So, the book is not out of date, it just covers the basics.
   
   I RECOMMEND that before you tackle this book, which isn't very thick, that you go through Jeff Deuntemann's Assembly Language Step by Step. Why? Well, even though Jeff's book doesn't give much hands on experience that Essentials of 80x86Assembly Language does. Jeff's book gives valuable information in novice terms that helps beginners bridge the gap from high level programming languages like C++ and Visual Basic to assembly language. So, I'd buy and read Assembly Language Step by Step before tackling ANY assembly language book on the market. I'd consider Jeff's book Pre-Assembly Language sort of like there are Pre-Calculus books. Then get this book (Essentials of 80x86 Assembly Language) or Assembly Language for Intel-Based Computers by Kip R. Irvine. Both are excellent treatise on the subject.

1 comments about Programming in Mathematica (3rd Edition).

1. I read 2nd edition of the book. "Programming in Mathematica" (PIM) is certainly a classic work (in programming style) for writing Mathematica packages. I also think it as a perfect example of literate programming in Mathematica, if you are trying literate programming in Mathematica.
   
   The literate programming style encourages writing explanation explicitly with the computer code so that both get pretty-printed and become human friendly. PIM is exactly such a perfect example. Nearly each Mathematica code piece in the book was clearly and elegantly explained.
   
   I noticed that Silvio Levy commented at the back of 3rd Edition of PIM. Silvio Levy is one of the creators of CWEB, a literate programming tool for C language. Wondering if this book also satisfies his taste of literate programming.

2 comments about Professional Visual Basic Interoperability - COM and VB6 to .NET.

1. Its only a couple of months after the retail release of Visual Studio .Net and we are still coming to terms with the new reality - and it will take months and not weeks to feel cool about it! Once you start to feel comfortable with VB.Net the language - I am still a bit shell-shocked - then you have to start thinking about migration and legacy. This is when all the smiles drop! From a time and cost perspective we know that this is where we have to get it right.

   What is great about this book is that its written by highly skilled and seasoned fellow programmers - these guys know their stuff - they know the issues - they know the reality, and they focus just on interop! Make no mistake interop is not a cake-walk and we need a technical bridge. The discussion on API calls, COM & Marshalling and DCOM-Remoting-Web Services were terrific.




2. I have been pouring through a lot of books on .Net and when I first pulled this book out of the box I thought there may not be much to it because it didn't appear too thick. I couldn't have been more mistaken.
   First, the print is smaller than most Wrox books I've seen. Second, this book packs in a lot of practical, heavy technical advice and samples in communication from .Net to COM, COM to .Net, Custom Marshaling and much more. Its well worth the money you'll spend and sure to become a heavily used technical resource.