JSystemTrader

La revolución ha llegado. Sabíamos que tarde o temprano sucedería: la filosofía GNU ha entrado con fuerza en el trading automático. El sueño de Leonardo por fin se hace realidad.

Y es que parece que por fin tenemos la herramienta definitiva: JSystemTrader es un programa escrito en Java que nos permite romper las cadenas que nos atan frente al monitor en nuestro trading diario, automatizando estrategias con la TWS de Interactive Brokers. Para ir abriendo boca les adelanto algunas características del programa:

Automatización de varias estrategias de forma simultánea, mostrando en tiempo real beneficio/pérdida, profit factor y máximo drawdown.
Descarga de históricos completos (resolución máxima de 1 min.) desde la base de datos de Interactive Brokers.
Realización de backtesting de estrategias sobre los históricos descargados.

Y, aunque no lo crean, todo esto es gratuito bajo licencia GNU y con el código abierto para que podamos incorporar nuestros propios indicadores y estrategias. Es decir, esto supone que cualquiera desde su casa puede trabajar con sistemas automáticos utilizando una sola aplicación gratuita que para colmo funciona a las mil maravillas (la he tenido 8 horas diarias lanzando órdenes continuamente y no ha dado ni un sólo fallo).

Eso sí, hacer la revolución supone también recorrer un duro camino en el que no nos quedará más remedio que aprender algunos fundamentos de programación en Java. Aunque creanme si les digo que sólo tengo algunos conocimientos de programación básicos y he podido ya modificar algunas características del programa sin saber Java prácticamente. Y es que su autor, Eugene (apodado Nonlinear en los Foros de EliteTrader e IB) ha desarrollado una aplicación realmente versátil y cuyo código está muy bien estructurado.

Pero empecemos por el principio…

1. ¿Qué vamos a necesitar?
Antes de empezar a trabajar con JSystemTrader, necesitaremos lo siguiente:

La última versión del Java Development Kit (JDK), que podéis encontrar en https://www.oracle.com/java/technologies/downloads/.
Eclipse, entorno de desarrollo integrado para Java disponible en http://www.eclipse.org/downloads/
Y por supuesto el propio JSystemTrader, disponible en https://github.com/memarc/jsystemtrader

Una vez descargadas todas las aplicaciones, haremos lo siguiente:

Eliminamos cualquier versión de Java que haya en nuestro ordenador e instalamos el JDK.
Descomprimimos Eclipse (por ejemplo, en C:\)
Descomprimimos JSystemTrader en una carpeta que, para poder seguir el ejemplo, llamaremos C:\JSTWorkspace.

2. Compilando el proyecto
Reconozco mi total desconocimiento de Java (tan sólo algunos rudimentos básicos) así que cuando llegó la hora de compilar el programa para poder ejecutarlo estaba más perdido que una aguja en un pajar ;-). Los pasos a seguir serían más o menos los siguientes:

Ejecutamos el archivo eclipse.exe dentro de la carpeta donde hayamos descomprimido el Eclipse. Nos pedirá una carpeta para crear un nuevo workspace; indicamos la carpeta donde descomprimimos el JSystemTrader, esto es, C:\JSTWorkspace.
Creamos un nuevo proyecto en Eclipse. Para ello vamos a File->New->Project… Seleccionamos Java Project y le damos a Next.
En la siguiente ventana que nos aparece marcamos C reate New Project in Workspace y Use a Project Specific JRE, seleccionando jre1.6.0. Finalmente escribimos el nombre del proyecto en la celda superior, poniendo JSystemTrader (fijaos que este nombre coincide con el de la subcarpeta que se crea al descomprimir el JSystemTrader en la carpeta JSTWorkspace).
Una vez terminado el proceso le damos a Finish. Automáticamente aparecerá el proyecto que hemos creado en pantalla con un aviso diciendo que hay, más o menos, unos 100 errores y unos 40 avisos. Esto se debe a que debemos incorporar en el proyecto dos archivos JAR que vienen con la TWS. Para ello, debemos abrir una ventana del Explorador de Windows, dejando a la vista la de Eclipse, ir a la carpeta que contiene la TWS (generalmente C:\Jts) y seleccionar dos archivos: jcommon-1.0.0.jar y jfreechart-1.0.0.jar. Después simplemente los arrastramos a la ventana de Eclipse y los soltamos en la carpeta ‘lib’ que cuelga del proyecto JSystemTrader.
Ya casi lo tenemos: vamos al menu Project->Properties. Ahí seleccionamos en el cuadro de la izquierda Java Build Path y después en la ventana de la derecha la pestaña Libraries. Dentro de esta pestaña veremos un botón que pone Add JARs… Hacemos click en él, seleccionamos las dos librerias que acabamos de pasar desde la carpeta de la TWS y le damos a OK. Ahora cuando volvamos a la ventana del proyecto los errores del proyecto deberían haber desaparecido.
Finalmente vamos a configurar las opciones para ejecutar el proyecto: seleccionamos el menu Run->Run… En el cuadro de la izquierda seleccionamos Java Application; seguidamente pulsamos el botón New (que aparece arriba a la izquierda con un simbolo +). Nos aparece un nuevo cuadro con varias pestañas. En la pestaña Main escribiremos JSystemTrader en la celda Project y en la celda Main Class le daremos al botón Search para seleccionar la clase JSystemTrader – com.jsystemtrader.client. Le damos a OK y en la pestaña Main pulsamos en el botón Apply.
Seguidamente pasamos a la pestaña (X)=Arguments y en la celda que pone Program Arguments pondremos la carpeta que contiene el JSystemTrader (en nuestro ejemplo, C:\JSTWorkspace\JSystemTrader).
A continuación hay que pinchar en la pestaña Classpath, seleccionar en el arbol User Entries, pulsamos en el botón Advanced, marcar Add Folders, darle a OK, seleccionar JSystemTrader y darle a OK. Después, si no os aparece la entrada JSystemTrader – \ la primera de User Entries debereis subirla seleccionandola y dandole a Up hasta que aparezca la primera.
Pulsamos nuevamente el botón Apply y finalmente le damos a Run.

