5 comments about Borland C++Builder 4 Unleashed.

1. I need to programing using VCL with Threads of WINDOWS API, like as... CreateThread(...,...,... ..) USING SERIAL PORT, like as... CreateFile(...,....,... ..) If is possible using PARALLEL PORT formerly in c++ 3.0 for DOS inport or outport. Why is more dificult to programing this in VCL or environment windows that DOS?. I think this things must be more easy for user.



2. I purchased this book four weeks ago and in chapter 2 I tried to run the code. It would not run. So I posted in the Borland Non-Technical news group and was told that there are problems with several items in this book, including chapter 2. Kent told me he was really busy and would get back to me. I also wrote Kent personally and after 4 weeks I re-sent the original email. Today I got an angry email back from him stating that he is working 80 hour weeks and he did not appreciate me asking if he was too busy to support his product. No answer to the original problem. Just an angry email.

   I also wrote several emails to the publisher asking about the problem code throughout the book and they continued to point me to their web site which ONLY has a chapter 24 zip file. I gave up with them. They must be too busy too to help a customer the right way.

   As far as the book goes... it's OK. Expect typos and code that won't work. The book is written well and his mood must have been a whole lot better than it was when he answered my email.




3. Many people need a place to start learning the VCL. I recommend they look elsewhere.

   The author did not intend to walk hand-in-hand with the VCL newbie, portraying the glories of the VCL as he advances in the book. For this type of book - i recommed the "in 21 days" series.

   The book focuses on giving you WORKING KNOWLEDGE in quite a few areas : Component creation, threads, templates, services and (much) more. The book does not dive deep into any of these subject, and the chapters hardly relate. When you have grasped how to use the VCL, you sometimes need a guide to the other, non basic, stuff CBuilder can offer. This is where this book shines. It gives you great insight on many intermediate - advanced subjects, and really gets you WORKING. It doesnt explain anything under the hood. You just say "hey, i need to write an NT service", open up chapter 5, and write one. The same for creating components, threads and what not.




4. This book goes into great detail in how to use Borland Builder 4. There is plenty of program code to use and study from. But it contains some errors in program code. Some of the step-by-instructions are missing or incorrect. The sections on Visual Components and Window Controls go into great detail about these are, but do not give any practical instructions/examples about how to use them in a program.

   If you need a good introduction on how to use the various Visual Components and Window Controls, I would recommend getting your hand on Borland C++ Builder 3 for Dummies by Jason Vokes. It give simple instructions/examples on how to forms, form properties, labels, editboxes, listboxes, comboboxes, drawing pen/brush, and etc.




5. If not the difference between Object Pascal and C++, this book is the same as "Delphi4 Unleashed", a must for Delphi programmers. So, this book seems at most a translation version of Delphi4 Unleashed, by just translating the sample code from OP to C++. If you've already owned the Delphi one, don't buy this one! Anyway, the content is peerless as it's nearlly the same as that of exellent book "Delphi4 Unleashed".

5 comments about Charlie Calvert's Borland C++Builder Unleashed.

1. I expected more from this books after going through its contents. The database sections is invaluable for DB beginners, but the basics as far as ANSISTRING, STRINGLISTS, and/or integrating C++ Builder, C++, and real-world solutions to application development never rears its head. This book is not consistent and is choppy in its presentation. Overall, it is good for the advanced Visual C++ programmer as an intro to C++ builder.



2. Charlie covered a lot of interesting topics. However, there are too much preaching about his programming philosophy and not enough explanation on each topic. Many of the examples contradict his programming style.



3. This book covered a great deal on database programming, but very little on anything else. This was a dissapointment for me, since the title of the book was "C++ Builder Unleashed" and not "C++ Builder Database Programming Unleashed".

   It was also a nice reference on Creating Components and bypassing VCL Events and dealing directly with the Win32 API, although it didn't quite cover well on why you would want to do so.

   I bought this book because I was interested in some of the intermediate and advanced concepts that were not covered in Teach Yourself Borland C++ in 21 Days. I came back dissapointed, not any better off than when I started.




4. Just a word about a review that I read here. Database programming is *VERY* important nowadays. Almost any real world program use databases. So this topics had to be covered in such a book (Unleashed). This book is very well written. It's not only a tutorial but Charlie is a passionated defender of C++ Builder. Maybe the source code listings are a bit boring but all in all this the best books to learn C++ Builder.



5. I am a computer professional who was being left behind by all the new technology that I was not getting a chance to work with. I needed to upgrade my skills. My company happened to have a Developer version of C++ builder 4 sitting around (I am primarily a C/C++ programmer) and decided to go for this for no other reason as I could get it for nothing! I was also writing some VB code at the time

   I surfed the Net for some good doco on the language and I found this book (the full text in the form of a free eBook).

   OH JOY!

   I love this book. It certainly doesn't tell you everything. But with the richness of a language like C++, the merging of the Object pascal visual components library (VCL) and all the other stuff you need to know these days how can any ONE book possibly do that.

   What it does do however is to concentrate on the new aspects of Borland's C++ language which are introduced with C++ Builder (namely the VCL and the associated components). Just what you need if you are already familiar with the older libraries and do not want yet another book that describes libraries that are in every other reference book. Ad infinitum!

   I have thumbed through several C++ Builder books in bookstores that simply regurgitate the same old material. One in particular had just a few pages on the VCL. A waste of my hard earned money!

   What does this book have that the others don't?: Well besides detailed overview's, explanation's, information, examples and some great trivia (some don't like this 'property' of the author, but personally I find it refreshing ... and often enlightening). HE CONCENTRATES ON THE "VCL". Yay team!

   Look to put it bluntly! The man - Charlie - and the language is my dupli-hero! (I have to roll them up into a big ball of enlightenment which is greater than the sum of its parts). With their help I was able to build a plethora (...What is a plethora Jose?...) of useful utilities at work, that actually improved our efficiency and allowed me to go home at a reasonable hour.

   I am so grateful for a really useful text that I have decided to purchase a real copy of this book (as opposed to the free ebook that I was using as a reference) as homage to the man. This book is my Bible!

   Note 1: His subsequent work covering C++ Builder 3 Unleashed is also a rip snorter (that's Aussie for 'excellent'). Again, this does NOT retrace all the stuff from his previous book, but takes us even deeper.

   Note 2: To all you VB programmer's out there ... C++ builder is Visual basic with GRUNT. No. Sorry. I mean MEGA GRUNT!

   Gotta go now. See what's in his "C++ Builder 4 Unleashed"!

   Thanks Charlie. Hope to thank you personally soon!

5 comments about Practical .Net2 and C#2: Harness the Platform, the Language, the Framework.

1. I've been programming in C# for about two years now (and in C++ for about six years before that) and I learned a lot from this book. It contains much of what I've always wanted to really understand (CLR internals, non trivial C# tips...). It is difficult to put down and it will serve as an indispensable reference once you're done. Examples are helpful and I find myself consulting them several times a day at http://www.practicaldot.net/en2/SiteMap.htm. This goes onto my short list of "must have" .NET books for any serious programmer.



2. I am a MCAD developer, programming in C# for 3 years and yet found this book to be very useful. It has tons of useful code to study. I would highly recommend getting a copy for your own library.



3. The book covers a wide range of topics and gives an in-depth introduction to almost all aspects of .NET programming. And I was really impressed with the C# part. It was easy to understand, enjoyable to read and complete!



4. This book uses English words but it is written in some other language.



5. If you develop C# 2 applications this is one of the books to buy for your desk top library. In-depth on things such as asynchronous sockets, stream class the lot. If I can understand the content you will be able to.
   
   Worth every penny/cent.

5 comments about Professional Software Development with Visual C++ 6.0 & MFC (With CD-ROM) (Programming Series).

1. If you are new to MFC and Visual C++, this book will help you. When you want to start learning why some things are done a certain way, you are out of luck.

   This book will walk you through the basics of using the MFC in Visual C++. You will learn the steps you take in VC to do basic component manipulation in MFC but only on the surface. The examples are not really that good. Sure they convey the principle but that's about it. I found myself with more questions to ask and no answers to be found.

   If you have never done any MFC programming before, this is a good place to start. Otherwise, my advise is to keep looking.

   -=} Randall {=-




2. This is a terribly organized book.

   1. There are lots of errors and inconsistency, which cause lots of confusion. I've only reached chapter 5 and already noticed these errors:
   1) Page 57: the book shows you how to create a "CDataDlg" class, however, on Page 60, inside the code: "CDlgData dlg(this)" - the class name becomes "CDlgData" and this error repeats on Page 61 too;
   2) Page 68: "1. From ClassView, select CDlgData" - well, the figure actually shows "CDlgNew", not "CDlgData" and this discrepancy repeats several times in the chapter;
   3) Page 69, in the code "m_csLastname = "Jones";
   m_edtLastnaem.SetWindowText("Jones");" - the first line is totally unnecessary, besides, variable m_csLastname is not declared so if you follow his code closely, the program won't work.

   2. Looks like the author isn't very sure what type of readers he is addressing:

   Page 57: "6. At the end of this line press [Enter]...The cursor will be placed immediately below this line..."

   Looks like he thinks his readers are bunch of [people] knowing nothing about how to use a text editor, not to mention C++ and we need to follow strictly his explanation. Well, if we really follow his book so closely, we will definitely be frustrated by these errors mentioned above.




3. First things first, if you are a beginner my advise is to read books for beginners then move on to MFC books for the advanced. I noticed in a lot of reviews people seem to think that one book is all they need and expect one book to do it, but the sad thing is they end up using the book as a paper weight or they stop study the language because they got the wrong book, or they get confused. If you study and learn any language in the right order with the right books its hard not to enjoy! Read C++ in 21 days, second edition, by Jesse Liberty. Get through Jesse's book on the C++ language first then move on to learning Microsoft Foundation Classes (MFC). Then read C++ 6.0 in 21 days by Davis Chapman to get some of the MFC learning. Then read everything on advanced Visual C++ 6.0 to enhance you MFC understanding. Now you will have to add all these books to your library reference because it seems one book on C++ 6.0 will not tell you everything you need to know because when you start your own programming you're always do something different than what these books seem to cover and guess what? That's right, you will have to figure this out yourself by referencing more than just one book. Example: I needed more info on property sheets and finally found it in MFC Advanced, which is now discontinued for now on Amazon. This book Visual C++ 6.0 & MFC has some good info in it but it's short on detail but I will have to say it's a good book to help build your library on this subject. I had a problem with property sheets and this book did not cover enough to help me with my problem. It uses a control button you click on a menu to pull up a tabbed property sheet and I wanted to convert my main dialog class to a property sheet class to build my application instead of having the property sheet added to my application in a menu control. But I learned from its CTime class on how to display clock time in a better format. Did find some errors but that seems to happen in most book anyway. So, I give this book 3 stars because it doesn't cover enough in-depth information to be a professional software development book.



4. I think that this is a grate book for beginers. It gives you examples of almost everything you need.



5. This is a very poorly written book. If you follow the instructions, none of your programs will work. If I could give it a ZERO stars I would. I wasted my money on this book.

5 comments about Fundamentals of Data Structures in C++.

1. This book cuts to the essentials without digressing, unlike many other data structure books. The code requires a bit of studying and is not very clear, but once you get through the codes, it pays off. A learner who prefers having everything explained word by word might find this book too consise and without enough explanations. For other people, this is a great book.



2. This book gets way too caught up in mathematical terminology and offers too few actual code examples. Most of the code examples consist of showing the format of the class they want you to write with comments telling you what the code would do if they actually had any in there. Granted the authors are dealing with concepts in the book, but I always find it easier to grasp a concept with full working examples to tear apart.

   Aside from that, the book is extremely dry and difficult to read because the text is so boring. It's worse than reading a text on mathematics.

   Speaking of mathematics, this book will totally swamp anyone who doesn't have a strong algebra background. The authors assume that the reader uses fairly complex algebraic equations regularly. I'm pretty good with algebra, but a little out of practice since I've been concentrating on my job and learning C++. I find myself spending almost as much time figuring out what their equations mean as I do learning the concepts they're trying to describe.

   I would not recommend this book to anyone.




3. An excellent book for a student who has a fundamental knowledge of programming in C/C++ and Mathematics as well. The font of printing needs to be enlarged a little bit.



4. This book has an amazing amount of content. Very few data structures books contain quite as many structures as this one; In addition to containing all the common data structures one usually studies, people can also study Splay Trees, Compressed Tries, Patricia, Fibonacci Heaps...really the list keeps going. The only things that it seems to be missing are skip lists and multidimensional range trees...

   Most data structures have rigorous (college-level-worthy) proofs for complexity and performance. These proofs are typically required of a student in a graduate level course, and thus, this book could be used for a graduate-level text. Because of this however, some may find this book a little daunting, especially if you just need an introduction to the topic.

   The C++ code samples use templates so that the data structures can be generalized and used for any type. Therefore, the C++ code is very reusable. However, the code can sometimes be a bit hard to understand, mostly due to short variable names, and poor in-code comments. This is one of the reasons I didn't give this book 5 stars. Overall though, this book stands out in the crowd.




5. This book is divided in 10 chapters for a total of about 600 pages.
   Part about fundamentals give some description of complexity analisys and performance monitoring. Some sorting algorithms and some basic search algorithms are presented here. This section is not so exhaustive, still useful. It contains descriptions on how to abstract data types.
   Part about array and structures explains how aggregate data types can be used to build more complex data types and teach how to manipulate them.
   This section is not very useful and it is not projected in a "production environment". Things are explained in a too semplicistic way and don't fit real world data structure construction. This is the sensation you will have all over the book. Data structures explained in this book works only with integers number. In a real world you will not build data structures to store integers only. This approach simplify greatly source code and comprehension on how a particular data structure WORKS, but will not give you a good vision on how a real data structure should be PROGRAMMED. So this book remains more academic than practical. For theoretical explanations about data structures there are more exhaustive books around, like "Introduction to Algorithms" by Cormen, Leiserson and Rivest.
   The material presented in this book is complete and updated and surely this is a great reference.Explanations are well given.
   So consider five star if you buy this book for understanding how data structures work, only three star if you need this book to have some implementations to look at. Not bad but implementations could have been written in a more robust way.

5 comments about Essential .NET, Volume I: The Common Language Runtime (Microsoft .NET Development Series).

1. In my POV this is a masterpiece!

   I read both (Don Box's book and Stutz's Book)!

   Stutz's book has an "inside-out POV" to expose the CLR features,
   Don Box's book has an "outside-in POV" to expose the CLR features.

   These two books are really cool... Any review less than 3 stars must be ignored!




2. There are like a zillion CLR books out there and overall, it's not the type of subject that normally keeps you glued to it. When I got Jeffrey Richther's Microsoft .NET Framework book, I was convinced no one was going to outdo him. Well, it's a close call, but I think they are both Superb books by excellent authors. I've purchased Don's stuff before and really liked it. This book lived up to its expectations.

   I think his ability to communicate some of the more obscure areas of the CLR in a very clear matter is what makes this book shine. This book can be understood by anyone because of the writer's gift for writing...but that's not to say it's a novice's book. Wherever you are in the .NET learning curve, there's something for you in this book.

   If you really want to learn the CLR, this is a great place to start.




3. This is not the book to dive into first if you want to really get .NET. It's actually a fairly interesting mixture of what I now consider obvious and what I never stopped to consider. If you are just starting out, I would begin with Richter's book, and then digest this one quickly afterwards. There is a significant amount of overlap, but your final understanding will be very balanced.



4. only for advanced readers. If you are a beginner, you may get lost. I had to read a couple of times to get 100%. Excellent. Some concepts are pretty difficult to understand.



5. If you havn't read this book, Buy it! I really enjoyed the style, flow, and great insight into the CLR.

5 comments about A Simplified Approach to Image Processing: Classical and Modern Techniques in C (HP Professional Series).

1. A well done tutorial on how to approach complex image processing problems with ease. The book comes with useful documentation and example code that brings difficult theories within reach of amateur programmers or the curious.Rounds out any programming library



2. A great book for intro to image processing. Example codes are very well written, with an emphasis on clarity (as opposed to using compact C operators which make it difficult for others to understand).

   A great job overall. I recommend it highly.




3. Overall the author explains image processing concepts well. I have owned the book for several years and now have a need for it. It is very helpful in determining which components of an image processing suite are needed for an application. The C code appears to be well written. Unfortunately, there are errors in the text and the author's email address does not work as of 7/26/00.



4. The title of this book is more self-effacing than it needs to be. This is quite a good book on basic image processing programming. The most attractive feature of its code is that the author has created C functions that do not require an elaborate and idiosyncratic interface to use (unlike, say, _Computer Vision and Image Processing: a practical approach using CVIPtools_ by Scott Umbaugh). This code can be easily included in your already-existing IP library code.

   The choice of topics is mostly middle-of-the-road. It covers the various point processes (arithmetic, bitwise logical operations, histogram-based transforms, etc), areal operations (convolution kernels and selection kernels), image resizing, 2-image operations, and compression (this last the weakest of the coverage, but still quite acceptable for a general book) in a very clear and competent manner. In this regard, the best surprise is no surprise.

   But even in these plain-vanilla topics, Mr. Crane manages to provide some nice touches. For example, his is the only book of its sort that I know of to provide the formulas for generating Gaussian and Laplacian of Gaussian convolution kernels of arbitrary size and roll-offs.

   Most satisfyingly, this book includes coverage of some topics that are truly useful but typically not covered in basic IP programming texts. These include various approaches to digital half-toning and some wonderful explorations of image warping and morphing.

   All in all, this book is a small treasure. If you program for a living and image processing is part of your domain, the book is well worth having on your shelf. If you program for a hobby and are interested in learning how to work with digital images, this may end up being the only such book you feel the need to buy.




5. The book is quite simple but that's what makes it understandable, it was quite helpful to me. Unfortunately the source code could not be read completely from the floppy and the authors email is not valid (I would appreciate some help with that).

5 comments about Sams Teach Yourself Qt Programming in 24 Hours (Sams Teach Yourself).

1. If you are new to GUI programming in general or Qt programming in particular, this book will get you off the ground and running towards writing your own Qt applications. It is clearly written with many simple examples that illustrate how to use the basic Qt tools. The book also has exercises at the end of each chapter as well as several "hooks" to get you to check the official online Qt docs. I would have given the book full marks if the author hadn't wasted chapters on specific tasks such as programming for KDE, using OpenGL, or programming Netscape plugins. If you are interested in these tasks, it's a 5-star book, but I would have preferred a couple of advanced chapters covering Qt's built-in threading classes or other less task-specific topics.

   Note that this book is basically a "stepping stone" to get you going from scratch. After you've finished this book, you will likely not refer to it as much as the official Qt documentation that trolltech provides with most Qt packages. I recommend that beginners start with this book, and then move on to try the tutorial "cannon" program that comes with the official docs.




2. I would've given it five stars, but I didn't like how it tried to fill up the 24 hours with how to use the widgets. Qt is pretty consistent (like any good library should be), and most of the methods work similarly enough that it's easy to figure out (like how to set the size). I would have like to have seen either more advanced topics or more indepth coverage of the advanced topics.



3. Don't waste your money. This book would be helpful in getting you started using Qt, but the examples and coverage are no better or more complete than the tutorial included with the qt package. This book introduces basic Qt tools, but doesn't give any suggestions for how to use them in actual applications. Even the simple example applications at the trolltech website are more practical than the examples in this book.



4. This is a good book for the last version of Qt but not great for the current one (as of 8/27/2002). It also has significant proofreading errors in it, implying that it was written in more or less the same amount of time that you're supposed to read it. However, it is an easy-to-read introduction to Qt programming and is nice for beginners (I recall a quote saying "of course, if you're a professional programmer you wouldn't have gotten this book" -- and I *am* a professional programmer). The O'Reilly book is a better choice if you already know programming; and if you don't know programming you probably shouldn't be starting with Qt. :)



5. This book as mentioned before has many of grammar errors. If you?re from a country other than the USA and cannot speak proper English, this is your Qt book. It is a wonderful book for beginners to get started with. The intermediate and beyond will find this book to be boring, or they will learn one thing from it. It is the only 24-hour book I own.

No comments about Games on Symbian OS: A Handbook for Mobile Development (Symbian Press).

2 comments about You Can Program in C++: A Programmer's Introduction.

1. Francis Glasborow is one of the most frequent problem solvers on comp.lang.c++.moderated. And he has done a wonderful job authoring the book.
   
   I can recommend this book to anybody who knows basic programming (in any language) and wants to learn C++. In addition to the coverage of C++ basics that you find in many other C++ primers, you will find invaluable caveats and tricks.
   
   There are a few typos in the example programs in the later chapters. In spite of those, I still rate the book 5 stars as I could learn more C++ from this book than most others. After going thru 388 pages of this book, I find myself capable of taking on advanced C++ books -- like Modern C++ Design.



2. This C++ text is considerably less verbose than most, as it makes some significant assumptions about the reader's prior programming knowledge.
   
   These knowledge assumptions are the book's primary weakness for beginners. Early on the book presents concepts that many readers, even those with prior, but non-C++, programming experience, will not have previously encountered. For example, the author presents the term side-effect without explanation. As early as page 31 basic exception handling is presented in a small program. Iterators are first mentioned without an adequate discussion of what iterators are. Other items from the STL are also presented with explanations so limited that most novice C++ reader's will find the presentations very difficult, if not impossible, to follow.
   
   The author spends too little time providing details for a reader completely new to C++ or object-oriented methods to properly understand many of the new concepts presented, and too little time presenting well-coded exemplars. In chapter 3, e.g., the author states, "I deliberately leave some of these problems in my code because I want you to check code rather than taking my word for it." For beginners, this approach seems fraught with problems. I would have preferred to see programs correctly coded in the presentation sections, with code demonstrating poor practices, explicitly identifying what those poor practices are and providing examples correcting those weaknesses. Otherwise, code with potential problems should be left to the exercises. What reader's need are appropriate examples of good coding practices that they can emulate, not poorly written code examples. Snippets of code can be an excellent approach to presenting key concepts, but fully coded examples should demonstrate appropriate coding practices.
   
   Concepts are "fleshed-out" in later chapters, but "newbies" may find this book does not provide the solid understanding of the basics that they seek.
   
   Additionally, the improved and updated software does not always respond in the same way the earlier software versions used by the author did. For example, in the author's first floating point program, he deliberately leaves off an #include statement and comments that the user will see the compiler complain about this. However, my version of the updated C++ compiler, which is a later release of the one used by the author in preparing the text, accepts this situation without a problem and successfully compiles and runs the program.
   
   Many, in my opinion, unnecessary sections of the book relate to the author's inclusion of a graphic software package he developed called Playpen. This package provides extremely limited capabilities, and simply takes too much time and effort to learn. The package has essentially no value beyond the course. The author would have been better served to provide basic explanations of how to use the built-in graphics capabilities of the major OS systems currently in use. Perhaps he could have selected one, e.g., Microsoft's OS, and as he did for the IDEs mentioned earlier provided additional information on other OSs, e.g., Apple's, presented on the CD. This would have been far more helpful to readers, and have had real value beyond the course. I hope this approach will be followed for latter editions of this work, thus allowing the Playpen package to be removed. This package's limited educational value takes time away from important topics that could otherwise have been covered.
   
   However, in spite of, or because of, the author's conclusion about his readers knowledge level, many readers with some, even limited, background in C++ will appreciate this book's "get to the point quickly" approach. The author is also excellent in presenting appropriate C++ idioms, and showing where idioms carried over from other programming languages, even C, are inappropriate for C++. The author also takes time to explain why they are inappropriate.
   
   In summary, although the book indicates that it is appropriate for those with knowledge of another programming language, I don't concur. However, for those with prior C++ experience or knowledge gained from prior self-study of C++ basics, this is quite a nice book. It gets the reader programming from the start, and provides lots of short, complete, and easily understood programs illustrating key C++ concepts. It provides clear and appropriate short programming exercises throughout. It successfully brings many important advanced features of C++'s together in an authoritative manner.
   
   Thus, although it is not recommended as a first C++ book, it is definitely recommended as a good choice for those with some prior C++ knowledge or experience.