5 comments about C Programming in 12 Easy Lessons.

1. Good book for beginners. Even if have never touched a programming language before this can get started. The author has some DOS specific commands in his programming. So it limits you in that respect. If you can figure out where to take out the DOS stuff you can use it on any platform.



2. C in 12 easy lessons is THE BEST book on C programming for THE BEGINNER! Last summer i took a 5 week college crash course on C programming. Welp...the teacher gave me an "F" (the teacher sucked but that a whole other program) Plus the book he used to to teach the class was soooo freakin confusing it was pathetic! You know the type of books I'm talking about! The kind where the author has to feed his ego by trying to get the reader confused with BIGLONGCOMPUTERWORDSLIKETHIS rather than just speaking in English. Anyway, I re-took the class (with a different teacher thank god!) and thanks to this book..i got an "A". This book is PEEEEERFECT for the beginner! When I took "C" the first time I bought 3 different books on trying to understand pointers and functions to no avail BUT...this book did it! This book will TEACH you "C". But more important than that...the way this book is written, you will REMEMBER how to program in "C". I'm taking Visual C++ in the fall and low and behold...Mr. Perry has a "Visual C++ in 12 Easy Lessons" book! What more could a "PC Progamming" Major ask for! Thanks Mr. Perry!



3. (My version came with a limited version of borland C++ 1.0 on floppy disk.) I guess this book worked for some beginners, but I found it extremely awful. When I picked up this book I had no programming experience what so ever (I never even used DOS). I wanted to learn C on my own though so I was determined to do it. I read each and every chapter about 3 or 4 times trying to learn all the concepts but it was really agonizing. One thing books like this should mention is a basic understanding of algebra being suggested, I'm sure that would have helped me. I will say however that once I did completed this book the C class I eventually took in college wasn't nearly as bad. At least it made me familiar with C and programming. If you've never done any programming what so ever buy something else is all I can say (I hear C for Dummies is good).



4. Don't let nobody tell you different! I'm a Systems Engineer, not a programmer. This is the greatest 'intro to C' programming book of all time.
   My version didn't have a CDROM it came with a floppy that I found to be fantastic. I've never depended on the FREE, GiveAway compiler that comes with any programming book. And I strongly recommend that nobody else should either.
   Using the free 'cripple-ware' that comes with most programming books is a virtual guarantee of getting some indeterminate number of headaches, the magnitude of which, can be predicted.

   NO THE AUTHOR DOESN'T DEAL HEAVILY WITH POINTERS, like some reviewers gripe about. But he covers them MUCH MORE THAN ADEQUATELY FOR AN "INTRO" BOOK. Detailed, in-depth coverage of pointers is simply, BEYOND THE SCOPE OF THIS BOOK's MISSION.

   What makes this book so fantastic is that it is built in a great fashion from simple to more complex tasks that are RELEVANT, and that build on all of the previous knowledge. BUT, WHAT IS ABSOLUTELY KILLER, and nobody else seems to do this; is that there are a lot of programs given in the book
   - AND RIGHT ON THE SAME PAGE, LINE-BY-LINE -
   the author explains what each and every line of code is doing AND WHY.
   Some of the other reviewers imply that this makes the book too simplistic; but for beginners, this is JUST AWESOME.

   NO - IT's NOT THE RIGHT BOOK FOR ACCOMPLISHED PROGRAMMERS, BUT WHY WOULD THEY THINK THAT IT WOULD BE???




5. This is one excellent book to learn C programming. I purchased this book around 1994, because when I went back to college, programming was done in C instead of Fortran. I had learned Fortran at Purdue about a decade earlier. I had to either take a class in C, or learn on my own. I chose this book to learn on my own.
   
   Greg's style was crisp and to the point. It was easy to read. BUT, more importantly, the book was chock full of assignments. This is great, because you don't really know that you've learned anything until you actually write code yourself. Also, the disk had answers to the questions. So you can test yourself.
   
   Greg emphasized code style, white space and readability along with the basic C syntax. Because of this book, I've purchase other books by this author because I thought this one was so well written. I also own his Visual Basic in 12, Easy Lesson, Turbo C++ in 12 Easy Lessons and his Java book. I've been pleased with most of my books I've purchased by this author. His Java book didn't keep the style of programming assignments and end of chapter questions as his other books, so I didn't like that one as well.
   
   ONE WARNING: Greg recommends different books to advance you knowledge. Most of the books he recommends were excellent for going on in C programming. He does at one point recommend a book titled "Assembly Language for Real Programmers Only" to learn assembly language. Though this book by Marcus Johnson is a great book, it's not a good entry level text. I did buy it. It's actually an advanced book that also double as a reference. So, you may want to get "Assembly Language Step by Step" to learn beginning assembly language programming.
   
   Other than that, I would highly recommend this book for beginners to learn C.

