I haven’t updated any links in my blog but will gradually get there. I also changed the license to the very permissive MIT license, so you are free to use this as you wish (at your own risk… as always).

I also finally compile a help file again! I need to add some additional source comments, but the release files now contain a compiled chm file. Also every build is built on a build server finally, so dropping releases should be quicker.

I have one known bug where if you use the disconnect logic heavily you can run into issues – I will tackle this when I get a chance.

I am thinking of moving the library to google code or codeplex, so this may happen in the coming weeks. I have also been receiving a lot of requests for documentation, so I will look at building helpfiles again. I used to use sandbox, but their web documentation is asp.net, and this server is a linux machine, so I’ll see what I can do.

Also need to work on forums – some spam bot has taken over.

I also finally added parameterless constructors to all of the event args so that they can be serialized/deserialized.

Added the warrant type to securitytype.

Fixed orderId going to 2^31-1 when it should be interpreted as zero.

Check it out in subversion, or I will make another release soon.

As you can see in the above central box, our trading system abstracts several core functionalities.

• Settings Management – the entire trading system is configured via a straightforward xml configuration file. The actual storage and management of this is abstracted by the particular profile. For live running, these settings are version controlled and managed in a central replicated sql database. For simulation, these are stored as a simple file provided to a console based simulator. For optimization purposes, these files serve as the basis for chromosomes in the genetic optimizer (with an optimization file providing the constraints for the search space). At the end of the day, develop a simple generic settings management system that can be abstracted for different targets.
• Contract Manager / Base Contract – The core component of any system is the instrument that you are trading / measuring. The contract manager provides position management and risk management abstractions, as well as contract locating functionalities. Ultimately any object that requires a contract, goes through the contract manager, and is given an abstraction of a base contract. The base contract can be a futures contract, equity, bond etc. This provides for a universal interface to subscribe to market data, and issue / monitor orders.
• Strategy Engine / Base Strategies – The strategy engine is the very heart of any trading system. This basic class subscribes to message pumps and processes the messages to handle orders. It is the most versatile object in the trading system, allowing for nearly any type of strategy.
• Charting – Few systems put enough emphasis on thorough charting, but I find it critical for visualizing the results of a simulation, as well as determining what is happening during live trading. All contracts and strategies implement a simple IChartable interface that allows them to output highly configurable charts, right down to the Graphics handles. This allows the charts to be presented in a live windows forms view, or painted to a Bitmap class for saving to disk.
• Logging – At the end of the day, traceability is critical. Every trade made needs to be serialized to disk / database in order to reconcile with your clearing house. Furthermore, every strategy needs to output useful tracing information to aid in debugging. Beyond the obvious tracing, strategies also need to implement a reporting interface to provide live state information to the user interface in order to determine how it is behaving, and if necessary to modify its parameter set, or to debug the strategy. This again is abstracted, just like settings and charting to go to different destinations based on the target of the trading engine. For simulation it outputs to the simulation results, whereas in live trading we work against easily queried database engines.

Next up I want to cut into application design and multithreading. There is a lot to cover, and I am swamped, so expect the articles to continue to appear as I have time. And if you have any questions feel free to email email hidden; JavaScript is required.

All of my prior interfaces with Ib have been for strictly self contained situations. Essentially where the program is placing orders and monitoring messages for the orders it has placed. I am now writing an interface to listen for any orders placed by any application or directly through the TWS interface. It appears I can use the RequestOpenOrders method with a clientId of -1 and receive all open orders at that moment in time, or I can use the RequestAutoOpenOrders to map TWS order messages to my client with a clientId of 0. But it does not appear there is any way to get all order updates from any target without constantly querying the open orders method.

Does anyone have a better way to do this?

This is a non-relational database, which is well suited for things like raw tick data, where you are not querying them by values, but instead by an indexed time and symbol field.

To give you an idea of why this is important, take a look at their white paper from 2006 on performance. In a transacted environment they achieved 125,486 single record writes per second. With modern 2009 hardware, and multiple CPU / Solid State Disk systems, this could readily record every single tick coming off of the NYSE and NASDAQ (multiple million per second).

Check them out at Oracle Berkeley DB. I’m in the process of testing this out for our historical logging, and am very impressed so far, even on commodity hardware.

