Over the past 10 years new opportunities have opened in the stock, futures and currency markets to allow retail traders the ability to produce their own automated trading strategies which was once only the realm of hedge funds and investment banks. Interactive Brokers was one of the first brokerage firms to offer a Java API to its retail customers. Originally envisioned as way for developers to augment Interactive Brokers Trader Workstation (TWS) desktop application with features such as charting or record keeping, the API has gained popularity as a way to automate trading strategies.
In my first iteration of developing a trading strategy and software to automate the trades I built a Java desktop application using Swing components which would monitor stocks throughout the day and place trades when certain parameters were met, and then exit the trades at the close of the trading day. The software worked well, and it was adequate for the strategy it was designed to trade, however it was not extensible and attempting to implement new trading strategies to automate as well as connect to different brokerage accounts proved difficult and cumbersome. Also, there are restrictions on how many stocks could be monitored via the broker’s data feed so the software had to be able to accommodate real-time market data feeds from other sources in addition to the broker’s data feed.
I was introduced to the Netbeans Rich Client Platform (RCP) a couple of years ago and have recently decided to begin porting my application to the platform due to a large number of advantages that it provides. The Netbeans RCP is built on a modular design principle allowing the developer to define abstract APIs for features and then provide modules which may have different implementations of the API, allowing the application to select at runtime which implementation to use. Not only does it provide for a cleaner design by separating concerns, but by using the Netbeans Lookup API it also decouples the application and its various components from each other. There are numerous other features that can be leveraged including a built-in windowing system, text editor, file explorer, toolbar, table and tree table components as well the Action API (just to name a few).
The trading application will make use of the RCP module system to define abstract APIs with the following functionality:
- Place and cancel orders for stocks, options, futures, or currencies
- Provide event notification when orders are filled
- Monitor cash balances in the account
Market Data API
- Subscribe to real-time quote data for any ticker symbol
- Subscribe to Level 2 data (market depth/order-book) for any ticker symbol
Historical Data API
- Request historical price data for any ticker symbol
Trading Strategy API
- Define a set of rules for entering and exiting trades
- Ability to use any broker, market data, and historical data API implementations in order to make trading decisions.
The primary implementation for the Broker, Market Data and Historical data API modules will be utilizing Interactive Broker’s Java API, but other implementations can also be created as Netbeans modules and then imported into the trading application so that trading strategies can make use of market data from different sources if needed.
New trading strategies can be built as Netbeans modules implementing the Trading Strategy API, where each strategy can make use of one of the implementations of the various data and broker APIs. Utilizing the Netbeans Lookup API, strategies can query the platform to get a list of all implementations of the broker and market data APIs providing for loose coupling between the APIs and allowing the user to select which implementation to use at runtime.
Below is a diagram illustrating the organization of the various API components of the application:
In future posts I will go into more detail on how to create an API plug-in for the Netbeans RCP as well as show how to create a concrete implementation of the API. In the illustration above the abstract broker, market data, and trading strategy APIs are installed into the RCP as plug-ins. The broker API has a single implementation for Interactive Brokers at this point in time. The market data API has plug-ins which provide implementations for real-time market data from Yahoo Finance as well as Interactive Brokers real-time market data. Finally, the trading strategy API has 2 implementations in this example. The first strategy named “Limit Buyer” will watch the prices of approx 800 stocks and place limit order to buy when certain conditions are met. The second strategy in the example above, named AUD/NZD Currency Strategy will monitor the exchange rates of the Australian and New Zealand dollars and place orders to buy or sell when certain conditions are met.
At this point in time the application is functional and is utilizing Interactive Brokers as the main brokerage as well as market data provider. The AUD/NZD trading strategy is actively being traded through the application, albeit with a rudimentary user interface which is publishing messages to a text area within the strategy’s main tab. The screenshot below illustrates Interactive Brokers “Trader Workstation” application, the large black application (which is a Java Swing app), as well as the Netbeans RCP automated trading application which is the small white application, with the large text area. In the screenshot below the application is currently monitoring prices and placing trades for the Australian Dollar, New Zealand dollar, Hong Kong dollar and Japanese yen currencies.
This post is just a high level overview on the design of an RCP application to trade in the financial markets. Future parts to this series will include more information on how to implement abstract APIs and make them available for other portions of the application to use via the Netbeans Lookup API as well as working with some of the Netbeans UI components included with the platform such as tabs, trees and tables, showing how easy it is to render the same data via these different views using the Netbeans Nodes API. In addition to this I would like to incorporate some JavaFX components into the application such as the charting components that can be found in the core JavaFX library which will provide a graphical representation of some of the data the strategies are monitoring which will be a bit more user friendly than the current large text area. The integration of JavaFX components within the application will be documented in a future post as well.
You can follow my trading related blog if you would like to see the actual trading results of the application as its being refined at:
8 thoughts on “Designing an Automated Trading Application on the Netbeans Rich Client Platform (Part 1)”
HI Rob ! I must say that I’m stunned by visual impact of your application !
This is exactly what I’m looking for, for projects I work on – especially mozilla-like-theme (this black background) and if I see well, a timeline-like component.
Can you please direct me, where I can find more tutorials and components to “arm” my app with them ?
All best ! Thanks in advance !!!
The application with the dark background is actually Trader Workstation which is a product of Interactive Brokers. It is a Java app using swing components, although I don’t think they are using the Netbeans RCP as the framework. The app that I was working on was the small app pictured in front of it, with a tree component on the left side, and a large text area in the center.
I’m a software developer like you, have been trading and developing software tools for financial markets. Here is one of my tools – might be helpful for getting historical data from Interactive Brokers. I developed my own framework around IB Java API to allow automatic handling of pacing violations, etc…: http://www.tradinggeeks.net/downloads/ib-data-downloader/
Oleg, do you provide an API for your framework? I could potentially make use of this in my automated trading application, but the app would need to be able to access the data via an API and not a GUI.
I stumbled upon on your post when reading about Netbeans Platform and found this article quite interesting. I currently work on a proprietary swing/swt based real time trading application and was interested in looking at porting of the application to netbeans rcp ..but couldn’t find an update to this series ‘Designing an Automated Trading Application on the Netbeans Rich Client Platform’.
shortly after writing that post we received a capital allocation from commodity fund and the priorities of what software we needed changed, so I have not yet completed this.
However I have developed 2 other applications, using the same architecture, minus the Strategy API.
A FIX trading client:
and an application to monitor our positions and provide alerts:
I do hope to return to the automated trading app sometime next year as I have a number of different strategy ideas that I would like to test and implement.
Is the Swing/SWT app that you are working on based on the Eclipse platform, or are you using a homegrown framework?
Are you looking to port your components over to JavaFX or will you be sticking with Swing?
The Trading application is based on Eclpse RCP ..but the blotters are Swing Tables embedded using SWT AWT Bridge. As a POC we plan to port to Netbeans RCP with Swing GUI. We did try taking Javafx for a spin..but found the perfomance not upto to the mark when handling large Tables/Data.
I’ve heard the same as well regarding the tables. I ended up rolling my own table component using a GridLayout, but it was to give me finer control over the formatting of the rows, which is a similar approach to what Celer Technologies did with the JavaFX trading app that they developed.