3 comments about Teach Yourself Borland C++5 in 21 Days (Sams Teach Yourself).

1. Arnush's book "Teach Yourself Borland C++ in 21 Days" provides many examples to get the novice programmer up and running with Borland's C++. In comparasion to other authors like Barkakati, and Gurewich and Gurewich, who have also written books on the Borland C++ product, Arnush gives examples at the programming level to master more of the C++ language as opposed to the Borland Development Environment. I am waiting to see if Arnush will put out a new book developing in the Borland Environment. I do like to see computer books with many examples, as was presented by Arnush, because it becomes clearer to see, when learning a language for the first time, how the pieces fit together. Also the 21 Day Series books give the reader goals to accomplish over that time period, which is an excellent teaching aid. I used Arnush's book for a graduate course and found it to be extremely helpful in getting through that course.



2. I am a self-taught programmer (of Pascal, C++, Perl, respectively), and I bought this book with the intention of being able to build some basic Window applications. (I figured that since one-third of a book covered windows programming, it would give me the basics.) I found it easy to mimic the programming, but I failed to really "learn" the OWL basics efficiently. (Maybe all I need is an OWL5 for Dummies book.)

   While everything before the windows programming seemed alright, the Windows/OWL programming chapters (totalling 7 chapters or so) lacked in its organization. The book uses examples that are easy to conceptualize, but it often fails to explain the how and why of the code in a clear, concise, and timely manner. I found myself thinking, "What does this parameter do? Why do I use this to do that?" Eventually, everything gets explained, but only because I got into the habit of reading a chapter several times more than I usually do, reading ahead of the chapter before programming anything out of the chapter I'm studying, and consulting the OWL Help in the BC5 IDE. (Without the IDE online help, this book would not have a prayer.)

   The book could use some illustrations explaining the relationship between various OWL classes, and which OWL classes handle what kinds of objects in windows. As I mentioned, everything is there, either in the help file or the text. My major complaint is that the organization within each chapter. My experience reading the book reminds me of running win95 on a 486sx25 with 4 megs of RAM. I eventually understood what I wanted to know, but the unanswered questions piled up and that kept me from learning efficiently. Although I eventually found answers, I don't feel that I have a solid understanding of OWL.

   In addition to patience, and devotion to reading the text over and over, an espresso might help to keep you awake. There are certain parts that feel like reading a monotonous reference manual instead of a tutorial book. You might also consider hiring somebody to restrain you from deleting your compiler because of error messages. The book has printing errors, but you can download the source off the URL in the book.

   Overall, the title is true in that it teaches C++. It explains the features of the compiler pretty well too. As for the OWL sections, the chapter order makes sense, but the organization within each chapter needs work. To say the most, I am qualified to plagiarize (cut and paste) windows code and have half a clue of what I'm doing. As for actually learning to program OWL, I think I'll ask IDG to make an OWL5 for Dummies after all.




3. Good for novice of C++ when he gets to business the Classes, constructors, and inherence. He is going directly into "deep constructors" not "shallow constructors" immediately if you know what I mean. Also using the debugger engine is not well explained which is the most important tool in C++.

2 comments about Remoting with C# and .NET: Remote Objects for Distributed Applications (Gearhead Press--In the Trenches).

1. I have worked with C# for some time now. I really wanted to learn about .NET Remoting and I did not have much idea about building distributed systems. This book gives you a step by step approach and it does require you to have some basic knowledge in any OOP language. Knowing some C# would be beneficial.

   Thanks to the author for publishing this book! Excellent!




2. Very well written. I recommend this book to others that need to work with remoting.

No comments about Value-Range Analysis of C Programs: Towards Proving the Absence of Buffer Overflow Vulnerabilities.

5 comments about C++ How to Program.

1. Sir(s), I am employed to Cable & Wireless Jamaica Limited. About four or more years ago I was sent to their inhouse training school to do a one week course in C programming, I was at a loss, I learned nothing. A couple of months ago, my wife decided to do a computer course (C programming followed my visual basic 6 then java) she is now at the visual stage. When she began, I took out my old manual (from C&WJ training school) and surprizingly I was able to help her in the early stages, but then the tables were turned and I got jealous. I read and read and read until I began to understand. I realized that the manual I had was chock full of information but it is hard to understand without someone to explain. Thank you for helping me to understand. "C HOW TO PROGRAM" the second edition is now a part of my library and I feel very strongly that I have made a worthwhile purchase. I am now doing the exercises at the end of chapter three but it's a pity I do not have "someone" at hand to ask questions when I need to, by the way, writing the pseudocode is giving me a bit of a challenge, so I just go straight into writing the C programs. Imagine that, I am teaching myself. Any advice? P. S. I love C. Devon



