5 comments about Beginning Visual Basic 6 Application Development (Programmer to Programmer).

1. The target audience for this book is someone with some VB/VBA/VBScript experience who is looking to expand into serious VB development, and has possihly been put off by more advanced and detail oriented books. The writing style is casual but not cute. Concepts are presented first from a big picture view followed by more detailed explanations and code. A single main project is woven through the book with numerous additional short examples for introduction of new topics. Examples are kept to just the point being explained and contain numerous screen shots. The introduction to COM is outstanding and of correct depth for the intended audience. Although there were 3 principal writers, the book speaks with one voice and one writing style. It is, I believe, an outstanding choice to follow completion of a book like Peter Wright's Beginning Visual Basic 6.

   Bruce Kirkpatrick MCDBA, MCSD, MCSE+I, MCT, i-Net+, Network+, A+




2. Before buying this book I was curious how the enterprise level VB developement has been done. Though I am a developer, I did not have enterprise level experience. I was searching for a book which gives a real world development. It's a great book !!. It jumps into the subject with real world example, Banking Application. This is the pattern required by the people who're waiting for a enterprise level experience. I can recommend it without haveing any doubt. Go ahead and buy it, you never regret it. my congratulations to all authors to this book.

   Thusith Kathaluwage AACS,MCSE,NCC




3. I'm a huge fan of the book that WROX has put out over the years (the 2 Beginning VB 6 books are phenominal). They've taught me virtually everything I know about programming. However, I must say that this book falls far short of my expectations for this publisher. It started out great; the examples of using RUP and UML were very helpful. I also learned a lot about MTS, XML, etc. that I did not know before. However, when it got to to actually writing the application, I had to take charge. Repetitive logic, misaligned object architechture, and not enough descriptions made me so frustrated that I only finished the book so I could rewrite the application more efficiently. Now, I'm a far cry from a professional programmer, so maybe I'm not seeing the whole picture. But, when I read a book to lean a new technology or method, I don't expect to be saying things like "Why did they do it this way?" or "It'd be much more clear if they did it this way." These, among other things, were said while reading every page in the sections dealing with writing the app. All in all it was very disappointing, but I won't hold it against these guys; they're still my favorite.



4. In my opinion, this is how every book that attempts to teach computer programming should be written. Most books on programming tend to teach bits and pieces that leave the reader hanging in mid-air. You learn the "alphabets" and the "parts of speech" of a programming language, but you are not taught how to put it all together into a beautiful prose, right?
   Not this book. "Beginning VB 6 AppDev" takes you, as it were, by the hands, and leads you through the tunnels, the caverns and other subtleties of application development. What you have at the end is a superb application, and a well enlightened reader. It is very rare to find a book this good: a single book that covers virtually everything needed to develop a fully, functional scalable application. Yes, it covers the whole development life cycle of a multitiered application.
   The authors did a very good job. I gave it five stars because it is worth five stars. If you are not convinved, get a copy, and study it.



5. The first third of the book deals with subjects covered in other WROX publications. The treatment here is cursory, but enough to be usefull. However, once the code is covered things get messy. Properties are all named with Get (not good practice) and several properties should be coded as methods, for which the authors seem to have little use. ADO should get more attention, but the authors just go ahead and hard code database connections. The same parameters are sometimes treated as variants, then strings or integers. The stored procedures for the T-SQL database were all named with an sp_ prefix (which is a no-no), and so on... On the whole it's a usefull book, once you clean up the authors' mess.

5 comments about Designing Highly Useable Software.

1. If you've read Alan Cooper's excellent "The Inmates are Running the
   Asylum", you're familiar with the format of "Designing Highly Useable
   Software": the main text talks about broad useability issues, while
   entertaining (or frightening) sidebars pillory the flaws in the design
   of everyday things. But whereas I sympathized with Cooper, I had
   trouble identifying with Jeff Cogswell. The sidebars, meant to be
   amusing, are mostly distracting: they are rarely relevant to the main
   topic being discussed on the same page. Worse, Cogswell goes much too
   far in complaining about the difficulty of living in the world around
   him; the reasonable reader won't recognize himself in these vignettes.
   Worse still, whenever this book steps away from abstract useability
   discussions and into coding specifics, technical errors appear that
   shake the reader's confidence.

   I had high hopes for this book. Perversely, I expect slimmer books to
   be better than fatter ones. At a relatively slim 300+ pages, I looked
   forward to a good read packed with useful advice. Instead, the book
   dragged on. The last five or six chapters (on such topics as dynamic
   libraries, OOP, management, and training -- all with a heavy emphasis
   on an outdated, waterfall-like development methodology) feel precisely
   like padding. The first half-dozen alone, with more specific
   useability advice and fewer suggested implementation details, might
   have formed the basis of a far better book. But as it stands, I can't
   recommend this book.




