Expect more in the iPad/HTML5 space soon……

Customising FX algorithms (page 102) touches are on time-slice orders coupled with almost shouting out about the obvious DSL trading language for constructing algorithms. I’m guessing backtesting is leveraging a tick plant?

• Added a LINQPad style of interface to MSE so that strategies can be entered
• Allow the DSL to either alert from a strategy or submit orders (DMA?)
• UX the alerts onto the charts based on what “streams” the strategy is consuming
• Integrate the DSL on top of StreamInsight to leverage what MSE already provides

Sidebar: Seven common Sprint Burndown graph signatures

Bats Europe operates the “market-taker” fee model – a tariff structure that pays firms for supplying liquidity and charges those that take it. This model has contributed to Bats success among the HFTs. It will be interesting to see if the LSE changes have any effect on the dent to market share that Bats and Chi-X have had on the LSE.

Here he works up a large network diagram on UBS� �Analyst Transparency Report�. Required publishing by banks each quarter. Check out his post, he drills down on sections of the graph which turn up unexpected connections.

UBS� �Analyst Transparency Report�.

The connections indicate the recommendations by analysts to stocks. Buy (green), neutral (black) or sell (red). Check out his post where he drills down further into sections of the graph.

There are many other interesting groupings and links buried in the graph. I think viewing extremely long tables as a graph like this could help us spot relationships we might not have otherwise seen.

• Screen real estate
• How to alert traders to changes
• Lots of tenors
• T-1 PnL

One component that is rarely talked about within the context of a BP is what Microsoft is calling Advisory Services, or specifically the Institutional Client Platform (ICP). If you watch this video you’ll hear that ICP is aimed at providing sales with information on buying patterns, suggesting products, etc. “Single view of the client” is particularly key, and one that I don’t believe has been fully explored by any of the current SDP’s.

There are a number of other video’s which touch on ICP, specifically FAST – obviously if your going to build ICP you need a search engine. The FAST video mentions research data, but I suspect there is a wealth of data that needs to be searchable in ICP land.

If you look at a OLAP cube its fundamentals are dimensions and measures. So the initial Proof Of Concept for the aggregation engine is to build an appropriate hierarchical tree structure that holds the dimensions and measures. Reduce contention to a minimum and see if we can load the “cube” with 5-10K per second update of position/risk data. Then look to at hook for aggregation engines off the cube, leveraging an appropriate notification mechanism. Aggregation engines need to be attachable in a dynamic way so that only the aggregations that are in use and in play, otherwise the calculations will overwhelm the application. Finally, we need to see if our public API allows us to handle MDX queries. If I get this far I suspect I’ll be doing well The final obvious hurdle is to move to a distributed environment. More to come.

Sidebar: Convention-based auto-registration extension for Unity

A classic aggregation might be based on organisation hierarchy: Region-Desk-Book. There are many regions, each region can have 1 or more desks, each desk can have many books. When a trades PV01 is calculated the appropriate aggregation needs to be updated. Another fairly classic aggregation is by asset class, where the buy/sell-side may have a hierarchical structure of asset classes e.g. Rates contains all Bonds, IRS and FX trades. Now a trader might want to see various aggregations on his UI, and he may want to slice and dice his trades based of numerous other possible aggregations. What is clear is that you probably can’t calculate in real-time every possible aggregation, and that you are probably better off only calculating (and hence streaming) the aggregations that users are currently viewing.

You may consider using OLAP to handle the aggregations. Oracle, Microsoft and others provide OLAP support on top of relational database, but for anything approaching real-time risk, OLAP is probably just not going to keep up and provide sub second response times coupled with streamed notifications. A number of other vendors have built OLAP cubes in memory, or used vector databases which can provide appropriate real-time aggregation.

Where am I going with all of this? More to come…..

• Decide when to snap the market data
• Generate the curves based off the snapped market data – e.g. yield curve and forecast
• Copy the trades
• Generate the cashflows for the copied trades based off the snapped curves/market data
• Report Market Risk
• Start from the top again based on some event e.g. time

    let valueDate = new DateTime(2010,1,1)
    let trade  = createIRSTwoLegTrade 101
    let npv =
        trade.SwapStream |> Seq.sumBy (fun x -> generateCashflow(x,trade, valueDate, curve, forcast))
    printfn "IRS NPV %A" npv

    let bumpCurve = curve |> List.map (fun x -> (fst x + 0.0001, snd x))
    let bumpForcast = forcast |> List.map (fun x -> (fst x + 0.0001, snd x))
    let shockedNpv =
        trade.SwapStream |> Seq.sumBy (fun x -> generateCashflow(x,trade, valueDate, bumpCurve, bumpForcast))
    printfn "IRS Shocked NPV %A" shockedNpv

    printfn "Parallel PV01 %A" (npv - shockedNpv)