To illustrate a common problem with trading systems. You have a producer consumer model, where your data is coming in from the exchange on a single thread. This data is going to a large number of contracts, and it would be nice to do this in a multithreaded model. Under the ordinary paradigm, you would create a queue, have your producer thread lock on the queue, add the new market ticks, and unlock, letting your consumers take locks on the queue, and beginning to work on this. There are special concerns though, for a given contract you need to make sure all ticks are handled synchronously, and whenever the queue hits zero for a particular contract after data has changed, you want to tell your strategy to process the new data. Here you would need a second producer consumer framework, and things continue expanding from there.

With the CCR, you would break things down into tasks. There would be a task that consumes raw market data and posts it to a port. There would be a task that takes a tick from the market data and posts it to a contract. There would be a task that takes a tick in a contract and updates the contract, checking at the end if the contract’s queue is empty, if so, it would post the entire contract to the strategy saying it has been updated. There would be a task that consumes a contract and updates the strategy. All of these are small work tasks that are setup to run in a common dispatcher pool, and are all invoked every time a work product is posted to a port. No complicated setup, just arbitrated registrations.

I’d love to spend a lot more time talking about this, but here is one short example.

</code>using (var dispatcher = new Dispatcher(0, "Master Dispatcher"))
{
var dispatcherQueue = new DispatcherQueue("Master Queue");
var tickPort = new Port<int>();

Arbiter.Activate(dispatcherQueue, Arbiter.Receive(true, tickPort, tick=>
{
if(tick > 25)
{
Market.PlaceOrder(tick, 1);
}
}));
while(true)
{
tickPort.Post(new Random().Next(50));
}
}

I realize there are many simplifications made in this post – I just wanted to convey how cool the CCR framework is. If it were free, I’d post my Ib wrapper for it! Easily worth the $400, and if you are a student you can get it from the Robotics Studio for free. There is talk of merging it with the parallels framework added in C# 4.0 (another great invention… waiting for VS 2010 to fully integrate it though).

I also added an overload to RequestHistory which allows you to specify the duration to allow you to pass a string for duration directly to Ib.

If you have any problems, email hidden; JavaScript is required.

Download the release here, or go to the utilities page.

• I’m new to programming and I just don’t get your TestApp running. How exactly do I link to TWS ? Do I need to add any references or components from the IB API software?

In TWS you will need to goto Configure -> API -> Enable ActiveX and Socket Clients.
Next select Configure -> API -> All API Settings
In the window that appears, under Trusted IP Addresses, select Create, and add “127.0.0.1″ (The local machine) to the Trusted IP Addresses. Select OK, and you are good to go.

• 9.6.3.13 New Release – 7/20/09
• Update to Ib’s 9.63 api
• Add shortable tickType
• Fixes to ReadDecimal
• Fix 1 second barsize enum.
• Fixed Bug with IBClient.ReadDecimal()
• Fixed bug in ExecutionFilter

I also reorganized subversion to relink all of the files’ history, I had accidentally broken things when I first made the archive public.

This release has not gone through quite the normal scrutiny of my prior releases, but it was so overdue, I thought I’d get it out there, and if you have any problems, email hidden; JavaScript is required.

Download the release here, or go to the utilities page.

• If you stop maintaining your wrapper to the latest versions and the IB API changes to newer versions, how long will your existing C# API wrapper keep working?

Ib goes to great lengths to maintain backwards compatibility with old apis. If you look at their api code, it is clearly version controlled by the method, and I wouldn’t be surprised if code from many years ago still works.

As an example, I have been running an API app I wrote in Jan / Feb of 2008 every day since without updating the api once and have had no problems.

• If you stop maintaining your wrapper to the latest versions, would you possibly update it for a small fee? (I am not rich, just trying my hand to get rich!)  I would hate to lose all the effort into coding this ATS.

Always a possibility, but it is my intent to keep updating it for free. I’ve become somewhat less reactive to Ib version updates because each update adds relatively obscure features, and since compatibility is always maintained, it is not super urgent. That being said, I will get myself caught up here shortly, and continue to update to the latest version.

• Has your wrapper matured over time and currently working well?  No inherent hard to debug problems?  (Sorry for my asking but my Delphi friend has many of these!)  I noticed your excellent forum for help.

Good question, it certainly has matured. Occasionally some parsing bugs have been pointed out, specifically with my use of decimals, but I address those quickly with updates to subversion, and changes get rolled into the next release.

Let me know if you have any other general questions and I will create an FAQ page.

This will also make it easier for users to generate patches against the Api, and if anyone is interested in becoming a contributor, I am certainly open to it. Drop me a email hidden; JavaScript is required.

I just downloaded the latest VS2010 Beta 1 to play with, and am contemplating making breaking changes to the library that use C# 3.5 features. How important is VS 2005 support to people? Is everyone running VS2008 or later? Or do I need to maintain the 2005/C# 2.0 backwards compatibility?

Let me know in the comments, I will be steadily making changes here.

I also made a large update to the event handler framework to make the calls thread safe now.

Please download it directly here or from the utilities page here.

In any case, this release has incorporated all of the changes with IB’s 9.51 release, the decimal conversion, and a series of bug fixes.

As always, goto the utilities page to download here, or download directly from here.

9.4.0.9 Bug Fix and Clean up – 2/10/09

• Made all EventArgs Serializable as well as the new enumeration FATypes.
• Fixed bug in OrderType.MarketOnClose – changed Description from "MKTCLS" to "MOC"
• Fixed RequestExecution method to allow you to pass a null or empty filter to get all executions.
• Changed HistoricalRequest Response. Added two parameters to the event args that lets the user know how far the download is. Also no longer calls function after download completed with null entries, since you can determine that the call is complete by the Record Number / Record Count properties.
• Made EnumDescConverter Static, as all methods were static.

As usual, download it from the utilities page here, or directly here.

Please note this release has breaking changes, not to functionality, but you will have to update your events and function calls to the correctly spelled equivalents.

• 9.4.0.8 Code Clean up – 1/31/09
  • Ran Vs2008 Code Analysis Wizard / FxCop and implemented cleanup
    • Numerous Spelling Changes
      • All Mkt references went to Market
      • All Req references went to Request etc.
      • All Lmt references went to Limit
      • All Indice references went to index
    • Added a lot of CultureInfo related fixes, making sure to provide invarient parsing
  • Fixed VB Client, used old contracts, and changed contract references to equity/future

As always, please go to the utility page here to get the latest release, or directly from here.

The following is the change log from the release notes

• 9.4.0.7 Bug Fix Release – 1/26/08
  • Changed FAMethod to Enumeration
  • Changed OrderState.Status to enumeration
  • Fixed several data parsing problems related to empty strings
  • Added Visual Studio 2008 solution, all files are still C# 2.0 compliant.

As I mentioned above, I now develop in Visual Studio 2008 against .net 3.5, but have been careful to keep this library C# 2.0 compliant. Let me know what platform you are using, if everyone has switched to .net 3.5, I may consider using new feature in future releases.

Without further ado, goto the utilities page to download the latest version or download directly from here.

• 9.4.0.6 API and Bug Fix Release – 12/9/07
  • Updated to support 9.40 Interactive Brokers API Release
    • What-If Order Support
    • Commission Data
    • Contract/Contract Details Refactored
  • Fixed Historical Request 1 day limitation
  • Changed TickSizeEvent Args to use TickType instead of TickerType
  • All Enums / Container classes are now marked serializable
  • Fixed bug on Stop Limit Orders "STPLMT" -> "STP LMT"

As always please post on the forums if you find any issues, or email hidden; JavaScript is required with any questions.

Please precede to download from the utilities page, or directly here.

Various sites report implementations, but always define it in terms of indicators which have varying definitions. Namely FxStreet defines the general concept here, but only in terms of DI+/-, TR and DM+/-, each of which has varying definitions. ForexReal defines ADX here, but uses a completely different concept of TR. Stockwiz has a good overview of all of the variables used (at least they define all of their variables) here. I will be defining the ADX all the way down to price action (what you need when you are coding this…) as best I can to the original definition by J Welles Wilder.

Lets start by defining the Directional Move indicators

Directional Move Indicator

         = the Positive Direction Movement Indicator

          = the Negative Direction Movement Indicator

We use two helper variables to track the delta extreme price changes from yesterday

If today’s range is entirely within yesterday’s range, or the range is the same, then there has been no directional movement.

If the range moved up, then there has been a positive directional move.

If the range moved down, then there has been a negative directional move.

Average Directional Move Indicator

          = the Average Positive Direction Movement Indicator for N periods

          = the Average Negative Direction Movement Indicator for N periods

The Welles Wilder Average is used here to stay true to form, but this average introduces a lot of latency, so I will also implement an exponential moving average.

Alternatively, the formula for the ADM with an exponential moving average is shown below.

True Range

          is the true range for a given period. It is a measure of volatility and takes into account any overnight gap in the period’s price.

Average True Range

          is the average true range for N periods.

The Welles Wilder Average is used here again to stay true to form, but for my C# implementation I will be using the exponential moving average.

Alternatively the ATR can be calculated with the exponential moving average as shown below.

Directional Index

          is the average positive directional movement indicator normalized by the average true range.

          is the average negative directional movement indicator normalized by the average true range.

The directional index calculation is very straight forward and shown below.

Directional Movement Index

          - the directional movement index is the difference of the directional indices over the sum directional indices.

Average Directional Movement Index

          is the average directional movement calculated over N periods.

Staying true to form again, the Welles Wilder Average is used below.

Again, you can alternatively use the exponential moving average as shown below.

C# implementation

So after the laborious research to determine exactly what the ADX is and should be (exponential vs Welles Wilder Average), here is the C# implementation of this indicator.

    //The Average Directional Indicator

    if(barHistory[timePeriod].Count > 1)

    {

        //Directional Movement Indicator

        double deltaHigh = cBar.High – barHistory[timePeriod][barHistory[timePeriod].Count – 2].High;

        double deltaLow = barHistory[timePeriod][barHistory[timePeriod].Count – 2].Low – cBar.Low;

        if((deltaHigh < 0 && deltaLow < 0) || (deltaHigh == deltaLow))

        {

            sig.DmPlus = 0;

            sig.DmMinus = 0;

        }

        else
if(deltaHigh > deltaLow)

        {

            sig.DmPlus = deltaHigh;

            sig.DmMinus = 0;

        }

        else
if (deltaHigh < deltaLow)

        {

            sig.DmPlus = 0;

            sig.DmMinus = deltaLow;

        }

        //Average Directional Movement Indicator

        if(barHistory[timePeriod].Count <= 2)

        {

            sig.AdmPlus = sig.DmPlus;

            sig.AdmMinus = sig.DmMinus;

        }

        else

        {

            double a = (double) 2/(double) (calc.DMIPeriod + 1);

            sig.AdmPlus = sig.DmPlus * a +

                symbolHistory[timePeriod][symbolHistory[timePeriod].Count-2].AdmPlus * (1-a);

            sig.AdmMinus = sig.DmMinus * a +

                symbolHistory[timePeriod][symbolHistory[timePeriod].Count – 2].AdmMinus * (1 – a);

        }

        //True Range Indicator

        sig.TrueRange = Math.Max(Math.Abs(cBar.High – cBar.Low),

                                 Math.Max(

                                     Math.Abs(cBar.High – barHistory[timePeriod][barHistory[timePeriod].Count – 2].Close),

                                     Math.Abs(barHistory[timePeriod][barHistory[timePeriod].Count – 2].Close – cBar.Low)));

        //Average True Range Indicator

        if(barHistory[timePeriod].Count <= 2)

        {

            sig.AverageTrueRange = sig.TrueRange;

        }

        else

        {

            double a = (double)2 / (double)(calc.ADXPeriod + 1);

            sig.AverageTrueRange = sig.TrueRange * a +

                symbolHistory[timePeriod][symbolHistory[timePeriod].Count – 2].AverageTrueRange * (1 – a);

        }

        //Directional index Indicator

        if (sig.TrueRange != 0)

        {

            sig.DiPlus = 100 * sig.AdmPlus/sig.TrueRange;

            sig.DiMinus = 100 * sig.AdmMinus/sig.TrueRange;

        }

        else

        {

            sig.DiPlus = symbolHistory[timePeriod][symbolHistory[timePeriod].Count – 2].DiPlus;

            sig.DiMinus = symbolHistory[timePeriod][symbolHistory[timePeriod].Count – 2].DiMinus;

        }

        //Directional Movement Index Indicator

        if ((sig.DiPlus + sig.DiMinus) != 0)

            sig.Dx = Math.Abs((sig.DiPlus – sig.DiMinus)) / (sig.DiPlus + sig.DiMinus) * 100;

        else

            sig.Dx = symbolHistory[timePeriod][symbolHistory[timePeriod].Count – 2].Dx;

        //Average Directional Movement Indicator

        if (barHistory[timePeriod].Count <= 2)

        {

            sig.Adx = sig.Dx;

        }

        else

        {

            double a = (double)2 / (double)(calc.DMIPeriod + 1);

            sig.Adx = sig.Dx * a +

                symbolHistory[timePeriod][symbolHistory[timePeriod].Count – 2].Adx * (1 – a);

        }

    }

Sample Data

This is a sample data set consisting of the NYSE A/D 1-min bar data (“Close”) from August 28, 2007 and the 14 period ADX in red.

The Kaufman Adaptive Moving Average is a great low latency moving average filter. It technically has an infinite tail, but cleverly weights the amount of signal for each new bar based on the historical trendiness. If the past data has been choppy, then each new bar is weighed very low in the average, however if the past data has offered a strong direction (regardless of magnitude) then the average weighs new signal very heavily.

There aren’t too many sites discussing the actual formula – I based my implementation on the MetaStock code found here.

I started writing this post in windows Live Writer, and found that it does not keep Visual Studio’s source formatting, so I will try to post this from Word 2007. Word is much better at formatting, but terrible with images, while Live is great with images and managing the site, but terrible with formatting.

//Direction is just present over previous price
double direction = cBar.Close - BarHistory[timePeriod][BarHistory[timePeriod].Count - cnt].Close;
double vol = 0;
//Vol is the sum of all differences in the past period
for (int ix = 1; ix < cnt; ix++)
{
	vol += Math.Abs(BarHistory[timePeriod][BarHistory[timePeriod].Count - ix - 0].Close - BarHistory[timePeriod][BarHistory[timePeriod].Count - ix - 1].Close);
}

//if not enough data, or there has been no price change, then AMA is price.
if ((direction == 0 && vol == 0) || cnt == 1)
{
	sig.Ama = cBar.Close;
}
else
{
	//Elastic ratio
	double ER = Math.Abs(direction/vol);
	double FastSC = 2/(calc.AMAFastEMA + 1);
	double SlowSC = 2/(calc.AMASlowEMA + 1);
	double SSC = ER*(FastSC - SlowSC) + SlowSC;

	//This is the magic scaling/smoothing constant.
	double conC = SSC*SSC;
	if (cnt == 2)
	{
		sig.Ama = BarHistory[timePeriod][0].Close + conC*(cBar.Close - BarHistory[timePeriod][1].Close);
	}
		else if (cnt > 2)
	{
		sig.Ama = BarHistory[timePeriod][barHistory[timePeriod].Count - 2].Close +
		conC*(cBar.Close - BarHistory[timePeriod][barHistory[timePeriod].Count - 2].Close);
	}
}

This is easily my favorite indicator, and with a lot of tweaking can actually be made to have a lot lower latency. The key thing about noise removal, is that signals are noisiest when their trending derivative is lowest. This fact allows a lot of clever hacks to lower the latency of filters like the ATX. That being said, it is often important to use an indicator unscathed, as so much of the market uses it, its performance is a self fulfilling prophesy.

View the new documentation sites here

• http://ibhelp.dinosaurtech.com
• http://ibhelpbeta.dinosaurtech.com

Please download release 9.3.0.3 here.

I chose to make the RightType enumeration translate to "PUT" and "CALL". A bug report from the yahoo forums illustrated that this is no longer true, and that "P" and "C" are the only accepted values.

Please download the bug fix versions

9.2.0.2 and 9.1.0.2

Both also available under utilities.

Why did you do this?

I’m sure many of you are wondering why I would spend so much time on this, when Interactive Brokers now makes a .net version available through their J# compiler. The reasons are many, but mainly the J# component breaks a lot of C# design rules, and is poorly documented. My port places the documentation inline, so Visual Studio will bring up the messages, and so you are not working with cryptic const values.

Support / Stability

I plan to simultaneously support two C# clients, corresponding to the latest release of the TWS API as well as the TWS Beta API. My assembly versions will match the TWS API with an additional revision to correspond to my changes. For example, this initial release’s version is 9.1.0.1 corresponding to TWS API 9.10 and my release version 1. Please note that this is release version 1. I am considering this an alpha release as I have mechanically ported and cleaned up a lot of the code, but have not thoroughly tested every function yet.

License

The source is free for you to use in any application you like. I ask, but do not require, you to give me credit and a link back if you like it. I also ask, but do not require that if you improve the library, or find any problems that you send me your changes / problem report, so I can continue to make this better. I want to be clear that I do not hold any liability or responsibility for any use / content of this code.

Documentation

I have published MSDN style documentation from generated from the library at http://ibdoc.dinosaurtech.com. This documentation was populated from Interactive Broker’s User Guide, and notes from the IB Yahoo Forum and was generated using Microsoft Sandcastle with DocProject. I will continue to revise it on feedback from users, and as I find room for improvement.

Forum

I have created a forum, where I would like to collect problem reports / feature requests at http://www.dinosaurtech.com/forums/ and ask that any users register and provide feedback there. I will try to be very responsive, and incorporate your feedback.

Credits

