December 29, 2011

There are so so many books on finance and financial mathematics, but not one that gives you a real sense of the terminology, techniques and general knowledge you will need to learn to become successful in fixed-income financial mathematics and trading.

This blog aims to cover topics of direct interest and directly applicable to anyone working on or alongside a fixed-income trading floor.

And for the generally inquisitive mind there are also scatterings from other topics of interest like mathematics, probability theory, computing, languages, economics, education, art & design.

As a starting suggestion, have a look at:

How to calculate option prices in your head

How to understand fixed-income trader jargon

A fast-moving introduction to probability theory

Everything you need to know about swap spreads

A non-technical description of the risk-neutral measure

Ito product and quotient rules in trader speak

Why does the yield curve slope upwards?

Intuition for the forward-FX equation

Please feel free to ask questions or post suggestions via the comments feature at the bottom of each post.

Or if that sounds too scary, just give me a Like with the button.

Improving the Jarrow-Yildirim inflation model

February 5, 2017

A few years ago I came up with a useful improvement to the Jarrow-Yilidirm inflation model: let’s diffuse the inflation curve rather than the real-yield curve.

It turns out that this gives the modern inflation derivatives trader a much better risk management tool.

In the attached paper I give the details. I wrote it up back in 2013 and never got around to publishing it. It happens that I was talking to someone about this just the other day and it occurred to me that I should get it out there. Enjoy!

Improving the JY inflation model

The value of open source

June 5, 2016

Of the many points made by Tom Preston-Warner in his article Open source (almost) everything, I particularly like the paragraph on why you should let your coders work on open source projects:

… dedication to open source code is an amazingly effective way to retain … talent. Let’s face it, great developers can take their pick of jobs right now. These same developers know the value of coding in the open and will want to build up a portfolio of projects they can show off to their friends and potential future employers. That’s right, a paradox! In order to keep a killer developer happy, you have to help them become more attractive to other employers. But that’s ok, because that’s exactly the kind of developer you want to have working for you. So relax and let them work on open source or they’ll go somewhere else where they can.

TypeScript with Underscore, a simple Grunt way

May 16, 2016

I use Underscore an awful lot. I have many good things to say about Underscore in the context of Functional Programming, but this post explains a simple one-liner which got my Underscore code quickly into our ever-increasing collection of TypeScript modules.

This is not a long term, fully robust solution incorporated into our Grunt build process, but it keeps us moving. A longer-term solution will use Typings, I imagine.

Here it is: did you know that you can have .d.ts files mentioned in the src slot of the grunt-typescript task?

So: we downloaded the underscore.d.ts file from the DefinitelyTyped repository, saved it into a separate ‘typings‘ directory and modified our grunt task to mention it as a source:

    typescript: {
      base: {
        src: ['app/typings/*.d.ts', 'app/scripts/**/*.ts'],
        dest: 'app/scripts/.compiled_typescript',
        options: {
            target: 'es5',
            declaration: true

In this way we keep our external TypeScript definitions in the separate directory, away from our ‘real code’, and now have the benefit of proper type definitions for our usage of Underscore.

A walkthrough guide to building yourself a Linux system for coding

November 24, 2012

In any technical role it is important to strike the balance between getting-things-done-quickly and knowing-all-the-details, and this is especially true when it comes to building computer systems.

You can find lots of different Linux distributions to download, and most have a relatively easy system for adding components or software via some kind of package manager.

However, anyone who is fiddling with Linux is probably doing so because they want to learn more about how their computer works. Dragging-and-dropping packages leaves you with a feeling that you haven’t really learned much.

The balance is wrong: we are getting things done but we really wanted to know more.

Of course, the way to know more is to roll up your sleeves and start building software from source code.

But experience has taught me that it is often much more difficult to build/compile than anyone will admit. Typically the problems come because you have some slightly different settings, or there is some minor file missing which everyone assumes is always there, or any one of a collection of ‘little problems’. An experienced user can circumnavigate these issues easily, but a beginner needs a much straighter path to the destination.

In this post I give a walkthrough of how to set up a Linux system (called Puppy Linux) and how to compile a few important packages (SDL, Tcl/Tk and Python) from source that you can use to write interesting pieces of software (eg games, eg applications with windows and buttons etc.).

The important difference with other ‘setup guides’ is that I have put a lot of effort into thinking how we can be sure that your machine is set up identically to mine, so that your walkthrough experience will be exactly the same as mine when I wrote it.

Read the rest of this entry »

Poker: become an ‘informed’ beginner

October 13, 2012

Introductory poker texts generally aim to take you from beginner- to intermediate-level.

Instead, this post aims to spell out a few key messages that will take you from absolute beginner to informed beginner.

It is a quick way to help you appreciate what poker is really about. If you dabble with online playing it should improve your profits too.

Read the rest of this entry »

What do normal subgroups look like?

September 26, 2012

I am in the process of writing a longer post on Galois Theory (see here), and one of the central concepts is that of a normal subgroup.

We all know the definition (and their equivalents) from classes/books, but anyone who likes to ‘see their mathematics’ is left with the question:

… but what do they look like?

In this post I give a few different interpretations of the standard definitions, and go some way to explaining why it is difficult to answer this question in concrete terms.

Spoiling the punchline a bit, it seems to me that problem is actually the other way round: most of the groups that you have an intuition about are normal, so the question is really when is a group not normal? Read the rest of this entry »

You are not a programmer!

September 26, 2012

Want to read an excellent article on how programmers should market themselves to the World of Business?

Click here to view.

The site is built by Patrick McKenzie and has lots (really lots) of other great content.

This video here of a presentation he gave on selling to underserved markets is a personal favourite.

Writing Latex articles with Vim

July 28, 2012

Vim is a text editor, part of the standard suite on a UNIX system.

This is a short post which is a store of some Vim keystrokes that I am progressively discovering, and which are worth sharing for anyone interested.

The main point is that with Vim you learn a new method of moving around a text file, so it is a bit like learning new paradigms for a foreign language if you like.

  1. Don’t move with the arrows, move by words or by searching.
    This means that for scanning through text you might do:

    1. Move forwards and back quickly with W, B and E (move by words, without recognizing punctuation),
    2. Get closer by releasing the shift and using w, b or e in the final stages to home in.

    And to move through larger distances use a quick search:

    1. hit / and type a bit of text to search forward, with n and N to move forward and back along those points,
    2. hit ? and type text to search backward, then use n and N likewise.
  2. Copy text you just typed for a paste later:
    1. Enter the text, then ESC and v to enter VISUAL mode,
    2. use ‘[ (moves to the point of where text was last changed),
    3. yank it with y.

For example, if I need to add something like ‘_{\text{N}}’ to a few ‘\sigma’ in my article I do this:

  1. find a ‘\sigma’ with /\\sigma,
  2. move to the end with e, and then append with a,
  3. type ‘_{\text{N}}’,
  4. ESC out and v into VISUAL mode,
  5. ‘[ and y to copy that text,
  6. now an n will take me to the next instance of ‘\sigma’
  7. and a quick e then p will paste the text where I want it.

Nice! In short, Vim seems to be a good fit for all of the usual text manipulations I do in a Latex article.

Interesting quant blog

June 17, 2012

A quick post to show a link to the blog of Tim Johnson at Heriot-Watt Unviersity.

Lots of writing on derivatives topics, from models to regulations, plus plenty on markets and the crisis.

Worth a look. Click here to visit.

Are our models too complex?

June 17, 2012

Gillian Tett is a well-respected writer for the Financial Times and frequently picks up the topic of complexity in financial markets.

In a recent article (see here) she makes a case that the era of number crunching is over, and that the world of investments is back again firmly in the domain of human relationships and evaluations.

Once upon a time we would measure credit risk with a numbers like survival probability stripped from CDS market prices. Once upon a time we were all happy to value a transaction with models that almost no-one other than the quants understood.

Her view is that these times are gone.