Takion Technologies, LLC.

Takion API
Documentation
A Starters Guide

8/1/2015
Table of Contents
The Takion Software Environment ............................................................................................................... 3
Hardware Considerations ............................................................................................................................. 3
Installing the Takion Application................................................................................................................... 3
Install Walk-through ................................................................................................................................. 3
VPN Description ........................................................................................................................................ 7
VPN Requirement ..................................................................................................................................... 7
VPN Settings .............................................................................................................................................. 8
VPN timeout .......................................................................................................................................... 9
VPN Troubleshooting ................................................................................................................................ 9
Takion Application (Graphical User Interface) ............................................................................................ 10
Takion API ................................................................................................................................................... 12
Description .............................................................................................................................................. 12
Obtaining the API files ............................................................................................................................ 12
Required Development Software ........................................................................................................... 12
Setting up the API Project ....................................................................................................................... 14
Project Settings ....................................................................................................................................... 16
Required API files .................................................................................................................................... 16
Required File Definitions ..................................................................................................................... 16
Compiling API Code ................................................................................................................................. 17
Getting your compiled DLL to work with the Takion Application ....................................................... 18
Debugging ........................................................................................................................................... 22
Debugging Restrictions ....................................................................................................................... 23
Observer Pattern..................................................................................................................................... 24
Observable .......................................................................................................................................... 24
Observer.............................................................................................................................................. 24
Messaging ........................................................................................................................................... 27
Circuit Breaker Information .................................................................................................................... 28
Hard To Borrow Securities ...................................................................................................................... 29
Threading Information ............................................................................................................................ 30
Locking ................................................................................................................................................ 30
Non-Security locking ........................................................................................................................... 31

Page 1 of 35
 Locking API Functions: ........................................................................................................................ 32
API FAQ ................................................................................................................................................... 32
Appendix A .................................................................................................................................................. 33
Takion Software ...................................................................................................................................... 33
Bug fixes in current version (or a link to the location of such a document) ....................................... 33
List of previously available versions .................................................................................................... 33
Version of MS Visual Studio that is required ...................................................................................... 33
Appendix B .................................................................................................................................................. 34
References .............................................................................................................................................. 34
List of useful links ................................................................................................................................ 34
List of useful External References ....................................................................................................... 34
General FAQs .......................................................................................................................................... 35

Page 2 of 35
Getting Started
The Takion Software Environment
The Takion trading platform is built for a Microsoft windows-based environment using the Microsoft C++
development language. Conceptually, there are two main divisions to the software – the main Takion
application and the Takion API. Like the Takion application, the API is also built upon Microsoft C++.

The Takion application is installed on the machine that users (traders) will use to trade. It creates a
desktop shortcut and can be used to trade the markets in its original, unaltered state. The API, in
contrast, is not a stand-alone application. Instead the API is ultimately an extension of the main Takion
application. It is not installed, but rather, it is associated with and accessed through the main Takion
application.

Hardware Considerations
Trading in the stock market is a very CPU intensive operation, as it must handle asynchronous
communication to and from the trading servers and ultimately the market. Given the architectural
design of the Takion trading application, it is greatly advantageous to have a trading machine with as
many CPUs or CPU ‘cores’ as possible. This permits a quicker response by evenly spreading the workload
of the queues of messages received from and passed to the market.

Additionally, as with any resource intensive software, the Takion application requires ample RAM and
network bandwidth resources too.

Installing the Takion Application

The Takion application is necessary to trade manually and to run the API code for algorithmic trading.
Keep in mind that there is software for several different CPU types (register sizes), such as 32-bit and 64-
bit. Matching the right Takion application software version to your machine will make it faster.

Install Walk-through
First, double click on the .msi file of the correct software version to start the install wizard.

Depending on your operating system (OS), you may get a warning such as this:

Page 3 of 35
If so, click the run button to kick off the install process.

At this screen, click “next”:

Page 4 of 35
At the screen below, type in the preferred path:

Click the ‘Install’ button, next:

Page 5 of 35
As the install program works on necessary configuration information specific to your machine, you will
likely see a screen that looks like this:

After a few moments, when it is done installing the main Takion application, the wizard provides the
option to install the VPN software. VPNs and their requirements are details in the subsequent section.

Page 6 of 35
If you keep the ‘Launch Cisco VPN installer, it will guide you through the install of a local Cisco VPN client
software.

VPN Description
A VPN is a Virtual Private Network (VPN) that encrypts all traffic sent to and from a specific server to
which a VPN client is connected. In this case, all traffic specific to the Takion application will be
encrypted when passing between Takion and the connecting computer running the VPN software.
Traffic that is not specific to the Takion application (or API), such as web browsing or a local email client,
is sent through the normal routes.

VPN Requirement
In order to permit the Takion application installed on a computer to communicate with the servers at
Takion, a Virtual Private Network (VPN) connection is required. Although there are many VPN clients
that will work to connect to the servers at Takion, one is also available on the Takion FTP site. There you
will find a copy of the Cisco VPN client version 5.0.07.0440. Look for the appropriate file at the bottom
of the listing where all the VPN install files for various platforms and configurations are located.

Please note that it is possible to use a different VPN client. However, it must be capable of IPsec.

Page 7 of 35
VPN Settings
If using the abovementioned Cisco client, once installed, the VPN client will usually appear in your start
menu, or other common areas and dashboards, depending on the operating system you are using.

When the Cisco application is started, it should look something like this:

To add the Takion specific connection information, click the ‘New’ button, then fill out the fields with
the information that you received from your Takion contact. While this is a demo account, your
connection settings should be similar to the example below:

Page 8 of 35
VPN timeout
In general, if the Takion servers to which you connect with the VPN detect 30 minutes of inactivity
across the connection, the servers will automatically disconnect you. During trading hours if you are
running the Takion application, most likely there will be enough traffic across the VPN that a window of
30 minutes with no activity will not occur.

VPN Troubleshooting
1. Despite putting in the correct information, it still does not seem to connect.
Ensure that you have Internet connectivity from the machine you are using. Also, make sure that
your machine is receiving proper DNS information. A great place to start is with your Internet
Service Provider (ISP).
2. When I have the VPN connected, I cannot seem to open a browser and look at web site
locally. Is there a setting to fix this?
When logging on to a VPN, the client machine assumes another IP address, which makes it a
member of another network (by address only – not usually windows network domain
information). In some instances, this new network claims all default traffic – that is to say, all
traffic is attempted to be routed through the VPN. Most VPN software will have a setting that
permits routing only certain traffic, such as web browsing, etc., through the usual default
(machine local) gateway instead of going through the VPN. Check for such a setting.
3. Unable to resolve server address?

Page 9 of 35
 Ensure that either your host information is configured properly. In this case it should be
vpn.Takiontechnologies.com:

4. The VPN tries to connect, but after a few seconds the status bar at the bottom says ‘not
connected’.
Make sure your user name and password are correct. One way to see for sure is to look at the
VPN’s log of activity. It may contain a few hints on what caused cause of the failure.

Takion Application (Graphical User Interface)

Having installed the application on the desired machine, with your trading account information, you
have what you need to get started trading. Double-click on the Takion icon on the desktop or in the start
menu to launch the application.

(Takion desktop icon – against a blue desktop background)

The log in screen looks like this:

Log in using the credentials you received from your contact at Takion, and the GUI will appear. Be sure
to have your VPN connected first, though.

Page 10 of 35
To make the Takion application meet all the functionality customers need, it has a degree of features,
capabilities and thus complexity that most users will want a comprehensive reference full of helpful
hints and tips. Addressing all these features is beyond the scope of this document. There is additional
documentation available from to address the Takion application GUI, specifically. If interested, please
contact your Takion representative for more information.

Page 11 of 35
Takion API