2. The book is really easy to understand. It is straight forward and to the point. Most of all technical terminology is defined for the beginner.

   I especially appreciate the fact that the authors have mentioned that they have tried to present C in such a way to be the first computer language for beginners, despite in traditional terms, Pascal being taught as the first programming language because of it's known structured programming discipline.

   In my lower years of education, I have had experiences with QBasic and a little of Visual Basic. However, as a student, I would think that skipping Pascal is a plus since I tend to ask myself, "When am I ever going to use it in life..." Students tend to question the applicable use of something that is learned.
   These days, Pascal is seldom used as C++ predominantly takes the stage.

   In sum, learning C as a foundation and first language seems to be something that will pay off. This book also includes tips and points out common pitfalls such as common programming errors, good programming practices, performance tips, and software engineering observations, which are all really helpful. If you are new to programming, this book is a must.




3. I am an aerospace engineer learning some computational methods in fluid dynamics and I started to learn C programming with this book. I was a complete beginner and with the use of this book I can really say to have a fair knowledge of C programming.



4. This is the best book to learn C, step by step, very well written, easy to follow. It covers all C basics. Highly recommended.



5. This book goes over the basic concepts of C programming, and is ideal for the novice C programmer who wants to establish competence in writing C programs. The material is probably similar to what would be taught in a first or second university-level course in C programming.
   
   Topics covered in this book include program control, arrays, pointers, file I/O, strings, data structures, and other concepts. To top that off, it devotes several chapters to introductory C++ programming.
   
   Presentation of the material is done quite well. The text is easy to read, and contains a good number of examples and diagrams that foster understanding of the concepts as well as the syntax.
   
   Overall, this book is a valuable resource for those learning or refreshing their skills in the C programming language.

No comments about Borland C++: The Complete Reference (Complete Reference Series).

5 comments about Visual C++ Windows Shell Programming.

1. I wish Wrox Press would learn to edit books. They choose appealing subjects, but the books themselves just don't cut it. This is nothing against the authors, it is the editor(s), if any, that are causing the problems.

   The book content is fairly good. Much of the info is taken from articles that appeared in MSJ, or from Nancy Klut's book on shell programming, but it does add some useful new information.

   Unfortunately, the source code (which is not included with the book, but is a free download) does not compile. I tried two of the projects (Shell hooks and Context menu) and neither would compile under a vanilla VC 6 installation. I know it is not my compiler, because the errors are in syntax. I suspect, despite the forward's statements otherwise, that the code was built with VC 5 and never recompiled under 6.

   In any event, you may want to buy this book if you don't have access to Nancy Klut's (or MSDN, where it is included) and don't want to dig through the back issues of MSJ.




2. I have found this book to be very usefull as a guide to shell programming. The information in msdn is a good reference, but there are often many ways to accomplish the same thing. This book presents the various ways to approach a task and also warns you of pitfalls including misleading documentation and implemenation bugs.

   Also, the source does compile in vc6 if you select the appropriate build setting (non unicode). The problem is related to unicode versions of macros being used in standard c functions such as fopen. Selecting the non-unicode build setting fixes this.




3. Recently I was tasked to develop a name space extension. Not knowing that much about the topic, I scoured the web for relevant information. Unfortunately this is an area that, in my opinion, is rather poorly documented. All I could find was a couple of articles written several years ago. Fortunately for me, I found Mr. Esposito's book, and found it very enlightening, and easy to read. It's the only book that I found that has a complete chapter dedicated to this rather niche topic. Obviously the book also spends a great deal of time covering the larger scope of shell programming. All in all, I would highly recommend this book for anyone interested in learning more about shell programming, and personally, I consider it mandatory reading for anyone who is planning on developing a name space extension. Selfishly, I only wish the entire book was dedicated to name space extension, oh well, I'll have to wait for that book...