2. I finally finished reading this book, and I have to say, in time it will give the other usability books a run for their money. This book is written for programmers, and the goal of the book is to help us programmers step into the shoes of the users. The other reviewer couldn't relate to the stories, but I sure could. The author fills the book with funny stories about strange things he's encountered over the years that have frustrated him. These stories show what it's like to be a user. When you take this knowledge and apply it to programming, you start to understand how to build software for the user. Also, unlike other usability books, this one actually gets into some programming, with real-live code samples in C++! This guy really *is* a programmer. He even talks about design patterns, and methodologies like the Rational Unified Process. Get this book, read it, and start making great software.



3. If you're looking for a book on general software design, this book won't help you much. This book is about creating usable software, not software in general. It's very hard to pinpoint what makes something usable, but Jeff does an outstanding job. I liked the fact that he often augmented a technical lesson using stories that make learning the details fun. The manner of presentation is interesting because Jeff doesn't rely on just one technique to present the information. The details are often illustrated using several methods, so it's easier to understand precisely what Jeff means. Unlike many theory type books, this one has source code examples--something that every developer can relate to.
   
   The chapters that I liked best appear at the end of the book. They discuss topics that many developers really don't know about, but should. For example, Jeff takes time to point out a need for online help and tells you why training is important. Of course, someone could make an argument that developers do very little training, but if they don't understand what makes software easy to teach to users, the software will never become usable.
   
   No, this won't be the only software design book on your shelf, but you owe it to yourself to make this book part of your collection. This is the book that every developer should read after reading a general software design book. The world could certainly use more usable software and Jeff shows you how.



4. I definitely recommend the book to all programmers who want to make their software more useable to the end users, which hopefully is the goal of every programmer :). The tone of the book is casual yet informative making it very easy to read unlike the hoards of other books on the market. Best of all, the author is a real programmer, probably the reason why the content is very pertinent to situations encountered by programmers and the decisions that they have to make routinely. This book provides them the tangible points to consider while making those decisions as topics ranging from User Interface design to exception handling to libraries are discussed. The author uses various practical examples and humor to drive the point home. This book is a must read for any programmer!



5. This volume covers valuable topics in a readable manner. It should be useful to anyone who develops applications, interfaces, and documentation. 
   
   But how in the world can the author justify both "useable" and "usability" in the same book? Good style requires consistency in spelling. If "usability" is the noun, then "usable" is the adjective (see the Microsoft Computer Dictionary as well as many other dictionaries and technical style manuals).
   
   Something this sloppy should have been taken care of in editing, especially when one of the words is in the book title!! Doh...

No comments about Atari BASIC Programmes in Minutes.

No comments about Fundamentals of N-Tier Architecture.

1 comments about Atari BASIC X.L. (Self-teaching Guides).

1. I learned BASIC thanks to this great book, and I was only 8 years old! A great step-by-step book!

1 comments about Software Development for Engineers, C/C++, Pascal, Assembly, Visual Basic, HTML, Java Script, Java DOS, Windows NT, UNIX.

1. The book is already outdated. The inclusion of Pascal was questionable, even in 1997. Outside some universities, Pascal has suffered a continual erosion of mindshare.
   
   As for the choice of JavaScript as a scripting language, that still holds true today as a good choice. It is the dominant client-side scripting language for browsers, VBScript and JScript competitors notwithstanding.
   
   The unix discussion could easily be modified to include linux. Minor changes here.
   
   As for Microsoft DOS, it is a toss up whether this might still be discussed. Perhaps it might be replaced by an explanation of .NET?

No comments about The Tomes of Delphi : Basic 32-Bit.

No comments about Mascaras Y Montajes Con Photoshop/ Photoshop Masking & Compositing (Diseno Y Creatividad / Design and Creativity).

3 comments about MCAD/MCSD: Visual Basic .NET XML Web Services and Server Components Study Guide.

1. This is the third Sybex book I have purchased. The first two books I bought were for the 70-306 and 70-229 exams and they were both sufficient for those exams. Although I passed the 70-310 exam, I believe it is only because I first took the 70-306 exam which has a lot of overlap with the 70-310 exam. There were at least a half dozen questions out of 57 which were not even lightly covered in this book.

   That said, I would still recommend this book as an introduction for your preparation for the 30-310 exam. The chapter on security is very well written and is superior to the same section in the 70-305/70-306 book. You will just need to cover each topic a bit more thoroughly with other materials (perhaps reading Microsoft online documentation after each topic). This is good advice for any exam since you should have a goal of thoroughly understanding each topic as well as wanting to pass the exam.




2. Having recently passed exam 70-310 I believe this book does a satisfactory job of exposing us to the basic concepts required for the exam. Unfortunately, basic concepts are not enough for 70-310. During my month of preparation, I found I had to refer to both MSDN and "Microsoft .NET Distributed Applications" (ISBN 0735619336) for more elaborate explanations and working examples (some of the Sybex sample code did not work, and no errata appeared to be available on-line).
   
   Bottom line: if you plan to use this book to prepare for 70-310, then be prepared to supplement your studies with additional resources.



3. this product is awesome,but ull need extra help to get cert.
   you can get more help in this link
   (getcert's POST)
   
   http://www.mcse.ms/message2132798.html
   
   thanks

5 comments about DirectX 8 and Visual Basic Development (.Net).

1. This book is fantastic. It's only draw back is that it should have included a CD. I'm not going to fault the author for that, since most publishers don't include them any more. I did find the source code at Sams very well documented and full of good examples. I'm glad someone finally wrote a book on DirectX/VB programming. The title here at Amazon is wrong, but it does include some VB .NET example code.



2. Why is it that developers who copy and paste from MSDN think they're suddenly authors? I see pages after pages of tables with method names and short descriptions that don't contribute to anyone's understanding, but only to fill in the, what else, pages. For example, the 3 chapters on DShow spand 37 pages and they're full of enumerations of interfaces and their methods and oh, here's a bonus, two pages of instructions on how to create a Standard EXE project that references the ActiveMovie control type library.

   If you're looking for a meaningful guide to how DirectX works, this one will disappoint you, but if you're an actuary, it might be mildly familiar.




3. I agree with Paul asarak's comment. This book has a lot of pasted stuff from MSDN and from DX SDK help files, it has no cd, you need to download the examples from sams' website and there are some examples you need to type in the computer in order to test them.

   This book is as if you were ready a tale, tells how everything is supposed to work, but SURPRISE!: the color and gamma controls from DD are not supported by all video cards, but the book doesn't tell you that.

   It has a poor explanation in issues like the parameters that the calls to DX take in the example code. Since it has the same tables of methods and other stuff taken from MSDN, if the explanation of the MSDN didn't clear your doubts the tables in this book won't. I don't know about the others, but I feel a lack of explanation in DD.

   If you've already fought your way through the maze that the many DirectX parameters are, it's behavior and have learned the basis of it, you may feel a little dissapointed. Anyway you must take in account that sometmes you may want to have another source of information when trying to understand DX, besides the MSDN and the internet.




4. This is by far the worst purchase I have ever made. It goes to show that you shouldn't buy a book based on a table of contents alone. The author's code is weak at best. He explains 1/4 of the primitive code he writes and then throws in variables with no acknowledgement. In his discussion of directPlay he fails to mention the need to implement any interfaces. I've been teaching the database side of app developement for years, and if I can read a book and still be no better for it, it stinks.



5. Keith Sink, DirectX8 and Visual Basic Development (Sams, 2002)

   It's 2003, now, and the world is slowly migrating to Microsoft's .NET standard (well, those who aren't using Linux, anyway). Here's a prediction, built on past observation of the process: companies who have been developing apps in Visual Basic for years will get copies of VB.NET, expecting a no-brainer transition from one to the other. Their programmers will import the programs, and immediately die of massive aneurysms at seeing the number of errors (especially the number of seemingly unfixable errors, if you happen to be programming in DirectX or any other API where classes expose other modules, which is verboten in .NET's "managed code" environment). This will leave the companies stranded and unwilling to move to .NET. They will be stuck behind those companies whose programmers have read DirectX8 and Visual Basic Development.

   Keith Sink's book was written at the perfect time, and he often goes step by step through processes both writing code for VB6 and for VB.NET, making the book an invaluable resource for .NET VB programmers who are converting VB6 programs (or who are programming in an area where there are far more VB6 books than .NET books, which is, well, just about every area you can think of). Even if you're not planning on using DirectX, seeing the way things transition from one language to the other in one aspect of the language should give you a clue on how to make the transitions in other areas.

   Sink doesn't mention at any point that there's actually a Microsoft.DirectX library in .NET. But then, neither does Microsoft's documentation. Nor does its upgrade wizard. (I only found about it after asking a random question on a message board.) So it's hard to fault Sink for something that, at the time he was writing, may have not been in the framework, or may have been considered an unsolvable problem. That aside, Sink's book is, for the reasons mentioned above, the best I've read to date about Visual Basic .NET at all. For such a specialized book to be so generally useful puts it in a class by itself. ****