CV

Resume-Quant-Paul Hollingsworth

Contact:

email: paul@paulhollingsworth.com
phone: (+44) 7817 932182

Availability: 4 weeks

SUMMARY

I’m a quantitative programmer with 15 years of experience in front office roles for the financial services industry.

I love programming, and it gives me great satisfaction to help people solve their problems using software, no matter how “unglamorous” those problems sometimes are. What really motivates me is working directly with the end users of the software that I write – typically this means working on a trading floor.

Most recently I’ve been helping the FX options desk at Westpac Institutional Bank to build a pricing, risk management and PnL system.

Some of the areas I am experienced in are: FX, equity derivatives, credit derivatives and high frequency algo trading. I am fully versed in quant finance concepts such as: risk-neutral pricing, dynamic replication, partial differential equations, linear regression, statistics, stochastic calculus.

I like to think that I write elegant, correct and efficient code in .NET, Java and C++.

ONLINE CODE EXAMPLES

Here are some examples of the sort of code I that I like to write:

https://github.com/Patient0/FirstClassLisp – an open source lisp interpreter I wrote in C#.

https://github.com/Patient0/ChessPuzzle – A Haskell program that solves “n-queens” type problems.

Here’s what I’ve been doing most recently:

EMPLOYMENT HISTORY

February 2011 – Present
Contract at Westpac Institutional Bank

Implementing an FX options pricing and risk management system for Westpac’s desk traders in London.

Initially we implemented an Excel-like pricer to allow sales and trading to quickly price and enter deals, and to link the legs of a deal together to allow more complicated “solving” functionality.

Most recently, I’ve added risk management and “PnL explained”. This allows traders to see the exposure of their portfolio to external markets (the “greeks”) and to explain the day-to-day PnL in terms of their market exposure and other trade activity.

This is a “greenfield” project – we’ve implemented the entire system from scratch.

The code is in Java and interfaces to model libraries written in C++.

September 2008 – January 2011

Vice President at Barclays Capital

Worked on the Fixed Income Exotics Risk system within Barclays Capital. The system is responsible for publishing daily PnL and risk numbers to the desk. This was working mainly in .NET, but also with some C++ required.

  • Designed and implemented a Flexible Query Engine. This is an on going project that presents an efficient relational abstraction on top of all of our risk data (a trillion row data set). The flexible part is that without any rebuilding or even restarting of the server, new sources of relational data including other SQL databases, Excel regions or anything else that can represented as a table can be incorporated into queries.
  • Designed and developed an Automatic Report Generator. This is used for the automatic publication of all daily PnL and Risk reports to the desk
  • Designed and developed a Post Processing Engine. This is the main engine which performs all data cleaning and finite difference calculation tasks (e.g. our PnL calculations are performed by this engine).
  • Developed XMLisp – a minimal Lisp interpreter which we embedded into the other components of our system. This allowed us a flexible, standard XML configuration format which let us minimize duplication as requirements changed.
November 2006 – August 2008

Developer at Royal Bank of Canada Capital Markets

  • CDO VaR

C++, Windows, Tibco. Convert quant spec for CDO VaR calculation into working code. Worked with quants on mechanisms to handle shocking of CDS spread and correlation curves in extreme scenarios. Numerous performance and functionality improvements to enable existing system to be able to value 100,000+ CDO risk scenarios per overnight run.

  • Sybase CTlib C++ wrapper

Sybase ctlib, template meta programming. Wrote C++ wrapper over Sybase ctlib to ease implementation of database client code. Used template meta programming techniques to ensure minimal coupling and compilation dependencies between the different clients’ types and native Sybase types and headers, while keeping an easy-to-use interface.

An example of the way client code looks is:

ResultBinder results = connection->buildCommand(“select tradeId, expiry from trades”)->execute();
    std::string tradeId;
    // RBCDate is some user type that is not “part” of the library. RBCDate expiry;
    results.bind(0, &tradeId);
    results.bind(1, &expiry);
    while(results.fetch())
        // Do stuff with tradeId and expiry

The key point was that to use the library you did not have to couple your code to any specific date or string type – you could define your own bindings via specializing templates.

October 2005 – September 2006

Developer at Citadel Investment Group (Europe)

C++ and Linux. Implemented:

  • Low latency XETRA and Values API feed
  • Liquidity Finder component to allow internal matching of orders with other internal hedge fund businesses. Orders from other systems in the post office are checked against prop desk’s own positions, and matched internally if desirable (but still according to best execution rules).
  • Proprietary trading algorithms (maintaining an in process order book, collection of real time statistics on order placement, latency, market data etc.)
March 2001 – October 2005

Associate Director at UBS AG (Chicago, then London)

This was split into two main periods:

Sep 2004– October 2005 – Equities Quantitative Strategies group.

Java, C++

  • Designed, implemented and deployed a basket decomposition library. Used analytic differentiation to shred greeks for derivatives based on arbitrarily complex recursively defined basket structures.
  • Worked with other quants to improve C++ coding standard throughout the code base
Mar 2001-Sep 2004 – Equities Risk IT

Java, multi threaded programming

  • Designed and implemented the Java re-write of the real time equity risk engine.

The original component was written in poorly performant C++. The Java re-write was part of a global overhaul the equity risk infrastructure. The engine allows traders to see multiple concurrent views of their portfolio position broken down by arbitrary attributes, all ticking in real time. All changes to the portfolio (trades, prices, volatility surfaces etc.) are updated in real-time.

Leave a Reply

Your email address will not be published. Required fields are marked *