4. I am a semi-advanced self taught C++ programmer. I use Borland's C++ Builder programming IDE. I found this book to be extremely valuable. It has provided me with more information on the pride and pitfalls of Windows 98/NT's shell implementation and API than I would've imagined. This is not a beginner's book. It won't hold your hand to get you through it's content. You will need a firm grasp of the Windows messaging system. Knowledge of and experience with the Win32 API is also important. While I am weak on COM technology (does it really provide things that can't be done in simpler ways, or are we just stuck with it?) I found that I could understand what was going on by (loosely) relating the COM objects and namespace extensions to C++ classes. This book does contain some typos and mistakes. You will have to know enough to spot them or else spend time on the author's erratta web page (haven't been there yet myself). This leads me to believe that the source code download isn't comprised of exactly the same code that's in the book. All in all, I truly wish I'd have found this book sooner. It could've saved me a great deal of time searching through many different resources for the answers to some of my recently overcome programming frustrations. I'm only halfway through the book and am already writing more robust applications. Who knew that my system tray based application would've been left (past tense) memory resident but unreachable whenever the Windows Shell was restarted! If you're serious about living with Windows...if you need to register an application or file type...if you want to use SHBrowseForFolder() better...if you can't figure out why the damned thing won't work and it's 3:00 am...BUY THIS BOOK.



5. The author, Dino Esposito, does excellent work in an instructional manner dealing with the customization of the Windows shell. There is an abundance of information located between the covers that will augment the comprehension the reader has about the Windows operating system as a whole. Many of the things that are in this book are available in other locations, such as MSDN and other articles available for free; however having a concentrated reference is very convenient.

   Chapter 1-2: These chapters include a basic introduction to the way the Windows shell functions, and the various portions of the shell. It also introduces the Windows Application Programming Interface (API).

   Chapter 3-6: Esposito explains how to work with files, including special folders, using the shell API functions SHFileOperation() and SHFileGetInfo(). Manipulating files, gathering information, and browsing for folders, it is all included. Certain Windows tasks such as working with shortcuts are explained programmatically.

   Chapter 7-8: Chapter 7 introduces the concept of `invading' the shell using hooks and COM objects: using shell events or events within other processes to trigger your own events. Chapter 8 explains how to spawn processes programmatically.

   Chapter 9-10: The first topic discussed deals with Windows icons, and then `invading' the Windows taskbar. This example can be used to take over any other process. Areas of the shell that are supposedly not very well known are covered; the recycling bin, formatting drives, etc.

   Chapter 11-13: The Windows shell, `explorer.exe' is investigated. The author describes to the reader how explorer works, both the default actions taken and how to invoke certain behavior using the command line. Benefits and differences between using rundll() and rundll32.exe are covered; complete with examples of how to use them. Esposito spends a lot of time on scripting, first offering examples of scriptable shell objects then covering how to use the Windows Scripting Host, (WSH).

   Chapter 14-16: Further levels of shell integration are presented as a conclusion to the book. Creating your own document types as well as many other features, like drag-and-drop support, give applications a native appearance in the shell. By creating new namespaces, the Windows operating system becomes even more customizable.

No comments about EXAMNotes for C Programming (EXAMNotes).

5 comments about Practical Algorithms for Programmers.

1. I bought this book 3 years ago. I learn a lot from it. I still use it. It's worth the money.



2. This book has the singular benefit of doing complete implementations of algorithms, not just code snippets nor pseudo-code. (The code is in C.)

   The book also covers lots of the algorithms other books forget: searching for multiple strings at once, searching for regular expressions, complete calendar routines, arbitrary-precision arithmetic, phonetic searches, most data-compression algorithms (including the one used by Microsoft in its product distribution), etc. Plus all the traditional sorts and data structures that appear in other books. As to data structures, it's one of the few books that implements an ISAM routine using your choice of red-black or B-trees.

   (By the way, although there is a coupon at the back of the book for a source code disk, the code is made available here for free download: http://www.pacificdataworks.com/bookdownload.html The authors update the codebase intermittently.)

   A good book, which has no direct counterpart.




3. "Practical Algorithms for Programmers" fails to deliver what is mentioned by authors as "The purpose of this book is providing a practical compendium of algorithms for use in applications" and "Most algorithm books today are either academic text books or rehash of the same tired set of algorithms". This book goes over that tired set of algorithms over again (B-Trees, bubble sort, shell sort etc) and is filled with long code listings with little comments and faux paus code practices (if column > 61).
   
   Almost all of the algorithms discussed in the book have already been very well described in various books of the same genre, notably "Introduction to Algorithms, Second Edition by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein" which has better explanation and examples. I see that "Practical Algorithms for Programmers" has good description of algorithmic efficiency, B-trees, AVL trees, phonetic comparisons, soundEx and metaphone along with excercises, but as an overall study for a CS grad and/or skilled developer, it's repetitive and meaningless. If authors' idea was to provide a cookbook for algorithm implementation, due to lack of component oriented thinking, this book lack this prospect as well. As mentioned, it's not a text book and therefore I don't see a reason of having about hundred pages of printed source code in the book? If the intended audience are software developers, why not highlight the important code segments and let the rest available via CD/FTP and use remaining pages for practical industry implementation discussions like the title suggests.
   
   As mentioned by other reviewers, this book might be a short & quick review or refresher course but I believe that it doesn't add any valuable reference to existing set of books available in this niche. Especially in the current development era when underlying software architectures and programming languages provides the built-in complex datatypes and memory management, algorithm world now belongs to exploration of binomial option pricing, naïve Bayes filtering and normal distribution approximation style studies.



4. We have this book in our lab and many times I've been able to refactor my own implementation after reading the code in this book. The chapter that deals with dates is very well presented and doubles as a history lesson since it covers all the adjustments that have been made to our calendar over the centuries. The source is writen in plain C so it should be easy to port to other languages.



5. There are numerous well written books on algorithms. Those by Sedgewick and Knuth come to mind, for example. But some students find these too hard. Binstock and Rex aimed their work at this need. This book has very little in the way of fancy maths. It emphasises examples with complete code listings. Not unlike "Numerical Recipes". Hence, you can also treat the text as a cookbook for your needs.
   
   The code is in C. If you are using another language, you can get some practise in seeing how well and accurately you understand the book's code.

5 comments about UML and C++: A Practical Guide to Object-Oriented Development (2nd Edition).

1. Clear description of modeling OO with a lot of tricks. Helpfull in moving from C to C++ world.



2. I was very disappointed with this book. At least through the 150+ pages I struggled through before giving up, UML was barely covered and utilized. What passed for an example was convoluted and confusing. Some bizarre quotes may convey the tone of this book: "This is consistent with our phenomenalist view: ... dialectical process ... we believe the real world of objects is a reflection of social relations ..." "If you take the Eastern, or Taoist, approach to OOA, ... the Taoist (practitioner) ... the focus is on the path rather than the destination" Explaining is-a: "Generalization has its roots in the knowledge-representation paradigm used in ai ... psychological model of associative memory ... representing a semantic knowledge network" "meronymic relationships" "homeomorphic" "anyone who has studied philosophy knows that reality is the state of mind of each individual"



3. I would give it 0 point if that's available. I think the authors are idots who are not clear about what they wanted to write. Don't buy it!



4. This book is outdated (both first and second editions). It certainly does not teach you UML, it does not teach you C++, nor does it teach you OOAD the right way. I also found numerous errors, even in C++, supposedly their area of expertise.

   They confuse between OO technique and developmental process. They keep referring to development process as OO. Typically, OO is combined with UP in software projects. This is not mentioned anywhere.

   They also fail to see the forest, instead keep focussing on the trees. For example, there is a top-down analysis approach, and another is a bottom-up analysis approach. You can also do it both ways and come to the middle. Not a mention about this in this book.

   They keep preaching about their beliefs. That is annoying. Instead of saying, bottom-up analysis gives rise to more reusable class structure, they go on and on about Taoist philosophy.

   Lot of outdated stuff also in there. Who cares for Structured English.

   On the whole, reading this book will not help, will confuse you, and could potentially get you started in the wrong direction as an OO programmer/analyst.

   There are numerous other excellent books on the market that focus on the OOAD and software development lifecycle. Don't bother buying this one.

   The title is also nonsense. There is very little UML in this book. There is very little C++ in this book. It does not show you how to effectiely use C++ when you are grappling with certain design decisions. No mention of design patterns and how they could be represented effectively in C++.

   Can't find much virtue in this book honestly. Waste of paper.




5. This is a difficult book to categorize and I was left puzzled as to where it would fit into a computer science education. The first eleven chapters deal with the basic ideas behind object-oriented programming and the way they are expressed in UML. While this is a good introduction to the abstract ideas of objects in computing, the book then takes a dramatic turn. Chapters 12 through 17 (a total of 96 pages) cover the C++ programming language, far too much paper and ink to even begin to explain this complex topic. Therefore, this section is either incomplete for beginners or not necessary for experienced C++ programmers. The remainder of the book is devoted to a complete description of the game of "Breakout", where a set of bricks is at the top of the screen and a ball bounces off them and destroys them. The development of the game is described, from the design descriptions in UML to the final C++ code for the project.
   The main problem is that not enough time is spent on C++ or UML for the reader to truly get a grip on either one. Very thick books are written on these topics, so the reader is left knowing only a little bit about both of them, but certainly not enough to be effective or efficient in using them.