April Update from LMAX Technology

Here at LMAX we've been working dead hard to deliver more features and more ways to access the platform, and we've neglected the poor blog.

There are a few things of note that are worth mentioning from the LMAX technology camp:

• Mike Barker is featured talking about the Disruptor on the Distributed Podcast.
• Mike, Trisha Gee, and Andy Stewart all gave presentations at QCon London.  Links to the presentations will be posted as soon as they are available.

And there are more events that we're going to be at too:

• Trisha is presenting about the Disruptor at GOTO Copenhagen and GOTO Amsterdam at the end of May.  You can get a discount on your tickets for the event by using the code "gee1000".
• There will be an array of the usual suspects from the development team at the London Java Community Developer Sessions on the 17th April.

Oh, and we're still hiring developers.

Order and Execution Events

Quite recently we had a customer come to us with a question regarding the Execution events received on the API.  The question was: "How do a I recognise the last execution event for a given order event?"  This is a little bit tricky in the Java API as it does not behaviour exactly the same way that FIX does.  E.g. If an individual order with a quantity of 30 aggressively matches multiple price points (quantity of 10 at each) on the exchange, a fix user would expect would expect:

MsgType(35)=8, ExecType(150)=New(0), CumQty(14)=0
MsgType(35)=8, ExecType(150)=Trade(F), CumQty(14)=10
MsgType(35)=8, ExecType(150)=Trade(F), CumQty(14)=20
MsgType(35)=8, ExecType(150)=Trade(F), CumQty(14)=30

As our API is based upon our XML protocol the information that we can return on the API is restricted to what we receive in those events. For a similar scenario over our XML protocol only emits a single order event at the end of the matching cycle, therefore the data output would be:

	<order>
	<timeInForce>ImmediateOrCancel</timeInForce>
	<instructionId>1733844027851145216</instructionId>
	<originalInstructionId>1733844027851145216</originalInstructionId>
	<orderId>AAK8oAAAAAAAAAAF</orderId>
	<accountId>1393236922</accountId>
	<instrumentId>179361</instrumentId>
	<quantity>30</quantity>
	<matchedQuantity>30</matchedQuantity>
	<matchedCost>22.1</matchedCost>
	<cancelledQuantity>0</cancelledQuantity>
	<timestamp>2011-12-22T10:09:25</timestamp>
	<orderType>STOP_COMPOUND_MARKET</orderType>
	<openQuantity>20</openQuantity>
	<openCost>22.1</openCost>
	<cumulativeCost>22.1</cumulativeCost>
	<commission>0</commission>
	<stopReferencePrice>111</stopReferencePrice>
	<stopLossOffset />
	<stopProfitOffset />
	<executions>
	<executionId>3</executionId>
	<execution>
	<price>110</price>
	<quantity>10</quantity>
	</execution>
	<execution>
	<price>111</price>
	<quantity>10</quantity>
	</execution>
	<execution>
	<price>112</price>
	<quantity>10</quantity>
	</execution>
	</executions>
	</order>

view raw gistfile1.xml hosted with ❤ by GitHub

So the Java API does not have the information about the individual filled quantities as a result of each execution only the final state of the order. This can make it a little tricky to find which execution event represents the end of the matching cycle. The information seen by a user of the Java API for the same scenario would be:

getQuantity() = 10, getOrder.getFilledQuantity() = 30
getQuantity() = 10, getOrder.getFilledQuantity() = 30
getQuantity() = 10, getOrder.getFilledQuantity() = 30

However, it is possible to use some of the additional events that are available on the Java API to derive the same behaviour. By listening to both Execution and Order events we can track the cumulative quantities as we go. It does require a little bit more state management by the client, but the logic is fairly straight forward.

	public class ExecutionTracking implements OrderEventListener, ExecutionEventListener
	{
	private final Session tradingSession;
	final Map<Long, Order> lastOrderStateByInstructionId = new HashMap<Long, Order>();
	Order currentOrder = null;
	long currentFilledQuantity;
	long currentCancelledQuantity;
	public ExecutionTracking(final Session tradingSession)
	{
	this.tradingSession = tradingSession;
	}
	/**
	* The order event will always arrive before the associated execution events for that order.
	*/
	public void notify(final Order order)
	{
	final Order previousOrderState = lastOrderStateByInstructionId.get(order.getInstructionId());
	if (null != previousOrderState)
	{
	// Track the current filled/cancelled quantity as a delta between this
	// order event and the previous one of the same order.
	currentFilledQuantity = previousOrderState.getFilledQuantity().longValue();
	currentCancelledQuantity = previousOrderState.getCancelledQuantity().longValue();
	}
	else
	{
	// The is the first order event for this order, so start from zero.
	currentFilledQuantity = 0;
	currentCancelledQuantity = 0;
	}
	currentOrder = order;
	}
	/**
	*
	*/
	public void notify(final Execution execution)
	{
	// As we receive the executions for the order increment the quantities for each execution
	currentFilledQuantity += execution.getQuantity().longValue();
	currentCancelledQuantity += execution.getCancelledQuantity().longValue();
	// Once our per execution tracking of the order matches the totals on the
	// order itself, we've found the last execution for a given order event.
	if (currentOrder.getFilledQuantity().longValue() == currentFilledQuantity &&
	currentOrder.getCancelledQuantity().longValue() == currentCancelledQuantity)
	{
	System.out.printf("Last Execution: %s for order: %s%n", execution, currentOrder);
	if (isComplete(execution.getOrder()))
	{
	// The order has completed, all quantity is filled or cancelled, so remove the order from
	lastOrderStateByInstructionId.remove(currentOrder.getInstructionId());
	}
	else
	{
	// Track the order event for the next match
	lastOrderStateByInstructionId.put(currentOrder.getInstructionId(), currentOrder);
	}
	currentOrder = null;
	}
	}
	private void isComplete(Order order)
	{
	long completedQuantity = order.getFilledQuantity().longValue() + order.getCancelledQuantity().longValue();
	return order.getQuantity().longValue() == completedQuantity;
	}
	public void subscribe()
	{
	// Listen for both Order and Execution events
	tradingSession.registerOrderEventListener(this);
	tradingSession.registerExecutionEventListener(this);
	// Only subscription to execution events is required
	tradingSession.subscribe(new ExecutionSubscriptionRequest(), executionSubscriptionRequestCallBack);
	}
	}

view raw ExecutionTracking.java hosted with ❤ by GitHub

We're hiring!

If you like what we do and you're interested in working for LMAX, take a look at our Stack Overflow Careers advert.

Weekly Events Update - Tuesday 26th July

Apologies for the late post, unfortunately sometimes actual development gets in the way.

Last week

The Disruptor was nominated for the 2011 Java Innovation Awards.

We made a change to the application which means that FX trading is now only shut down for 5 minutes after 10pm, instead of 30 minutes.

A team of LMAX cyclists completed the London to Cambridge Bike Ride, raising money for Breakthrough Breast Cancer, and no-one (from our team) died.

This week

Mike will be giving a lightning talk at the LJC/JBUG event tonight, Tuesday. Trisha and Martin will also be turning up.

Future events

5th October - TradeTech Architecture. Martin Thompson, CTO, will be on one of the panels.

11th October - Goto Aarhus. Martin Thompson (CTO) and Dave Farley (Head of Software Development) will be presenting the LMAX Disruptor pattern: "100K transactions per second at less than 1ms latency".

13th - 14th October - Goto Amsterdam. Martin Thompson (CTO) and Dave Farley (Head of Software Development) will be tackling the folklore surrounding high performance computing.

31st October - 2nd November - JAX London.  Mike Barker and Trisha Gee will be presenting "Understanding the Disruptor, a Beginners Guide to Hardcore Concurrency".

15th November - StackOverflow Dev Days 2011. Mike Barker will be presenting on Performance & Technology Folklore. 

Weekly Events Update - Monday 18th July

This week

Some of the development team will pop in to the London Java Community monthly social on Tuesday. It's always a great night to talk tech (or not) and meet new people.

On Wednesday, Dave Farley will be giving a presentation at SkillsMatter on how we do Continuous Delivery.

Future events

5th October - TradeTech Architecture. Martin Thompson, CTO, will be on one of the panels.

11th October - Goto Aarhus. Martin Thompson (CTO) and Dave Farley (Head of Software Development) will be presenting the LMAX Disruptor pattern: "100K transactions per second at less than 1ms latency".

13th - 14th October - Goto Amsterdam. Martin Thompson (CTO) and Dave Farley (Head of Software Development) will be tackling the folklore surrounding high performance computing.

15th November - StackOverflow Dev Days 2011. Mike Barker will be presenting on Performance & Technology Folklore.

Nominated for three UK Agile Awards

We're excited to announce that we've been nominated for an Agile award in three categories:

• Best Agile Team
• Most Agile Aware Organisation
• Most Engaged Management Team
  

Using agile techniques is important to the way we deliver business value as fast as possible, so it's nice to get a little recognition in this area.

Weekly Events Update - Monday 4th July

Last week

We made a number of tweaks to the Disruptor, with some improvements to the code and some changes to the website, and there are now a number of blog posts explaining sections of it.

There has also been work on two .NET versions of it: one on github and one on Google code.  We're pretty excited about them and interested to see the results.

This week

On Wednesday some of us are attending "The Future of TX Trading Debate" hosted by EQUINIX.

Thursday is Oracle's global introduction to Java 7, with a live webcast.

Future events

5th October - TradeTech Architecture. Martin Thompson, CTO, will be on one of the panels.

11th October - Goto Aarhus. Martin Thompson (CTO) and Dave Farley (Head of Software Development) will be presenting the LMAX Disruptor pattern: "100K transactions per second at less than 1ms latency".

13th - 14th October - Goto Amsterdam. Martin Thompson (CTO) and Dave Farley (Head of Software Development) will be tackling the folklore surrounding high performance computing.