Description
The Takion API is a compiled Dynamic Link Library (DLL) that operates as an extension to the Takion
application (detailed in the previous pages). It contains algorithmic logic to watch, make trading
decisions about and actively trade securities. All API code is interpreted on the client machine running
the Takion application; no proprietary code is sent to Takion.

Obtaining the API files

With the username and password you obtained from your primary Takion contact, navigate to the
Takion FTP site and locate the most recent copy of the Takion API.

On the ftp site, the Takion API directories are named using the version of the file and compressed into
individual zip files before upload. For example, the zipped file: TakionApi_1_0_2_105.zip contains
version 1.0.2.105. The names contain no reference to date of development. However, there is a last
modified date column that reveals the date it was uploaded.

FTP Directory example:

Once you have determined the version you want, download the file to a local directory on your
machine, and then extract it. You will need to assemble the resulting files into a project for compilation
into a Dynamic Link Library (DLL) to get the API to operate correctly.

Required Development Software

Takion uses the Microsoft development platform - Visual Studio 2010 (VS2010) to build the API using the
language C++. More specifically, VS2010 needs to be patched to service pack (SP) I. To check this, with

Page 12 of 35
VS2010 open, click the Help menu and then click ‘About Microsoft Visual Studio’, at the bottom of the
Help menu. The resulting screen will tell you if you are running the patched version or not.

Example of a suitably patched copy of VS2010:

Page 13 of 35
The latest service packs and patches can be obtained by running Windows Update, and asking it to show
all updates, if nothing appears. Alternatively, it can be downloaded from Microsoft.

Setting up the API Project

Takion supplies an example API application that serves as a quick way to start coding your own trading
algorithms. You can find the most recent copy of this starter application on the FTP site. As of this
writing, it appears like this:

Once unzipped, there will be a directory called Extension. In the resulting extension directory are the
files for two projects combined into a single Visual Studio solution. Find the Extension.sln file, and
double-click it. It should open in Visual Studio.

While the project is opening, you will encounter a message or two about the solution being part of a
software versioning repository. If encountered, feel free to check the box indicating that you don’t want
to see that message any more, and on a subsequent pop-up message, choose the option to remove the
versioning bindings associated with this software, as illustrated below:

Once you have the solution loaded, your Solution Explorer will look something like this:

Page 14 of 35
In the project named Extension Sample, there are a large number of files already. In this project are a
number of dialog-related and support files. For example, in the source files folder, among others, the
following files can be found:

• BaseDialogSettingAccount.cpp
• …[scroll down]…
• ConfigEnums.h
• …[scroll down]…
• MainDialog.h
• …[scroll down]…
• SampleDialogSettingSimulateQuote.cpp
• …[scroll down]…
• stdafx.cpp
• …[scroll down]…
• targetver.h

As of this writing, there are around 100 files in this directory. Not all of these files will be necessary for
core algorithm development but are there to facilitate development options such as dialog boxes.
Leaving them in place will not harm nor interfere with the operation of the resulting DLL.

Page 15 of 35
Project Settings
Besides the right project files, it is also necessary to ensure that your project settings are correct. One
such setting is the project type.

Below is an example of the default project settings (properties) within VS2010 for both projects in the
solution named Extension.

Required API files

If using the ExtensionSample project to jump start trading application development, all of the necessary
files have been included in the zipped file on the Takion FTP site. But in the event that a developer
references this document having built the project straight from the downloadable API files, this section
assists in pointing out exactly which files are required to get the resulting DLL recognized and operating
properly when loaded into the Takion application.

In order to produce a functional trading application, you need the Takion API files, mentioned previously
above, and a few other files are required.

Required File Definitions

Since this is written in VS C++, a .def file is included to indicate which functions get exported. As such,
<ProjectName>.def should be included; in the case of the ExtensionSample project, this means the file
ExtensionSample.def needs to exist in the project. It is included in the downloadable zip file, and has a
few important functions listed for export.

In order to specify the version number in the resource file, this will require the files <ProjectName>.rc
(ExtensionSample.rc) and Resource.h.

Page 16 of 35
Finally, <ProjectName>.h (ExtensionSample.h) and <ProjectName>.cpp (ExtensionSample.cpp) are the
main files that will hold the functions that perform the primary algorithm code.

A quick summary of these required files and their purpose is below.

Files Purpose
ExtensionSample.h The header file for the functions that contain the primary
algorithm code for the API.
ExtensionSample.cpp The file containing the logic for the algorithms being
developed with the API.
ExtensionSample.def Meta data for permitting the API DLL to be accessible to the
Takion application.
ExtensionSample.rc Permits the version number to be set
Resource.h Meta data file generated by Visual Studio /
Permits the version number to be set
stdafx.h Meta data file generated by Visual Studio (facilities
compilation)
stdafx.cpp Meta data file generated by Visual Studio (facilities
compilation)
targetver.h Meta data file generated by Visual Studio
<Takion API Files> Takion provided base files for building a trading application

Compiling API Code

Once all the proper files are in place, the project should compile successfully. Using the ExtensionSample
project, the following directory structure will be present after compilation:

This is a menu view of the resulting directory structure:

Page 17 of 35
This debug directory should contain these files:

Here one can find the DLL that needs to be provided to the Takion application to implement functional
API code.

Looking at other resulting files from the compilation, note also the Win32 directory that appears:

This is a necessary set of files that are referenced by the API DLL and should not be removed or deleted.

Getting your compiled DLL to work with the Takion Application

The DLL you created is not a complete application by itself; it relies on the Takion application software
to function properly. In order to do this, the DLL must be imported into the local application. The
developed algorithm DLL therefore stays local on your machine.

To associate your API DLL with the Takion application, follow these steps:

Create an extension window (right-click on the main bar and choose ‘New Extension’). See illustration
below.

Page 18 of 35
Next, right-click on the created Extension window and choose ‘Add’:

Page 19 of 35
If the DLL is successfully loaded then a line will appear in the Extension window with some info about
the DLL, like this:

There are two steps to follow if you would like your API code to load when the application starts up.
First, in the extension box, right-click on the line and choose Selected then Make Auto on the sub-
window:

Page 20 of 35
Next, there is a check box "Load Custom Extensions" in the Takion application's Logon dialog that must
be checked for the DLL to auto load:

Page 21 of 35
Debugging
When developing an algorithm, it is helpful to be able to step-through and debug the code. Since the API
is a DLL, and thus not a stand-alone application, debugging requires access to source code versions of
the Takion application. For this purpose, ‘debug’ versions of the Takion application are available on the
FTP site.

There are two copies available for each version – 32-bit and 64-bit (see the restrictions immediately
below). After loading the appropriate version of the Takion debug software, one can then use
breakpoints to step-through associated debug version of API code.

Page 22 of 35
Debugging Restrictions
Please be aware that you should load into Takion only the extensions that are compiled with the API of
the same version as the Takion application that you are running.

Additionally, be sure to avoid cross build loading. For example:

• The debug 64-bit DLL loads only into the debug 64-bit Takion application
• The debug 32-bit DLL loads only into debug 32-bit Takion application
• The release 64-bit DLL loads only into release 64-bit Takion application
• The release 32-bit DLL loads only into release 32-bit Takion application

Page 23 of 35
Observer Pattern
For various reasons, the API is designed to function in the Observer pattern. There are three main parts
to this pattern – the observer, the observable item (object) and the communication through messages.

Observable
The observable object can be a security, such as Apple, Inc. (AAPL), or an account, an order, or a position
object. These objects have properties, methods and will communicate through messages generated
from market activity, status, or state changes.

Observer
The observer is a class in the main API program that provides the ability to receive messages from
observable objects (see above). Using the provided pre-built start application and the example
algorithm in the ExtensionSample program, an observer object is created then told about a security to
‘follow’. Inside the observer, an observable with the desired symbol (eg. AAPL) is instantiated, then
followed by calling the method AddInThreadObserver(<observable>). By calling this method, the
instantiated observer will now receive all messages pertaining to the security AAPL, such as trade,
volume and price information.

To handle messages, the observer must implement the notify() method which has a signature definition
for receiving messages and from which observable it originated. Bear in mind that there are MANY
possible message and message types. It is a best practice to add a default clause to the switch statement
(see example below) to manage unhandled message types. Below is a stubbed-out general example of
what this might look like:

Page 24 of 35
void MyObserver::Notify(const Message* msg, const Observable* from, const Message* info)
{

switch (msg->m_type)
{
case <Some Message> :
{

//Handle the message as desired

break;

// Gracefully ignore any irrelevant / unrecognized messages

default : { }

}
}

For the sake of clarity, it is possible to overload the notify() method and dedicate certain notify()
methods to specific message types – especially if they are commonly received. See the example below:

void MyObserver::Notify(const Message* msg, const Observable* from, const Message* info)
{
switch (msg->m_type)
{
case M_TRADE_REPORT :
{
Notify((const TMsgTrade*)msg, from, info);
break;
}

default : { }
}

void MyObserver::Notify(const TMsgTrade* msg, const Observable* from, const Message*

info)
{
//only handle Trade Messages
}

Page 25 of 35
Since most algorithms want to react to market activity, a common practice is to place trading logic in the
notify() method (that handles trade messages) in the observer objects. A general example follows:

void MyObserver::Notify(const TMsgTrade* msg, const Observable* from, const Message*

info)
{
bool haveAPosition = false;
//write code to determine if we have a position ...

if(haveAPosition == false)
{

//Get prices for comparison:

Price curPrice = Price(msg->m_priceDollars, msg->m_priceFraction);
Price yesHighPrice = takSecurity->GetYesterdaysHighPrice();
Price yesLowPrice = takSecurity->GetYesterdaysLowPrice();
Price todaysHighPrice = takSecurity->GetHighPrice();
Price todaysLowPrice = takSecurity->GetLowPrice();

…
//<Code to Trade …>

Another best practice in this pattern is to dedicate one observer per security. Thus, when looping
through a list of securities to follow, be sure to instantiate one observer per security.

Dedicating an observer this way provides the functional clarity and separation.

Page 26 of 35
Messaging
When specific events or actions occur in the observable object, a message is generated and made
available to the observer. The observer must be aware of the potential messages and look for each one
individually, as stubbed out above. Unknown messages or, more specifically, messages that are not
specifically handled by the observer are discarded.

There are several types of messages, each of which contain information specific to its source. For
example, the messages from a Position will be different than the messages generated by the market
trade of a security.

In the above examples, the focus was on trade messages. The example referenced the message object
(msg) and used a property to get access to the last execution price. Taken from the example above:

//Get prices for comparison:

Price curPrice = Price(msg->m_priceDollars, msg->m_priceFraction);

Page 27 of 35
Circuit Breaker Information
In the event a security has a large enough price fluctuation, it may be subject to a circuit breaker
restriction. For example if a security’s price drops more than 10 percent from the previous day’s closing
price, it will incur a short sale restriction. In order to obtain circuit breaker information, you need to
initiate a request through the security object.

Below is an example of how to accomplish this:

Security* security = (initialize code goes here);

char circuitBreaker = security->GetRegSHOTestIndicator();

The following is a list of potential values that could be returned:

Character Source Indicates

Blank CTS Short sale restriction not in effect
A CTS Short sale restriction activated
C CTS Short sale restriction continued
D CTS Short sale restriction deactivated
E CTS Listed Stocks only
0 UTDF No Reg SHO Short Sale Price test Restriction
1 UTDF Reg SHO Short Sale Price test Restriction in effect
due to a price drop
2 UTDF Reg SHO Short Sale Price test Restriction remains
in effect

Next, by ‘listening for’ certain messages it is possible to determine if there are updated circuit breaker
states. However, one still needs to make a function call to get that state value. Below is a list of
messages that could indicate a change of Circuit Breaker state:

Message Type Where to Listen

TM_EQUITY_UPDATE MarketSorter securities Main Thread
TM_STOCK_UPDATE_LEVEL1 MarketData Securities Main Thread
M_MS_SHORT_SALE_INDICATORS Ms Securities Stock Thread
SM_MS_SHORT_SALE_INDICATORS Ms Securities Stock Thread
M_SHORT_SALE_INDICATORS Md Securities Stock Thread
SM_M_SHORT_SALE_INDICATORS Md Securities Stock Thread

Page 28 of 35
What follows is a code sample (continued from the previous example’s security instantiation code) to
call for getting the current Circuit Breaker state once the above message have been received:

security->GetRegSHOTestIndicator();

Hard To Borrow Securities

To obtain borrowing information about a security, the account’s clearing firm needs to be referenced in
a call asking for the state of a security’s borrowing details. The value of ‘Hard To Borrow’ (HTB) depends
on the Account in which you are trading.

Here’s a small code illustration:

Account* account = (initialize process);

//Note: use TD_GetCurrentAccount() or TD_FindAccount(accountId) or iterating through accounts or
//other

unsigned int ordinal = account->GetClearingFirmOrdinal();

unsigned char htb = isHTB(ordinal);

Usually, the function isHTB() returns:

• '\0' (easy to borrow)

• 'H' (hard to borrow)
• 'T' (pre-borrow required)

Further, updates to the value should be checked when you get the following messages:

Message Type Where to Listen

TM_EQUITY_UPDATE MarketSorter securities Main Thread
TM_STOCK_UPDATE_LEVEL1 MarketData Securities Main Thread

Page 29 of 35
Threading Information
When the Takion application starts, it creates a number of "worker" threads. The number of worker
threads is equal to the number of CPUs that your computer has. When subscribing to a security either
through the Takion application or the API, the security is assigned to a worker thread that processes the
security's data. Internally, there is a mechanism that keeps all the worker threads balanced with
approximately the same number of securities.

When a message about the security arrives, it is posted to the same worker thread assigned to the
security. This means that several securities can be processed simultaneously in different threads.

Locking
When changing the security's state, the Takion application locks the security for modification, which is a
‘write’ process that is only performed in the Takion application to maintain a current understanding of
the state of a security based on market messages. This modification type of locking and changing a
security's state is not available through the API, since it is a consumer of a security’s state and has no
reason to modify a security.

When a custom built API DLL wants to perform an inquiry into the security's state for observation, it
calls the’ inquiry’ functions like GetLastPrice(), ResetIterator(), GetNextQuote() . But before doing this it
must Lock the security for inquiry to avoid a state change during the inquiry.

Some data is never modified, like stock symbol name. Consequently, this data can be accessed without
locking. Also, if you are accessing a single data item, which is no longer than 4 bytes (e.g. "imbalance
size"), the API DLL does not need to lock the item because those values are modified "atomically" and it
is not possible to access a partially changed values. However, given time constraints when accessing
several values and they all need to be based on the last message, the security must be to be locked.

If a lock for inquiry is obtained, it must be unlocked when the data retrieval is complete. Further, it is a
good practice not to keep the security locked for an extended period because it holds the worker thread
and prevents the ongoing market modification of the security. Ideally, API code should lock for inquiry,
quickly collect the necessary info, unlock, and leave the time consuming algorithm calculation and
processing for buying or selling security outside the inquiry locks.

Caution! Of special note is the process of accessing security data through iteration, such as like getting
several top quotes of the Level2. Not only is this dangerous because of the increased risk of incorrect
(out of date) data due to the modification in progress, but there is a risk of crashing the Takion
Application too!

Page 30 of 35
Below is an example of using locks (for inquiry) in the API:

Non-Security locking
The same locking details apply to Account objects. The accounts are assigned a worker thread (in a
balanced manner) for processing. The entire account object, with all its Positions, Orders, and
Executions belongs to a worker thread.

There may be multiple accounts, sometimes hundreds, loaded into Takion. Thus, it helps to have and
use as many CPUs as possible to process them in parallel.

Modification and inquiry locking of Accounts, Executions, Orders, and Positions is syntactically the same
as for securities. Although, one difference being that you Lock in a single manner, the Account object for
all kinds of modifications and inquiries. In contrast, securities can be locked in a separate manner for
Level1 data, Level2 data, trade prints, and Charts. The worker threads, discussed at the start of the
threading section, manage these types of objects in the same set of threads as the securities and
therefore can have a mix of Security and Account objects in the same thread.

Page 31 of 35
As mentioned above, the API code doesn’t have access to the worker threads; instead, these are
managed by the Takion application. As a result, API code simply needs to lock and unlock properly.

Locking API Functions:

Method Name Objects with Method Description
LockInquiryWait() • Securities Often calls LockInquiry(wait)
• Accounts iteratively until it returns ‘true’.
• Executions
• Orders
• Positions
LockInquiry(Wait) • Securities Boolean response for whether a
• Accounts lock can be obtained [generally
• Executions used by internal object coding,
• Orders less so by direct calls in the API]
• Positions
Unlock() • Securities Removes the inquiry lock
• Accounts
• Executions
• Orders
• Positions

API FAQ
Q: Must I use the sample extension application?
A: No. One could download the API from the Takion FTP Site and refer to the above Example Extension
API walkthrough for required files, folder structures, etc. to get started.

Q: Once I download the ExtensionSample application and add the necessary files and write my logic, I
can just tell the Takion application where it is and so long as it works as expected, I won’t need to
download anything else, correct?
A: From time to time, you may benefit from updates to the Takion API base code files. They can just be
copied over the existing files in your project, be recompiled and ‘re-associated’ with the Takion
application.

Page 32 of 35
Appendix A

Takion Software
• API: Current (as of 7/25/2015) stable version: 1.0.2.130
• VPN Software in FTP site: Cisco VPN client 5.0.07.0410
• Takion (main application) Version: 2.9
•

Bug fixes in current version (or a link to the location of such a document)
• FTP site – Release Notes.docx

List of previously available versions

Versions:

• 1.0.2.94
• 1.0.2.105
• 1.0.2.113
• 1.0.2.116
• 1.0.2.124
• 1.0.2.128

Version of MS Visual Studio that is required:

• Visual Studio 2010 service pack 1

Page 33 of 35
Appendix B

References
List of useful links
• Takion website:
• Takion FTP

List of useful External References

• Nasdaq
• NYSE
• ARCA

Page 34 of 35
General FAQs
1. In what language is the API code written?
a. C++ (Microsoft Visual Studio 2010 service pack 1)[Microsoft Foundation Class (MFC)]
2. Is it possible to write API code in a different language?
a. Not currently.
3. Where do I get the latest version of the API code base?
a. On the Takion FTP Site.
4. How will I know if a new version has been added?
a. Please check back on the FTP site occasionally to see if a new version is available.
5. Do I always have to use the most recent version of the API?
a. Not at the moment, but in the future, the API will receive a bit of an overhaul in which
certain libraries will be migrated to different files.
6. If my code relies on a specific version of the API code base, can I keep using it instead of
upgrading?
a. Most likely this will not create a problem in the short term, but by doing so, you may not
be taking advantage of recent effeciencies or features added to the newest API versions.
7. Now that I have a DLL how do I get it to talk to the Takion Application?
a. Please see the section above entitled: Getting your compiled DLL to work with the
Takion Application
8. If I am running the Takion API, and it is trading in and out of positions, can I manually enter a
trade through the Takion application too?
a. Yes. The API trades separately from the main Takion application.
9. Do my API trades appear in the Takion Application?
a. No – the API manages its own trades.
10. Will my API code ignore my manual trades through the Takion application, or will it try to
process it using my API code? Is this avoidable?
a. It will ignore them. More specifically, it will not process trade messages resulting from
these securities and will have no interaction with them.
11. Do I need to be well versed in the FIX protocol in order to trade using the Takion API?
a. No.

Page 35 of 35