Customer Reviews

C++ Design Patterns and Derivatives Pricing (Mathematics, Finance and Risk)

5 star:		(10)
4 star:		(2)
3 star:		(0)
2 star:		(2)
1 star:		(1)

 

 

Joshi does not intend to teach financial mathematics in this text. To learn about this topic, you can read his other book "The Concepts and Practice of Mathematical Finance". Joshi also doesn't try to provide an introduction to C++ programming -- there are plenty of good books on this topic.

Instead, the author does an excellent job of demonstrating how common C++ design patterns (templates, wrappers, decorators, bridges, factories, and so on) can be applied to price financial derivative instruments.

The book develops reusable components that are subsequently combined in a simple Monte Carlo framework, capable of pricing certain path-dependent European options. Another section uses Binomial Trees to tackle the early exercise challenges presented by American options.

The aim of the book is to allow the reader to develop an intuition for using the design tools rather than to provide an exhaustive framework. As a consequence, more complex instruments -- including any credit or interest rate dependent products -- are not covered. Finite difference methods are also not presented. But the design tools described are equally applicable to these areas.

Bottom line: "C++ Design Patterns and Derivatives Pricing" is a good addition to your quant library.

In principle, it seems that this book is a very specialized one: design patterns in derivatives pricing. However, Mark Joshi has been able to give ideas that are generalizable to many other fields. For example, I have developed a trading simulator in c++ using several of the ideas of the book. The ideas in the book are so general, that very often one can do simply a copy and paste and just change the names of the classes and variables.

The only complaint to the writer is that he does not supply the answers to the questions of the book. This is standard practice in academia (and there is a good reason for it), but this book is designed mainly for practitioners, that probably do not have too much time to solve difficult questions.

The writer is widely known in forums like nuclearphynance and wilmott for his deep comments about derivatives pricing.

Disclosure: I only know Mark Joshi because I have sent him an email with some questions about the book. He very kindly has replied to me. I do not have any other kind of relation with him.

This small book (192 pages) is pretty expensive but if it brings you a lot it is OK.

It depends what you are looking at:

If you want a book "how to write a clean C++ program", this book is for you. The authors enhance the formal (and correct) writing you should have when coding.

If you are interested in understand and solve the various problems you encounter implementing derivatives with numerous examples, it is not the good book for you. There are few programs so few examples and solutions. Moreover I have to dig in his classes to understand them. I would have preferred static functions, even if I have to do a little work to implement them in my library.

However from my point of view, the biggest reproach to this book is that it does not treat the interest rate derivatives at all, which is really problematic.

So it was not really interesting. The Clewlow was much better for me.

In terms of programming concepts and OOP design for financial engineering, this book has no equals. We have Daniel Duffy's Financial Instrument Pricing Using C++, but it takes a different approach (i.e. generic programming based in STL). All through the book, the author introduces improvements sequentially and doesn't start from the best design from the outset in order to demonstrate the flaws of a less general/useful/reusable program. In this sense, this is mainly a conceptual book, not an example book. For example, it deals with and develops vanilla-option pricing using Monte Carlo simulation over the first five chapters. A reader looking for a cookbook that gives programs to implement a large number of financial-derivative models would be well-advised to look elsewhere (e.g. Justin London's Modeling Derivatives in C++). However, someone looking for OOP wisdom would be generously rewarded for buying this book.

I couldn't help feeling that my good "academic" knowledge of C++ (confirmed by 98% Brainbench score) did not make me a quant developer. Here is a list of questions that I didn't know the answers for:

1) How often are the principles of OOP useful in practice? For instance, is it always a good idea to create classes and virtual functions? If not, why?

2) What technical features of C++ are important for quant development as opposed to only being used to create tricky test questions? Examples include pointers to member functions and virtual construction of objects.

3) The set of mathematical functions in the Standard Library is rather poor. It is therefore tempting to recourse to Matlab or S+/R if one needs to solve a particular quant problem. Is it possible to "boost" the computational toolbox of the Standard Library?

4) The interface provided by C++ programming systems, such as MS Visual Studio, is virtually absent compared to what can be quickly and easily done in Excel VBA. Is it possible to combine the Excel interface with C++ computational efficiency?

The book answers all of these questions by elaborating the practically relevant C++ design principles, and by introducing Boost and XLW to the reader. It builds a concise and informative bridge between the "studentwise" and industrial banks of C++ quant development. Therefore, I highly recommend it to all quant students and entry-level developers who feel that having C++ in their toolbox is a must.

Joshi's book is practical and concise. The whole book is project-based and through step-by-step method in his book, Joshi provide a vivid view towards how to construct a pricing engine in an object-oriented way. This book forces me to think in an object-oriented way and to think about code reusability, the logics and relation between different classes I put into my pricing engine. After my first semester's intense focus on this book, I found that my codes are just a nutshell of my whole logics and my understanding to the problem I want to solve, and then codes are extensible and readable.

It is not a book for reading, but rather a book for practicing. It is not an easy book. But some of my friends' interview questions are just the exercise in the book!! I would believe it is also a great book for preparing interviews.

This book will be very useful for anybody beginning to implement derivatives pricing models using an object-oriented language (not necessarily C++). Among the books of its class it is probably the best. The author keeps the exposition very focused on explaining how to apply such and such C++ object-oriented patterns to solving real life model implementation problems. All the model development issues described in the book are simplified versions of the real life problems that any quant really has to deal with at his job. It teaches you how to write every piece of software that one needs to write when implementing a model. That includes a random number generator class, a flexible Monte-Carlo engine, instrument class, variance reduction, a statistics gatherer class for your Monte-Carlo, solvers for finding implied volatilities, trees, etc. All of that is very well explained on examples of exotic equity options. The same principles apply though to building pricing libraries for all other asset classes, for example fixed-income (as a fixed-income guy I confirm that). Even though this book is less than 300 pages, it requires a decent amount of time to work through it. The exposition is rather dense. I had to read some pages/chapters more than once, play with the code, make sure I knew how to do the exercises before I could really grasp what the author was trying to convey. Reading this book will require a lot of effort, but it will definitely pay off in the end. For example, I was asked questions during my quant interview the answers to which knew from reading this book. Also understanding QuatLib code became much easier after reading this book. In conclusion I'd like to point out that the author is a well-known quant having real industry experience (unlike some other authors who write similar books).

C++ is the de-facto language of Quants.
Joshi's book successfully blends C++ and Derivative Pricing within a structured manner, laying the
foundations for future developement
This book has been my bible, and has exposed me to how a pricing engine should be structured in the context of C++

The worst crime an author can commit is killing of a reader's interest in the subject matter.
Fortunately there is Mr. Joshi's book to clear the air regarding the fundamentals of implementing pricing models in C++.
Mr. Joshi's style is not confusing, he elucidates ideas in a clear, concise manner without getting lost in the formalities/technicalities.
Many other authors get lost in the rigors of math or theory and then lose sight of the logical progression, the clarity of ideas that follow through to the result.
Fortunately, Mr. Joshi is not one of them.

This book met all my expectations. well organized, it follows an orderly progression of more and more complex techniques and patterns to solve the basic derivative pricing problem. Joshi also provides source code on his website so you can easily implement solutions and modify them as you wish. I found they all compiled on MS Visual C++ Express 2008 with no problems at all

Mark's book actually teaches you how to properly use classes and inheritance (virtual functions) to implement derivative pricing models in C++. The slim book is actually quite 'thick' in the sense that you need to spend some time on understanding the design and ideas behind those codes. In addtion, the second ed. includes a chapter on XLW (a package links C++ to Excel and modified by MJ). After using XLW for some time now, I have to say that it is definitely one of the best applications for financial engineering.

This is the book to buy if you want to develop/improve object-oriented thinking in C++.