5 comments about VB Shell Programming (Visual Basic).

1. Visual Basic and Shell Extension? I thought it should be Visual C++'s territory. The book proves Visual Basic can do anything as Visual C++ can. It might take more works to finish the same task compared to Visual C++ but the experience is simply rewarding and fun.



2. A must read for those who like to push VB beyond the limits, previously viewed as 'impossible to do in VB'. Very well organized and lots of examples.

   Excellent reference material and a worthly investment.




3. First off, if all what you want to do is to add an icon to the systray, go find _any_ Win32 API book or even search on the web. This book does not cover simple tricks like this. But if you want to write your own namespace extensions or property sheet handlers, read on.

   Many people think VB and windows shell programming don't mix very well. Honestly, I was one of them. But after reading this great introduction, I figured I was wrong. Well, mostly wrong.

   There are two issues that make shell programming hard in VB:

   (1) As in most "advanced VB programming tasks", the first realization must be you _can't_ do it in pure VB. You need to import Win32 APIs and then fake you are writing your program in C. But that's a very old and well-solved problem, and in fact this book assumes you know how to do it: it shows the import statements without explaining how to get them. But that's fine, for I think most advanced VB programmers have already picked up this old trick.

   (2) The windows shell is built heavily on COM, so must be the shell extensions. But this book is not about writing COM servers in VB... Apparently the author did not expect the readers to know COM before, so he offered a short chapter on COM basics that I find too short to be sufficient for the purpose of this book. For example, later on he started using jargons like "in-process COM servers" and "apartment threaded" (these are COM jargons) without explaining what they are. I tried to look up these terms in the index to quote the page number. They are absent---yet another proof of insufficient coverage of COM. I admit that shell extensions are in-process COM servers and so in most cases the readers are not expected to do anything else anyway, but this kind of treatment much weakens a reader's understanding of what he/she is doing.

   And there are other problems that plague this almost excellent book:

   (1) There is no separate treatment of what should the programmer do when a new shell extension comes out. As an example, icon overlay is not covered in this book. I think this is really the major reason I have to take half a star off: this book is more like "how I wrote those shell extensions" rather than "how you can write your own ones". For example, it does show many examples of how to turn a given IDL into more VB friendly, but not how can the programmer obtain the IDL of an interface that's not covered in the book. (OLE View won't answer all such prayers. Go check the platform SDK or, _cough_, wait for the second edition of the book to have a new chapter on that extension. :P)

   (2) There is no coverage of debugging shell extensions. It's not as easy as one may expect, especially as VB will automatically re-register your COM servers when you execute your code while Explorer loads some registry entries only once...

   Overall, this is a more than decent introduction to shell programming using VB. If you want to do some typical shell programming like having your own property sheet or namespace extensions, then this book is really good for the job and is worth every single penny. I would rather say it's 4.5 star, but I have to round down for the minor problems I mentioned.




4. I particularly like the Shell Extension part which is very
   useful to understand somthing more advanced in Windows Shell.

   However, what disappoints me is that I found the sample codes from
   Chap 11 (Both sample projects DemoSpace and RegSpace) crash in
   machines running Win2K. This means that if you want to use the
   techniques taught from the book to implement a Shell Extension
   by VB, you can only support platforms below Win2K. That will not
   be much useful at all.

   As far as I know, the author has not yet figured a solution
   (through private communications with Orielly's book support).




5. I have a love hate relationship with this book. There are a lot of useful techniques spelled out in the book, unfortunately there are serious bugs in the demo code. I have been able to fix a few of them, but am still working on others. Maybe this was on purpose to get the reader to truly understand the code rather than blindly copy it.

1 comments about Modern Compiler Implementation in C: Basic Techniques.

1. This book provides a great overview of compiler-writing in general, with excellent discussions of issues like parsing, code generation, register allocation, and optimizations. This particular version (the C version) of the book, however, seems to contain a lot of typos in the code samples -- even without a compiler, I could see that most of them will not compile. If you can figure out what he meant, however, the algorithms are very sound.

4 comments about Visual Basic .NET Solutions Toolkit: 30 Practical Components for .NET.

1. The solutions are great, if only they worked in real life and not in theory!.

   The Auto Deploy just doesn't work (returns an error that there is not information for!) and the Application Settings writer is great in theory but in reality its easier to use the registry setting to achieve and easier to implement the result in a large scale development....

   Conclusion...don't waste your money...




2. When I first got this book I thought it was a pretty innovative idea for a book and skimmed through it but didn't put it to much use initially.

   A couple of projects later, I've used around ten components from the book with a couple more slated for the next project I'll be doing. In dollars, that's huge.

   All of my projects were done in C#, so I can't comment on the whether or not the source is 100%, however everything is explained well enough that even the most junior developer will be able to work around any problem, should any arise.

   All in all I would recommend this book to anyone.

   (Note to Wrox, let's get some equivalent C# books out!)




3. This book makes good on it's promise to present a compelling collection of components for us to use in development. It does so in a very logical way, explaining what each portion of the component does and how it works. The solutions presented are practical, well thought out, and generic enough to CUSTOMIZE to your need. The beauty of this book is it gives you many new tools to use in enterprise windows/web application development while at the same time leaving an extensible open architecture. Anyone who criticizes a book because it doesn't offer 100% turn-key code reuse should be slapped. All others should BUY THIS BOOK!!



4. I wish there was a return policy. The book covered a lot of material but there wasn't anything new to learn from it. You would be better off spending your money on a .NET magazine subscription. Anything that was written in this book can be found on the web and won't cost you anything.

No comments about Microsoft Quickbasic: An Introduction to Structured Programming/Book and Disk.

No comments about C++ BASICS (Begin and Succeed in Computer Science) : Book w/ Data CD Pkg.

5 comments about Professional VB SAP R/3 Programming.

1. Details with examples. Good for all SAP R/3 tools and application developers. Explains BAPIs, RFCs, bussiness object repository (BOR), SAP DCOM Connector component etc.



2. I'm not a VB programmer. I obtained this book to better understand how BAPI's worked and could interface with external applications based on a project team demand to develop better masterdata loaders. The first three chapters alone are goldmines of information that are neatly tied together and explain the concepts and framework used. After reading them I understood why SAP went this route and better understood some of the potential areas where BAPI's could assist our development team. The latter chapters get into more VB oriented issues but are useful regardless of VB experience (or lack thereof). Our VB developers all own this book.



3. An excellent guide for understanding BAPIs and RFCs, complemented with good explained VB programs which are useful for learnig how to develop interfaces whith SAP using VB.



4. I bought this book knowing VB but was new to R/3. Within days I had a working interface to SAP. If you want to use COM objects to connect to R/3 and make remote function calls this is the book. Great examples on using late binding too if you want to put the functionality into a dll without having a control bound to a vb form. Of the many computer books I've read, this is one of the best.



5. "Professional VB SAP R/3 Programming" - demonstrates how to combine existing Visual Basic tools with the new extensibility tools, so that you can develop robust enterprise applications based on SAP R/3 from a non-SAP programming environment. It also explains the fundamentals of SAP, including the new SAP tools and technologies. SAP R/3 business objects and BAPIs are implemented and a guide to the SAP Business Framework is illustrated. The SAP R/3 Automation tools are used to replicate SAP functionality from VB and the DCOM Component Connector is used to generate business object proxies, aswell as programming the core components of the DCOM Component Connector. Browsing the SAP R/3 Business Object Repository is demonstrated and working code samples of both inbound and outbound SAP R/3 operations are included...

2 comments about Oracle and Visual Basic Developer's Handbook.

1. This book should be renamed "Oracle Objects for OLE (OO4O) Developer's Handbook". It details the latest and greatest features of OO4O, including support for Oracle REF's, LOB's, and AQ. However, coverage of ADO/OLE DB is very weak, with only 7% of the book (the final chapter out of 14) dealing with Oracle's OLE DB Provider and ADO. It also lacks specifics (features and limitations) on Oracle's ODBC drivers, and practically there is no mention in the book of Microsoft's ODBC and OLE DB products. Microsoft MTS is only briefly mentioned in the OLE DB Provider chapter, but no detail is given on how to set up the database and web server to use MTS.

   If you want to get the hard-to-find information on connection to Oracle from ASP pages, you will be disappointed again. Although there are 2 chapters on connection pooling and transactional control, they focus on the OO4O implementation. You will not find info on the best practice for achieving scalability using ODBC/OLE DB connection pooling, or how to deal with the pros/cons of storing ADO connection/recordset objects in session/application variables, etc.

   The level of this book is at the beginner level, although the back-cover has it as intermmediate/advanced. A major portion of the book is spent repeatedly explaining what each line of code does, even though it is obvious towards the later chapters of the book. There are other types of inefficient use of pages such as instructions how to place a visual control on a VB form, i.e., details for how to use the VB IDE. People reading this book should be assumed to have basic knowledge of VB, even though they may come from a PL/SQL background.

   To repeat, if you code OO4O, this is the best book on the market (there are only 3 other VB/Oracle books available, if I may add). If you do ADO/OLE DB/ODBC, this book is not going to help a bit. The OLE DB chapter I mentioned earlier is almost a rehash of the User's Guide that comes with the OLE DB Provider. For developers in the ADO/OLE DB camp, I recommend the 2 books from Wrox Press (Professional ADO 2.5 RDS Programming with ASP 3.0 and VB Oracle 8 Programmer's Reference).




2. The book should have been titled "OO4O Programming with VB" and that'd merit 4.5 stars!The authors (all being Oracle Tech and Support Analyst) do a very good job of describing the workings of OO4O. While a section is dedicated to ADO, ODBC, and OLE DB, this book is primarily for OO4O users-to-be. Since I was looking to use ADO and OLE-DB, I found this book interesting but useless (only 1 example). What tickled my fancy (and I am still reading it!) is the book "Visual Basic for Oracle 8" by Dov Trietsch (Wrox) which does an unbiased treatment.

5 comments about Visual Basic(r).NET: The Complete Reference.

1. Simply put, this book is amazing. In order to take fully advantage of the .NET Muscle, you need a full understanding of the .NET Framework. This book will take you there. The chapter that covers the differences between Value Types and Reference Types is hands down the best I've read. Mr. Shapiro has a gift for writing, so be sure to take advantage of it.

   - MKP




2. You have to read this book, before you spend thousands on a VB.NET course.

   I read Mr Shapiro's first VB.NET book in late 2001 and made up my mind that I needed to make the move from VB to VB.NET asap. I am a VB/ASP programmer still struggling with OO design concepts and patterns, and I find his insight into the software development and design process quite remarkable indeed.

   He writes with a wit and with metaphors I have not seen elsewhere, and made tackling the complex subjects much easier more me. You'll be chuckling at some of the stuff he says. I find it hard to learn from computer books and prefer classrooms, but reading even the first 30 percent of this book, has saved me a bundle in time and money.

   I am more concerned about code than classes and figured that the new OO in .NET would put me off. But I was especially pleased to see Mr Shapiro tackle stuff like merge sort and quicksort and then place them in context with various .NET "features" like delegates, and interfaces. Incidently, if understanding interfaces and delegates has you scratching your head, this is the only book I found, browsing at the bookstore, that devotes a whole chapter to each subject respectively. At first I thought his notes on why Sun hates delegates would not be much use to me but they go a long way to understanding why .NET has delegates and interfaces and Java only has interfaces.

   There is also a very comprehensive linked-list example in this book that shows you exactly how to implement interfaces, like IEnumerator, and IList, stuff which very few seem to understand and which are very alien to a VB programmer.

   No book is perfect. There are a few typos in the text which are clearly last minute changes the publisher forgot to correct. The source code examples compile without issue. I will be looking for his next book for sure.




3. the first code example doesen't even work!
   He must have tested it in the beta version because his examples are sloppy, and poorly organized. I would have liked to have seen more code. In some spots his explinations are overly simple. In some spots it seems like he doesn't know what he is even talking about so he just fills in with techno-jargon. Mostly the code is just plain disappointing, what does work, needs to be re-worked so that it is not so buggy, for example, he uses implicit class declarations to demonstrate inheritance, then talks about the importance of strong type declarations. It goes on and on like that. His code on the web is not any better.

   Don't waste your money, I think that I will get a Wrox book next.




4. I'm still trying to catch up with the "rest of the gang" so this review is later than the others.

   It is a very good book in applying computer science knowledge like data structures to .NET. I have seen better explanations of interfaces in other books: for example, Deborah Kurata's "Doing Objects in Visual Basic 6", Jesse Liberty's "Programming C#", and the classic on C#, Grant Palmer's "C# Programmer's Reference".

   Regarding the downloaded code, I found it to be much better than most. I corrected 5 problems: 1. A "Shuttles" dll had to be created so "ShuttlesInjectorUI" would work (make sure the reference for this is set correctly, also). 2. "Math" didn't have a module, which I created from the book (though the two formulas for area mystify me: correct formula, area = pi * radius **2). 3. The reference to "vb7cr" in "Nodals" had to be corrected in the project properties. 4. The "BaseTree" module was in the appropriate directory, but had to be added to the "Nodals" project. 5. The "protected" access modifier for "StopInjector" in "Shuttles" had to be changed to "public".




5. When you buy a book with "Complete Reference" in the title, you expect one of two things:
   
   1. A thorough reference book that you can use for, uh, reference.
   
   2. A book that will completely explain whatever is in the last half of the title - Visual Basic .NET in this case.
   
   This book fails dreadfully on both accounts.
   
   Let me start by saying that I absolutely love Visual Basic .NET. It is a terrific development environment, and once you start to get a feel for working with objects, you wonder how you ever finished a project before.
   
   This book was actually the first .NET book I bought, over two years ago. I found it utterly incomprehensible and had to go on to other books for help in learning to use Visual Basic .NET. Recently, I've been reading through it again - thinking the book might be useful as a reference now that I have a much better understanding of Visual Basic .NET.
   
   Wrong again. You are much better off with the online reference material that comes with Visual Studio. After realizing that I had wasted $30 and a lot of my precious time on this gigantic paperweight, I was stunned that this sucker got 4.5 stars!
   
   It turns out that one of the first reviews was written by none other than the book's author, Jeffrey Shapiro. (Needless to say, he gave himself five stars.) After reading some of the other five star reviews, I darkly suspect that they must be close, personal friends of the author.
   
   The fundamental problem with this book is that it is so abstract. A reference should, by definition, be detailed. This book spends hundreds and hundreds of pages talking about abstract concepts in object-oriented development in a very vague way. It uses lots of abstract object-oriented terms without really defining them. It doesn't really tell you "how to" do anything. You just come away with a vague impression that however you go about developing something in Visual Basic, it should be "object-oriented".
   
   The book was also poorly organized. (I don't believe that this is the fault of the author, though. It's the fault of the book's editors.) It is very hard to find anything in the book, which severely limits its effectiveness as a "reference". The index is terrible. Concepts which are mentioned in many places throughout the book will only have one or two entries in the index. This, too, severely limits the book's usefulness for its stated purpose.
   
   If you want to learn Visual Basic .NET (and you want to learn it from books) here are my recommendations:
   
   1. MURACH'S BEGINNING VISUAL BASIC .NET, by Anne Prince - This book is 700 pages of meticulous and thorough reference. This book tells you "how to" do almost any basic programming task in VB.NET, from creating user interfaces to accessing databases. The format is very easy to read and understand. Each section is very short, takes one topic at a time and covers it very thoroughly. The entire book is meticulously cross-referenced, making it very easy to find whatever you need. This should be the first book you buy.
   
   2. REFACTORING, by Martin Fowler - This book isn't specifically a Visual Basic .NET book. In fact, it isn't really language specific at all even though all of the references are in Java. However, you do not want to pass up this book. It is a classic in object-oriented development. It is very, very easy to read. (In fact, the very readable Java examples illustrate just how similar VB.NET is to Java.) REFACTORING is absolutely stuffed with simple, easy to follow advice on how to write better code (and how to fix the really lousy code you just wrote). I have had this book for nearly two years, and even now hardly a week goes by but I am picking up this book and leafing through it to glean more and more useful advice. One of the nicest things about REFACTORING is that the author, Martin Fowler, never talks down to you, the reader. He speaks to you as a colleague. The book also displays the author's very finely developed sense of humor. This makes the book easier and more enjoyable to read, but it never gets in the way of the material. I can't recommend REFACTORING enough.
   
   3. MURACH'S BEGINNING VB.NET tells you how to do all of the basic stuff that you're always asking about when you are first learning. REFACTORING tells you how to organize your code in such a way that it is easier understand and maintain. Once you've got these two books as a foundation, you can pick up any of the other excellent "how to" types of programming books for tips on specific topics.
   
   4. You certainly don't need it in order to be an effective developer, but if you want to study the abstract concepts of Object-Oriented Analysis and Design, go straight to the source and buy one of Grady Booch's books. Just be sure to bring your own oxygen: Booch tends to stay up in the stratosphere where the air is cold and thin.

5 comments about Visual Basic 6 Weekend Crash Course.

1. I found this book very beneficial. I hadn't done any programming other than some basic scripts for about 15 years. I found this book brought me up to date with VB6 and made me productive quickly.
   I find myself returning to the book as a resource for syntax help quite frequently.
   It may take someone completely new to VB a little longer to go through, but it is well worth it.



2. To me, this book teaches Visual Basic 6 in a friendly manner, but it lacks explanation in some areas. Even though, it still is able to teach programming farely well.
   Watch out! This book does contain flaws in code. I encourage you to buy a little reference book so you are able to point out and debug the wrong code.
   This book isn't a newbies dream come true, but it is a decently good Visual Basic 6 book.



3. OK, so it took a effort approaching that of Hercules, and I'm an experienced programmer with quite a few other computer languages under my belt -- but at least we know it's possible!

   I finished the book in 14 hours, 15 minutes -- including all of the review questions (usually just a mental affirmation when I knew the answer), plus 10 minutes to set up the included version of VB on my computer.

   One of the greatest things about this book is its motivating format. It's a challenge -- learn the essentials of Visual Basic in a weekend!

   And it was that challenge, plus the generally very positive reviews at Amazon.com, that motivated me to pick *this* book instead of a different title. Simply put, I decided this past week (because of a couple of opportunities that came up) that I ought to learn VB -- preferably, by Monday!

   I finished the book 15 minutes ago, at 11:35 p.m. Sunday night.

   My advice: start earlier in the week, and try to get in a bit extra time as you go along. Other matters took some of my time on Saturday and Sunday, and if I hadn't gained an hour and a half on Thursday evening, and half an hour on Friday, I couldn't have finished tonight.

   The other great benefit is that Mansfield majors on the things you'll use a lot, and skips the things you'll use less, to produce a package that actually *can* be completed in a short (and hence motivating) time frame. He claims "the VB vocabulary has been carefully surveyed to determine which commands you need to know for nearly all programming." Obviously, I can't verify that from experience -- but throughout the book he seems to know what he's talking about.

   Compare my experience in learning VB via this book with, say, my Java expedition: I began an 1100-page Java text almost a year ago, and I'm still stuck on page 257.

   Negatives: yes, it could definitely use some better editing, including, in places, editing of the code supplied. For humor, my own favorite example of this was:

   --------------------------------------
   For I = 1 to Numberofcopies
   Printer.Print Text1.Text
   Next I

   Notice the convention of indenting the code inside a For...Next loop. This graphically illustrates the loop.
   --------------------------------------

   (Did you see the indentation? Me neither!)

   Far less amusing is that the author should've included on page 279 or so the code for cmdNew_Click() that's on page 302. Also, my main finished application didn't behave quite as expected -- and if I'm "keeping to schedule," I didn't have time to debug it (that's OK, I learned enough from it).

   Incidentally, though, another reviewer's complaint of illegal names -- as in "1stSearch" (a variable name can't begin with a digit) -- was INCORRECT. The previous reviewer misread the text, which reads, e.g., "LSTSEARCH" (as in LIST BOX) -- *not* "1STSEARCH".

   For most chapters, you'll need to use your computer to really follow and learn the material. Unfortunately, the version of VB on the CD-ROM won't allow you to walk through all the steps in some of the final chapters, but the author (obviously knowing this) has provided more screen shots, allowing you to follow along.

   A time-saving tip: don't type in the code! Simply cut and paste it from the CD-ROM. Then review it line for line, either from the book pages or on your screen.

   A perfect book? No. But all in all, this text got the job done for me. I'm by no means a VB expert after one weekend and 375 pages, but I sure as heck am on my way. I give Mansfield's book a quite solid 4 stars out of 5.




4. I agree with everyone else that the book has some value, but not worth more than $10. The Wiley site is unresponsive to the feed back and judging from the amount of time that has elapsed since it hit the shelf, the publisher dosen't care. There's no errata sheet to download. I'll certainly keep this publisher's name on a post it on the monitor to AVOID future purchases.



5. This book starts out with an interest and plausible concept: to teach the reader the fundamentals of VB6 in a weekend. And it would be able to accomplish this task in at least a "four-star" fashion if the author and/or publisher had attempted to review the code for errors and debug the code. From chapter 22 onward the code errors are so serious that one cannot run the sample program since one uncorrected error builds on another (and coding errors are simple repeated in the code on the included CD) the book becomes practically impossible to follow along by coding on your own computer after chapter 22. What's worse, the publisher does not publish an errata on their website for this book.

5 comments about Beginning Access 97 Vba Programming (Beginning).

1. I'm a hobbiest programmer and recently purchased this book to start to work on databases. With little previous experience of VBA I have managed to now create quite sophisticated databases that pass information to other MS Office applications. I thought the chapters were very well written, and provide the depth of information that I needed. I would say this is an ideal book for anyone wishing to get a toe hold in this area of technology and a must buy for any serious would be programmer.



2. There does not seem to be a good book on VBA written, but this book is the best of a bad lot. If you have no programming or computer science background at all, then this book would be considered an intermediate text and you may wish to try one of the SAMS learning series books instead. However, if you have any background in programming, this book will help you acquire the nuances of using Visual Basic with Access.

   The book takes a very practical approach of walking the reader through the various elements of how a VBA application is structured and developed. The chapters are: Designing Applications, Events, Creating Code, Flow Control, Objects, Recordsets, External Data, Reports, Advanced Techniques, Error Handling, Class Modules, Optimization, Libraries, OLE, Internet interfaces and miscellaneous notes. Using a consistent sample application, the reader is walked through each step in the construction of a VBA application.

   I find that the use of single demo, which builds upon itself, to be much more effective that snippets of code and incomplete/unrelated examples. With little effort, many of the techniques in the sample code may be modified to fit your own needs.

   Overall, the book is a good text as well as reference for sample code. It is not organized as a reference text (use the online help instead). As a systems integration professional, I have purchased this book for more than one of my junior programmers in order to get them started.




3. It seemed they assumed more than the begginer knows. Their explanations on why the code works did not provide a clear enough explanation for me to understand what is going on and left gaps that I am still stuggling to fill. Also: it would have been nice to better explain how you decide what variables are required and how you decide the syntax of the commands. All in all, the books starts out ok but then leaves the beginner in the dust as it continues. I would recommend the Step by Step book over this one.



4. It seemed they assumed more than the beginner knows. Their explanations on why the code works did not provide a clear enough explanation for me to understand what is going on and left gaps that I am still stuggling to fill. Also: it would have been nice to better explain how you decide what variables are required and how you decide the syntax of the commands. All in all, the books starts out ok but then leaves the beginner in the dust as it continues. I would recommend the Step by Step book over this one.



5. This book is good, but it contains too much information. The book is overkill on Access VBA. More information than anyone can handle. The code examples can be too long. You can learn, but you have to stay awake and remain alert. If not you will fall asleep. I don't recommend it to beginners at all. For all beginners out there, stay clear of this book. If you don't you might end up hating Access VBA. I thought the book could have been written a lot shorter. I recommend this book to experienced users who want to read a few pages a day.