This library is a port of the Interactive Brokers Java library, so of course I would like to credit the interactive broker’s developers for their API. I also used code from an article by Javier Compos "Description Enum TypeConverter" in order to transform the ugly consts to pretty enumerations with overridden ToString() functions.

Downloads

• Version 9.1.0.1 Library – July 8, 2007 – Alpha – Corresponds to IB API 9.10
• Documentation

Please note that I will maintain the latest on my utilities page.

I realize many brokers provide you tools / data to do this (I know Interactive Brokers does at least) but I really wanted something simple and open source that I could hack to bits to put on my own indicators and so forth.

Please let me know if you find this useful or have any problems – it is a C# app that uses opentick’s data base (you must be a registered user) and ZedGraph to draw the graphs.

Below are a series of screenshots to illustrate the features.

Startup screen. On first load you must press “Config” and enter your username / password for opentick.

Enter your username / password in the dialog boxes, and any changes to the opentick servers (nothing should need to change…)

Enter the Exchange / Symbol you are looking for – Open tick’s exchange codes are listed here.
Please note the standard version is configured for west coast users (it downloads from 6:30AM to 1PM). If you are in a different time zone, please modify the source appropriately.

This is the initial chart that will appear (5 minute bars).

This is the raw ticks display (The Volume is just the total volume at any given point in the day.) You can change the timebase by clicking on the combo box at the top left as illustrated above.

The volume bars are synchronized with the share price axis, so if you zoom around, the two maintain sync.

Please post a comment if you have any problems, and I will get back to you promptly.

Download Here

Kodak Gallery Easy Uploader

Shutterfly Uploader

As you can see, these options present a very intuitive upload experience. Shutterfly in particular is literally as simple as dragging pictures on, and it immediately begins to asynchronously upload the pictures two at a time, placing additional pictures that you drag in on a queue. This is something within the realm of my family understanding.

The clear advantage of these components is that they are simple to use, and work through your web browser, however, they are a pain to install as shown below.

ActiveX installer

Java applets seem to be the most violent to work with, though they offer the best packages such as radlinks or JavaAtWork. However, I have experimented with both of these packages, and the bottom line is that too many antivirus / malware protection programs disable Java / ActiveX, and ultimately I do not want to have to explain how to use the advanced window under internet explorer to fix these.

I believe this leaves me with writing a custom program, which our guests then download and run. Ultimately, this is making an easy to use – pre programmed – FTP window.

I would love it if I could do this through Flash, but I have yet to see a solution to this problem. I realize sites like box.net seem to have solved the problem, but I believe they too use an active X control.

Let me know if you know of a way around this, or are aware of a better solution, otherwise part II of this article will cover the development of this application.

In any case, this spurred a lot of research on my part. Up until now I had been investing in the best discount broker available, scottrade, and as a software engineer, the first thing I did was to write an html parsing interface to scottrade to allow my soon to be automated framework to make buy and sell orders. It wasn’t long before I did my research on the difference between a direct access broker and a brokerage firm. The former allowing me to place direct orders with an exchange, and the latter attempting to take a piece of my cake by being a market maker. My research immediately led me to Interactive Brokers, which offers an API (what you say? No HTML parsing to interface?), as well as much lower fees (we’re talking half a penny per share baby!). Later I learned that they do not offer the best margin rates, nor do they offer the highest leverage… but lets just say for my level of sophistication, they are perfect.

After establishing my new brokerage account, I needed to test the waters. I developed an incredibly simple trading infrastructure in C# using the interface provided in http://finance.groups.yahoo.com/group/twsapi/. This first cut interface simply parsed news events at the fastest possible speed, allowing my application to track it, and rapidly trade on it. As you can see from the chart below, there was some news event at 12:00. If the news event was detected at 12:00:10, one could make a tidy profit simply by going long early, and selling at around 12:04 with a stop at 43.55, this would represent a profit of 45 cents/share at a risk of 15 cents/share, or a nice 3R.

I implemented this strategy and ran for two months before trading live. It worked flawlessly, I back tested it on old news releases for about two years, and there was not a single case where the momentum did not follow the news. Then I turned it on last July, and got one good month of running, and come August it started out alright, right before the bull came. Then it hit (possibly like triceratops butting heads), the uptrend in all of the stocks I was following was proceeded by erratic trading behavior. Momentum on the in the news stocks was no longer carrying. After a news release I may see a large down tick followed be an instant up tick, so fast that I could not liquidate and close positions in time to make money. Clearly my strategy had to change. I shutdown my strategy in September, and went to work on version 2.0 of my ATS. (Part II to follow…)