Si han seguido estas instrucciones al pie de la letra, debería aparecerles una pantalla como ésta:

Una vez realizado todo este proceso, ya no es necesario repetirlo para poder ejecutar JSystemTrader. Simplemente bastará con abrir Eclipse, aceptar al inicio que deseamos trabajar con el proyecto contenido en C:\JSTWorkspace y después pulsar directamente en el botón Run (círculo verde con una flecha blanca en su interior). Otra posibilidad es generar un JAR distribuible para no tener que andar dependiendo de Eclipse pero aún no he sido capaz de conseguirlo (ayuda siempre bienvenida).

3. La hora de la revolución
Con JSystemTrader podemos hacer, fundamentalmente, tres cosas:

Descargar bases de datos de IB
Hacer backtest de una estrategia predefinida sobre esos datos (ojo, el programa no optimiza, los parámetros se los tenemos que dar fijos)
Automatizar por completo la estrategia que hayamos creado.

Veamos cada uno de estos aspectos, si bien antes de ponernos manos a la obra conviene tener en cuenta que:

Antes de abrir la TWS debemos sincronizar el reloj de nuestro ordenador con algún servidor de Internet o instalar alguna aplicación que lo realice de forma automática (Atomic Clock Sync es una buena opción aunque hay muchas). JSystemTrader exige que el reloj del PC y el de la TWS estén sincronizados (como mucho admite 1-2 seg. de diferencia) para poder funcionar correctamente.
Es recomendable hacer las primeras pruebas con la demo que Interactive Brokers da a sus clientes para hacer pruebas de simulación.

Ahora sí, vamos allá:

3.1. Descarga de bases de datos
Una vez sincronizado el reloj del ordenador, abrimos la TWS con nuestro usuario demo y lanzamos JSystemTrader. Ni que decir tiene que antes de hacer nada tenemos que marcar «Enable ActiveX and Socket Clients» y «Enable DDE Clients» dentro del menu Configure->API de la TWS.

Vamos a bajarnos nuestra primera base de datos: para ello, lo primero será conectarnos con la TWS desde el menu File->Connect to TWS (si no les conecta, no se desesperen, cuesta un poco coger el tranquillo a la sincronización de los relojes; cierre la TWS y el JSystemTrader, sincronice el reloj de nuevo y vuelva a abrirlos).

Una vez conectados a la TWS, le damos a File->Back Data. Les aparecerá una pantalla similar a ésta:

Si ponen las opciones tal y como aparecen en la imagen y le dan a Download, el programa descargará el histórico en barras de 5 min. del vencimiento de Marzo de 2007 del mini Dow Jones (sólo horario regular).

3.2. Backtest de Estrategias
JSystemTrader ya viene con algunas estrategias de serie así como algunos indicadores, aunque podemos añadir los nuestros (veremos cómo en un próximo artículo). Si cerramos y abrimos el JSystemTrader, podremos hacer backtest sobre los datos del mini Dow Jones que acabamos de descargar. Para ello vamos a File-> Back Test. Configuramos los datos tal y como se muestra en la siguiente pantalla y le damos a OK.

Una vez leido el fichero de datos, nos devolverá un mensaje confirmando que se ha realizado correctamente.

Ahora vamos al menu Trading->Strategies y veremos un listado de varias estrategias. Podemos coger por ejemplo la LoadTest y darle a Start Trading. En ese momento simulará todas las operaciones que habría dado la estrategia utilizando los datos del mini Dow Jones. Cuando haya terminado podemos hacer doble click sobre la estrategia y nos dará la siguiente información:

% Operaciones Ganadoras, Profit Factor y Máx Drawdown.
Pulsando en Aceptar nos dará un gráfico mostrando todas las operaciones (la estrategia LoadTest lanza una orden en cada barra así que no le den muchas vueltas ;-)):

3.3. Automatizar estrategias
El plato fuerte de este programa es sin duda la automatización de estrategias. Para ello, vamos a modificar una de las estrategias que vienen con el programa. Con el proyecto abierto en Eclipse vamos a desplegar la carpeta Source y seguidamente desplegamos la clase com.jsystemtrader.strategy, tal y como se aprecia en la imagen.

Después seleccionamos el archivo ForexTrend.java, le damos con el boton derecho, seleccionamos Copy y después nuevamente con el botón derecho le damos a Paste. Nos preguntará el nombre que queremos ponerle; para este ejemplo vamos a llamarlo CruceMediasXTrader. Con ello hemos creado un duplicado de una de las estrategias para modificarla tranquilamente.

Ahora abrimos el nuevo archivo y buscamos la siguiente línea:

private final int maFastLength = 45, maSlowLength = 180;

Dado que el sistema ForexTrend es un simple cruce de medias exponenciales, en esta línea parece evidente (sin saber nada de Java) que lo que se declara son los periodos de las dos medias móviles del sistema. Para poder generar bastantes señales, cambiamos la sentencia a lo siguiente:

private final int maFastLength = 4, maSlowLength = 9;

Bajando un poco más encontraremos dos líneas como éstas:

Contract contract = ContractFactory.makeContract(«EUR», «CASH», «IDEALPRO», null, «USD»);
setStrategy(contract, PriceBar.BAR_1_MINUTE, false, 25000);

La primera línea controla el producto sobre el que vamos a operar mientras que la segunda especifica el minutaje y el número de contratos a introducir en cada operación. Tal y como está ahora mismo lanzará órdenes de 25000$ en el cruce EUR/USD negociado en IdealPro pero nos gustaría que lanzara las órdenes al DAX así que vamos a cambiar algunos parámetros, reemplazando esas líneas por lo siguiente:

Contract contract = ContractFactory.makeContract(«DAX», «FUT», «DTB», «200703», null);
setStrategy(contract, PriceBar.BAR_1_MINUTE, false, 1);

Es decir, vamos a lanzar órdenes a partir de un cruce de medias exponenciales de 4 y 9 periodos en futuro sobre DAX vencimiento Marzo de 2007 trabajando con barras de 1 minuto y operando con un contrato.

Finalmente debemos indicar el horario de la operativa. Para ello modificaremos la siguiente línea:

addTradingInterval(«1:00», «23:50», 5); // trades about 23 hours/day

En ella se indica que el sistema opere entre la 1.00 y las 23.50 h., cerrando posiciones a las 23.50 h. y no abriendo nuevas posiciones en los últimos 5 minutos de ese intervalo.

Para operar en un horario más realista cambiamos esa línea de la siguiente forma:

addTradingInterval(«9:00», «17:30», 5);

Finalizadas las modificaciones, lo guardamos desde File->Save y seguidamente incorporamos esta nueva estrategia al proyecto mediante el menu Project->Build All.

Ahora empieza lo realmente interesante: lanzamos nuevamente el JSystemTrader mediante el botón Run, conectamos con la TWS (File->Connect to TWS) y cargamos la estrategia que acabamos de crear, desde Trading->Strategies… Si todo ha ido bien, ahi debe aparecer un sistema llamado CruceMediasXTrader aplicado al DAX en 1 min. Lo marcamos y pulsamos en Start Trading.

En ese momento JSystemTrader se descarga el histórico reciente del DAX para hacer los cálculos pertinentes y en el momento que pase el primer minuto, el programa decidirá en qué posición deberíamos estar y lanzará la orden. Una vez tengamos algunas órdenes ejecutadas, podemos hacer doble click sobre la estrategia para que nos muestre, en tiempo real:

% Operaciones Ganadoras, Profit Factor y Máx Drawdown.
Pulsando en Aceptar nos dará un gráfico con todas las operaciones ejecutadas hasta el momento, con las medias móviles insertadas.

Y lo mejor de todo es que si en algún momento se desconecta la TWS, el programa intentará conectar de nuevo y en el momento que lo consiga le solicitará información de las últimas ejecuciones realizadas para no perder la posición en la que estaba. Simplemente brillante.

En definitiva, creo que JSystemTrader es posiblemente una de las mejores aplicaciones para automatizar nuestra operativa y que en los próximos meses dará mucho que hablar.

No quisiera terminar este artículo sin enumerar otras alternativas también gratuitas que prometen bastante aunque por ahora no sean tan potentes como JSystemTrader: