5 comments about Introduction to C++ for Financial Engineers: An Object-Oriented Approach (The Wiley Finance Series).

1. A reviewer below quotes the phrase "After completing the reading, you will earn a 'black belt' in C++ for financial engineering" like as it was a promise made by the author of the book. This phrase in fact belongs to one of the reviewers of this book and has nothing to do with the author's own opinion. In section 0.1 the author says "After having read this book, studied the code and done the exercises you will be in a position to appreciate how to use C++ for Quantitative Finance". So, the author's promise is far more modest than a 'black belt'.
   
   After almost having read the book I see it as an introduction into object-oriented C++ in which explanations are made through examples from quant finance. The book doesn't teach you anything but C++, so don't expect a derivation of the Black-Scholes formula or explanations of how Binomial methods work. It assumes that you know this stuff. I think this book is the best for someone who already knows a little bit about derivative pricing, but has a limited programming experience. It will give you a quick introduction into C++ and the ability to start reading more advanced literature on the subject.



2. This book is a great introduction to C++ for people working with or studying Quantitative Finance. I strongly recommend this book. The author is taking you from novice to a good level of understanding of C++ in a few hundred pages. I especially like the introduction to STL and the chapter on Design Patterns and how to apply them. In short a very good book.



3. Well, this book has listed out the essential elements for option pricing using C++. You are assumed to have a basic background of C++ programming up to OOP and simple STL. All materials covered in part I and II are well written for sharpening your knowledge in STL, inheritance, polymorphism and data structures which are useful for filling the gap between C++ language and application in computational finance. In part III, a core section of this book, it lists out the most popular techniques for pricing derivatives products such as tree method, Finite difference scheme and Monte Carlo method. This book is highly recommended for the first glance in computational finance. With the full source code in the attached CD, you can self-study easily. In addition, another Duffy's book - Financial Instrument Pricing Using C++ and Justin 's book - Modeling Derivatives in C++ are good references for intermediate level learning.



4. According to the author this text is supposed to serve as a self-contained introduction to C++ for beginners without any prior experience in C or C++. Unfortunately, the author's lack of didactic talent and even more so his negligence to introduce and explain key concepts like e.g. the "this" pointer (all the while making extensive use of it in his examples) would probably foil any attempt of using it in that way.
   
   Initially, I thought the text might still be useful for people hoping to refresh prior knowledge. That is until I happened to come across the code excerpt on page 107 that almost made me fall off my chair. There, the author instead of employing a simple do-while loop actually constructs a loop using goto! On top of that, he fails to initialize a member variable (tol) in the constructor that he merrily goes on to use later on. At the same time he introduces and increments count variable (n) that has no practical use at all.
   
   Another reviewer referred to the book as having the feel of a student's scratch pad. I have to disagree. This text is nothing but an utter embarrassment.



5. The motivation and objective of the book are quite appealing, teaching C++ to people who want to move to quant finance. However, the job is not well implemented. I read through most of the book and were quite surprised on the number of chapters and how few contents each chapter contains. Each chapter just gently touches the surface of the subject and it hardly covers much useful knowledge of C++ compared to C++ primer and effective C++ books. If one is new to C++, do not expect to learn much from the book. If one is quite familar to C++ but has not much experience on applying C++ to quant finance, the use of this book is quite limited. Although some example codes are printed in the book, there are really few further explanation on the design and syntax of the codes.
   
   Moreover, the book is way overpriced given its limited value. I still regret much spending 70 bucks on it.
   In conclusion, it has an attractive title but is not well designed and written.

5 comments about Windows Forms Programming in C# (Microsoft .NET Development Series).

1. Very good book! Windows Programmer must have.
   
   Easy to follow.



2. "...I had hoped it would be a convenient and quick reference to such questions as "how do I use FolderBrowserDialog and/or OpenFileDialog to open a file in my C# program?" but although these standard components are indexed in the book the discussion of them in the book is shorter than this review I am writing. What I would want is some kind of sample code, maybe a step-by-step description of how to add the components to my program..."
   
   There's no way I could have said it better. The book seems to want to cover "everything" but actually manages to say "nothing".
   
   The only part in which I would have to disagree with the previous reviewer is his rating. He gave it three stars. I think it deserves one.



3. I got this book after having already done quite a bit of WinForms programming and found it a compelling read. I'd have read after a platform/language primer but before doing any actual WinForms work, had I had it in my possession at that time.
   
   Its the first programming book in some time that I read as a 'page turner' - it's that well-written (in prose terms).
   
   It's also very well copy-edited, which shows that a lot of effort went into getting the book just right, which can't be said for all books (I guess the gap between release of .NET 1.0&1.1 and this book allowed for that more than in other books).
   
   As for the relevance of the information, I believe it to be very relevant to a wide variety of application types, regardless of that being the main criticism I see in other reviews here. I guess that comes from the fact that you can't please all the people all the time. Still, I'd venture it comes as close as any other book is going to come.
   
   For me it's very near the top of the must-have books if you're going to be writing non-trivial production WinForms apps.
   
   One thing to be aware of is that the .NET 2.0 version is on the way in the coming months, making it Essential unless you're not in a position to use 2.0 stuff.



4. 
   
   The second edition is out that covers Windows forms V2, you may want to buy it instead.



5. I'm a Java programmer who finished reading O'Reilly's "Programming C#" (very good book), and wanted to get started in Windows Forms programming. Chapters 1 and 2 were decent and Appendix B was an excellent introduction to Delegates and Events.
   
   The rest of the book, however, was very weak. All it did was give a brief summary of some of the windows forms components (and the coverage was very weak). If you want to learn about a component you are going to have to look it up it on MSDN.
   
   I was hoping the book would give me something other than what I can get by looking at an API. I was really hoping there would at least be a few chapters on how to design Windows Forms applications - there was nothing. The easy part is learning how to use a component. The difficult part is learning best practices about design an application - something this book didn't touch.
   
   Also, I'm not sure how the rest of the books in the "Microsoft .NET Development Series" are, but I think it's very cheap and dishonest to make a book 'appear' weighty. The book is 680 pages, but the margins, line spacing, and text are all very large. This book easily could have been half its size.

3 comments about Data Structures Using C++ (Programming).

1. It has been a pleasure using this textbook for my Data Structures course. Although most of the material can also be found in his other textbook Programming and Problem solving using C++, this is a great book to have as well. The material is well laidout, terrific examples and thorough explanations made this a great experience. The only issue I had is that I liked the color illustrations in his other book, this is published in blue and white. Most of the code examples compiled effortlessly. One example on linked lists gave me some headache. I also would have liked a little more expansion on the STL.



2. I used this book for my Data Structures course and while it is good it does not have a "meat on the bone". What I mean is that while it does introduce you to a concept, it does not have a lot of examples and expects you to have a good back ground in computer science already. I had to use other books to go furhter into explaining things, or the internet which has a vast array of information to help out where this book falls short. Probably will not even use it as a reference book as sometimes it shows you and sometimes it doesn't.



3. Event though this is our course book. We didn't completely rely on it since it was pretty complex for a beginner. We had to get other books to learn from which were much easier.

5 comments about Learning DCOM.

1. I'm a beginner in DCOM and all I needed to know about DCOM is clearly explained in the book, no function, no parameter,... unexplained. There are few books as good as this one. This is my fist O'Reilly and Thai book, but I'm sure that not the last.



2. This is a good book for C++ programmers wanting to learn com. This simplistic one language approach has made the book popular, since com is complicated enough without trying to briefly throw 3 programming languages at it. However, it will never be your only book on Com. Eventually you'll need to use your com objects from ASP or somewhere else (this is the purpose of com, binary reuse). This topic will also require a lot of study, and if your going to write com objects expect to spend a lot of time with this book open. I'm a programmer with 11 years experience. Com is one of the more complicated things I've encountered in my programming career. This book did have a few typo's (3 or 4 jumped out at me), however, they did not detract from the content. My first impression was that Don Box had the best book on Com I'd ever seen (I browsed it in Borders), but this book seemed equally as nice (and a few bucks cheaper).

   I would have liked to see another another practical example (never enough).

   Overall, an excellent book.




3. Would you trust the technical expertise of a programmer who writes this:

   if (g_hExitEvent == NULL) assert(false);

   This book is replete with this and other nuggets of technical prowess.

   The surrounding text is no better. Thai's English syntax is downright odd. His analogies are frequently tortured or nonsensical. All of this distracts the reader from the technical content.

   There is high praise for that content from my predecessor reviewers, but I thought his presentation was haphazard and unenlightening.

   I have found previous O'Reilly books quite good, but they did a very disappointing job on this one.




4. This book is a great source of information if you are interested in learning a complex topic such as DCOM. Be aware that this book requires you to have strong knowledge of C++, if you want to understand the examples. Although this is a great book, I'm still looking for other alternatives that will clarify the concepts of COM/DCOM in depth.



5. Micro$oft is famous for its ability to push out new development technologies. The reason behind this planned obsolesence is obvious, every time they come out with something new people will have to open their wallets to "keep up."

   DCOM is just another disposable technology. As such, it was a complete failure; one that the marketing folks at M$ have tried to bury as quickly as possible under an avalanche of .NET hype.

   DCOM was hard to port because, like COM, it is based on a binary standard (i.e. a standard that changes when you leave x86 and go to 64-bit RISC). Not only that, but DCOM doesn't support distributed transactions. Worst of all, DCOM is a very, very complicated technology to use. Three strikes... YOU'RE OUT!

   The half-wit MBAs at Micro$oft realized their mistake and have abandoned DCOM, leaving it forever in the backwaters where the only record of its sorry existence are stupid books like this.

   I have no idea why someone would want to buy this book. Folks, this is a dead technology. It is no more. It is an ex-techology. If you buy this book, you are lying to yourself. This book will sit an gather dust, unless you can find more productive uses for it...like burning it to stay warm.

   To be honest, I'm a little let down that a Unix-ish publishing company like O'Reilly would put out a book like this. They must really be hurting for cash. I heard that the bank has not been very nice to them during the recent market downturn...

2 comments about C++/CLI in Action (Manning).

1. Nishant did an excellent job with this book. The only complaint is that he could have made it bigger.
   
   He separates himself from the rest. The difference is his book covers:
   
   1. MFC/Managed C++ integration. Excellent chapter.
   He shows how to add any Managed class to either
   an MFC Dialog or MFC View. My favorite chapters are
   five and six.
   
   2. Templates/Generic mixing. Even covers managed template
   inheritance.
   
   3. Advanced event covering with C++. I have worked with C++/C#
   for years, and I didn't know this about events. Very good.
   
   
   
   4. Avalon integration. This is somewhat lacking, but it is still
   very good coverage.
   
   I would recommend this book to anybody.



2. The book is very well written. The author is intentional about bringing the reader along slowly enough to grasp all the important concepts along the way. Yet, there is no fluff or filler in this book. The book will take an experienced C++ programmer easily through every concept he/she needs to know in order to use the language in the .NET environment.
   
   Always empathetic to the target audience, the author reassures the reader when a new idea is first mentioned, that it will be fully explained at the proper time, if not in the current context.
   
   Chapter 1 introduces simple CLI concepts such as the /clr compiler option, CLR types, handles, gcnew, and boxing. Chapters 2 and 3 graduate to more advanced, but essential comcepts including delegates, finalizers, managed templates, and generics.
   
   Chapters 4 and 5 explain how to mix native code and managed code, in numerous, practical scenarios. It will address most every situation the reader is likely to encounter.
   
   Chapter 6 explains how to interop Windows Forms with MFC or vice versa. Chapter 7 deals with the Windows Presentation Foundation. And finally, chapter 8 covers migrating from DCOM to WCF, and hosting a WCF service in IIS.
   
   The author does not attempt to be funny or clever when he's not. However, he does write in a style that is interesting and keeps the reader engaged. He uses analogies effectively to help the reader connect concepts or to see them in a different light. I found Sivakumar to be one of the best technical authors out there.
   
   I would highly recommend this book to someone who needs to make the move to .NET programming from plain C++.

5 comments about C++ for Java Programmers.

1. I read a lot of computer books and was more hopeful that this book would be easier to handle than what reality dished out. After the third chapter, I was totally lost, then I realized that the most applicable use of this book is as a FINE REFERENCE rather than a cover-to-cover type of read. So, whenever a C++ compilation fails, at least I know that this book will likely be helpful, but really with the mindset that a pinpointed problem needs to be solved. The author clearly knows his stuff. If you're looking for a guided tour of the transition from Java to C++ with the hope that you could accomplish it in one sweep through a book, then look elsewhere, if even such a book exists. Judge for yourself, but perhaps this goal is unreasonable. WELL DONE, Mr. Weiss.



2. Although C++ is definitely on the decline, it will be a major force in the programming world for years to come. This book is an excellent intro to the language taught specifically for a person with some Java experience, and it does do an effective job of comparing and contrasting the two languages. The analogies, I feel are invaluable to understanding abstract concepts in C++, and the approach is better than starting from the ground up, if you understand Java at a fundamental level. I also have to disagree with the reviewer below: the writing is quite good, it's concise and not excessively technical. I suspect that that reviewer is unfamiliar with contemporary texts on computer science, because this is one of the more readable ones I know.
   
   Although the latter few chapters were not, I feel, exceptionally helpful, the book is a much better and lighter (not to mention cheaper) alternative to others out there, and is quite worth it, in every way.



3. I used this book in an introductory C++ class in college. Being a senior in Computer Science who has only been taught with Java, this book is a great starter to get into the world of C++. Nearly everything that is explained in the book is given an equivalent example in Java.
   
   Having never used C++ before, I can recommend this for those who are starting with C++, but have a strong Java background. I wouldn't recommend this as an introductory book for a beginner in the world of programming, as it delves into many advanced topics right away.



4. The book is logical and mostly clear. It has its weaknesses but for a Java programmer who wants to understand how the C++ sections of the project could possibly be taking so long and causing such problems, this probably the right book to start with (i.e. I haven't found a better one and am reasonably satisfied).



5. Very useful. It respects its contract: saving your time by progressively build on your Java background the core concepts necessary to understand the C++ language (instead of reading a 1000 pages reference book). Sometimes the comparison of design issues between JAVA and C++ (for instance about class immutability) suppose that the reader has already a solid knowledge about object oriented programming and/or design patterns, but not necessarily requires it (by the way, if you're a JAVA programmer and you didn't read Effective Java Programming Language Guide, you may have missed something). Along with a strong experience in C, this book allow you to become an intermediate C++ programmer in only few days !
   
   And remember: "[...] it is certainly not true that Java is better than C++, neither would we say that C++ is better than Java. Instead, a modern programmer should be able to use both languages, as each language has applications that can make it the logical choice". I deeply agree with the author's opinion.

5 comments about Data Structures Using C.

1. If you are interested in trees (Binary Search,Generic & Multiway ) & Graphs this book could be a very good reference. Common Data Structures are also dealt with very nicely.



2. ..this book is very easy to read... and there are very very exercices to help in the learning, also the topics of structures data is sufficent vast!

   good luck!




3. Excellent book, full of code and best of all, full with good examples; very important in this topic that is often cover merely as ADT. Stacks, queues, list, trees, everything is covered here. The chapter about trees is specially detailed, and topics like sorting and searching are covered in a separated chapter. I lost mine some time ago, and I did not hesitate to buy it again.



4. This book is a good introduction to the real world of computer programming and computer science---if you know C. However, time has moved on, and objects are now de rigeur. C++ is the new C, and a better choice for books would be one that teaches the same subject using C++ (or C#, or Java, or Python, or Ruby, or Perl, or...) Still, for some purposes, such as OS programming, device drivers, embedded application, and so on, C is still the standard, and for those applications, this book will suffice. I would add, it is a textbook that belongs in a classroom, with an instructor present to explain and give alternative examples to those found in the book. Independent-minded people might do better looking for a book written in the last five years.
   
   The book covers the basic data structres, such as linked lists, stacks, queues, hashing, trees, tries, and heaps, but it lacks some of the insights gained since it was written. Red-black tress, skip lists, speed trees, and other similar innovatons are not covered.
   
   Also, this book is not a good book for the study of algorithms. To do that subject justice, a book dedicated solely to the subject is needed. This book only gives those algorithms that are needed to use the data structures the book covers.
   
   In short, this is a good book to read if you already know the subject, but are rusty on it. Those learning it anew are advised to look elsewhere.



5. I found this book easy to read and the codes are explain in details. I recomend this book for those who are learning data structures.
   
   The only bad thing is that this book is a little outdated.

5 comments about A First Book of C++, From Here to There, Third Edition.

1. This book is perfect for the beginning programming student. It emphasizes a lot on programming structure which will be very useful in the later computer courses. Everything is simplified so it's easy to follow. I own many C++ books but this is probably one of the few that I can't let go of no matter how many times I've read it. It's also a good book to use a reference on certain functions because it explains the functions in full details.



2. C++ is the most difficult programming language to learn, yet Bronson does an excellent job in introducing topics painlessly. This book progresses in a very smooth fashion from topic to topic, and if the reader works all exercises at the end of each section, the concepts will be firmly grasped. Be careful, though, because this book does have quite a few typos, but they are easy to spot since the understanding of the material makes them obvious. The only drawback can be that not all the exercises have answers in the back of the book. Other than that, I would highly recommend this book to someone that wants to understand C++ and get a general knowledge of it, bearing in mind that this book will not make you an expert.



3. I would of never bought this book but it was for a class. Mainly focuses on C and then gets into C++. However my class never made it to the C++ portion where the author introduces OOP and classes. According to my professor, this is a two semester book. However, I learned quite a bit from this book and I already was familar with C and C++. I would recommend this book to anybody who wants to learn C and C++. However this book is not going to be very helpful for Visual C++ topics but still a good overall starting book on C/C++.



4. This book is very clear, well-organized, and easy to read. The author does an excellent job of explaining programming concepts instead of relying on diagrams to let us know what he's talking about. The sample code is easy to follow. Best of all, the exercises are carefully chosen so that they each represent a unique challenge. You will not get bored or lost in this book. My one complaint is that it doesn't say much about the String class or how to deal with string input (e.g. the common problem of the user entering more characters than you have room for).



5. After struggling with another C++ text I was lucky enough to come across this one. It's very easy to understand provided you didn't fail middle school English and have a decent knowledge of math.
   
   Bronson has saved "average Joes" like myself from pain in programming by making an easy-to-understand volume of C++. Even though it is unlikely I'll ever write another program in any language after taking two programing classes, I do have this laying around just in case.

5 comments about Practical Statecharts in C/C++: Quantum Programming for Embedded Systems with CDROM.

1. Since I saw quite a few excellent reviews on Amazon as well as on some other websites, I decided to purchase the book hoping it would give me some fresh new ideas in implementing FSM for real-time embedded system. I was quite disappointed when I received the book and had a chance to read it. Here are my own personal comments:
   
   - The text is too verbose and quite disorganized. Reading this I had the feeling of listening to someone rambling on and on.
   
   - The concept is unique and quite interesting. However, it is useless as far as embedded system implementation. Think of how you are going to debug this in a real-time environment. It would be a nightmare!
   
   - Lots of the detailed codings are encapsulated by the house-keeping codes. This is a definitely NO-NO for embedded system application if one must know every single line of executable code. (You have to know if you want to do size and speed optimization.)
   
   - It would be a nightmare to maintain an application written using this concept. It is just not consistent with the natural flow of thinking. Don't forget that the human element can never be detached from any application.
   
   - Debugging the state machine written using this concept is extremely difficult. (Believe me! I tried.) The concept of simply returning to the parent state if no special handling is required can be very very misleading during real-time debugging.
   
   Simply put, if you want to read some new interesting idea, this book is for you. But if you are looking for practical idea to apply to your SW development project, I suggest you look elsewhere. The 5-star rating is very very misleading. If you are still curious, you might want to check it out first at your local Barnes&Nobles or Border before buying.
   
   (In case anyone wonders about my background, I've been doing software development & architecture since 1988.)



2. Book is excellent in covering state machines and has many practical examples. It did not come short in covering different approaches used by real programmers to implement STMs. In second half of the book author is going into more advanced stuff and proposes what seems like an original new idea of Quantum Programming. Word "Quantum" in itself is very misleading in this context plus there is nothing new in tackling complexities of the real world dependencies in terms of State Machines. In fact author going further in creating entire new Object Oriented methodology with State Machine flavor. I doubt if most of practitioners will find more advanced chapters practically applicable, but it does not in any means reduces the values of the book as whole.



3. First prior to reading this book, I was finding the title unattractive. I did not know what statecharts were and what Quantum programming was. By reading this book, I have learn that statecharts were special finite state machines that could be built by deriving them from more general FSM similar to how OO classes inheritance works.
   
   Quantum is the name of the presented framework in the book. The title is misleading because I though that Quantum programming was some weird new programming technique that I was not aware and did not care to learn. I think that it is important to find catchy names to market software but one negative point of the book, is that the author spend way too much pages to describe similarities between quantum physics and his framework to justify the name 'Quantum' for his framework. Programmers are not all quantum physics enthusiasts!
   
   Concerning the book content, the author presents the C++ classes implementing the statecharts framework and a set of classes to make threads driven by statecharts collaborate together by communicating with message queues. It is an interesting reading and there are many places where you can learn good programming tricks by seeing the author code. However, I am not sure that I would want to use the framework because it is complex. Let me clarify what I mean. It is not the framework that is complex but implementing statecharts is complex. I believe that the author made his code as simple as possible to implement statecharts. Personally, I still have to work on a problem where a simple FSM will not be enough.
   
   The best feature of the book is its presentation of a base class to implement FSMs and compares it with traditional table based FSMs and a OO FSM like the one presented in the Design Pattern book and it is highly convincing that his FSM implementation is superior to the other 2 in size, performance and ease of maintenance. Another interesting topic is the author method to emulate C++ in C. You cannot beat the real thing with an emulation but when you have to go write C and you are used to do OO programming, this method might become handy.
   
   I would say that for the FSM pattern and the C++ in C methodology alone, even if it represents a small proportion of pages in the book, it justifies the purchase of this book.



4. Firstly: I am sorry about my English.
   I think that this book is really useful and very interesting for each interesting in C++/C. And want write programs with HSM behind as behavior rules of program.
   For conclusion: Useful and easy reading book.



5. I bought this book after reading some reviews which hinted that this book would be helpful for software developers of all systems and not just embedded ones. I have to admit I have almost no practical experience with C++, but I have substantial insights into OOD.
   I think this book is singularly targeted towards embedded developers, especially the ones who are into the crux of critical systems. I'm into regular OOD for PC/Web applications, and except for the first 2-3 chapters, I thought the book was impractical in today's age of environments such as .NET and high-performance hardware. This is a highly theoretical book which demands a massive change and learning curve for traditional developers.
   This, however, does not undermine State Machines. State Machines, if implemented right, can work wonders for regular apps. I found the Windows Workflow Foundation to be an excellent example of practical implementation of State Machines; it does have its limitations though and is meant for high-level processes. I am probably just going to stick to State Tables and such for a simplistic model with easy debugging capabilities.
   I found the UML 2 for Dummies much more practical.

3 comments about Schaum's Outline of Fundamentals of Computing with C++.

1. This is the C++ guide in the famous Schaum's outlines series. It teaches you the foundation's of C++ fairly well, as usual with a great load of examples and code snippets. We are used to this by Schaum.

   What I am missing is in-depth information. How do I use make to compile bigger programs? How do I use the STL? How do I use glib?

   This book will scratch the surface, and will probably be an ok guide for a novice. But if you want to take a step further after the first weeks of learning C++, you will have to look elsewhere.




2. I am a 12 year old male who just happens to be interested in learning C/C++. Someone showed this book to me and highly recommended it. I have found that the text is simple to understand even to a novice starting for the first time, and that it is completely stuffed with useful examples. I am going to buy this book -- you just wait!



3. If you don't already know the C programming language, this is probably a pretty good book on C++ programming basics. It goes into control structures, arrays, strings, pointers, recursion, and abstract data types, among other topics. It even has a good introductory chapter on the basics of computing that even includes information on the binary and hex number systems. In that sense, it is good enough to stand alone as a pretty good textbook. However, there is one major component missing from this outline that is essential for anyone who claims to know C++ in any meaningful way, that being any mention of object-oriented programming constructs as expressed in the C++ language. If you don't know object orientation as it is expressed in C++, then you are just a C programmer programming with C++ notation. Thus, this outline is not wrong, it is just woefully incomplete. I still give it three stars because for the right audience it is a good beginner's text at a very cheap price. For those who are interested in learning object orientation as it is expressed in the C++ language, I instead recommend "Schaum's Outline of Programming with C++". In that book there is less of an emphasis on algorithms and computing and more of an emphasis on teaching the complete language with all of its components.