cl-fix

Generally you'll derive your dictionary from the FIX specification for your endpoint. However, in the source, there is a standard FIX 4.4 dictionary which should get you 90% of the way there for many endpoints.

Rather than repeat the contents of that file here, you are encouraged to read through it and its comments. It is over here: ./dict/fix44.lisp.

Using the dictionary macros in cl-fix results in a few functions within that namespace:

• SERIALIZE-FIX function: serializes a message instance to a stream for this dictionary.
• READ-FIX function: reads one FIX message from a given stream and returns it in its object form for this dictionary.
• STR Returns a string representation of a given message for this dictionary.

To establish a session, you will first need a CONNECTOR.

There are 2 connector types:

1. An INITIATOR, which initiates an outgoing connection to an endpoint; and
2. An ACCEPTOR, which accepts an incoming connection.

You can create an initiator as so:

(defparameter *connector* (make-instance 'cl-fix:initiator :host "some.example.host"
                                                           :port 8383
                                                           :dict-key :fix44))

Next, add one or more sessions to your connector. Adding a session to an INITIATOR versus ACCEPTOR has slightly different semantics:

• Adding a session to an INITIATOR means that upon connecting to the remote endpoint, each session will send its respective LOGON(A) message.
• Adding a session to an ACCEPTOR means that when the connector receives an incoming connection, it expects to receive a LOGON(A) message, which will then be dispatched to the correct SESSION object.

Adding a session requires you to first create one, then add it to the corresponding connector. You'll also want to bind it to a message handler. You'll typically subclass the in-built SESSION class as follows (continuing from the above example):

;; Define a handler
(defun my-handler (session msg)
  (log:info "Received a ~A message" (util:fix-msg-type msg))
  (case (util:fix-msg-type msg)
    (:market-data-snapshot  (log:info "Yay - got some market data"))
    (:execution-report      (log:info "Yay - got an execution report"))
    (t                      (log:warn "Unhandled message: ~A" msg))))

;; Define session class defaults
(defclass my-session (cl-fix:session)
  ()
  (:default-initargs
   :dict-key :fix44
   :sender-comp-id "this-system"
   :target-comp-id "remote-system"
   :handler-fn #'my-handler))

;; Make an instance and add to connector
(defparameter *session* (make-instance 'my-session))
(cl-fix:add-session *connector* *session*)

You can then start your connector. Again, the behaviour is slightly different depending on what type of connector:

• In the case of an initiator, starting the connector will automatically start the underlying sessions once connected to the remote endpoint. Once the session is started from an initiator, it will send out a LOGON(A) message as per the session's values.
• In the case of an acceptor, we listen for an incoming connection. Upon receiving an incoming connection, we expect a LOGON(A) message to be sent by the remote end. That message will be matched to an added session based on key fields in the message (namely: target and sender comp ID's, and target and sender sub ID's)

Starting a connector is simple:

(cl-fix:start-connector *connector*)

Should you need to make some source code updates then re-iterate, you'd typically stop your connector, reload sources and start it up again:

;; Stop connector
(cl-fix:stop-connector *connector*)

;; ... Make some source code changes ...

;; Start connector
(cl-fix:start-connector *connector*)

For some fully working examples, take a look at the following files:

• the initiator example
• the acceptor example

SSL support will be added in the future. However, until then, it's possible to use cl-fix behind stunnel.

An example, minimal stunnel configuration (stunnel.conf):

foreground = yes
[quote-endpoint]
accept = 127.0.0.1:1111
client = yes
connect = target.example.com:2222

Then, when constructing your initiator, ensure you connect to your local stunnel port:

(make-instance 'cl-fix:initiator :dict-key :fix44 :host "127.0.0.1" :port 1111)

Intellectual curiosity, and rethinking problems I've encountered that could have used fast(er) iteration.

I've been in situations where iterating and prototyping at "Lisp speed" against FIX endpoints would have been extremely beneficial. I'm also experimenting with trading infrastructure against my broker, somewhat inspired by Durenard's book "Professional Automated Trading".

I'm fully aware that the vast majority of developers in this space are using Java, C++, or C#. I myself am a Java developer. The intersection of "programmers who work in finance", and "Common Lisp users" may likely just be myself. Hopefully not! Perhaps this library will make others come out of the woodwork.

Please see ./CONTRIBUTING.html for information on how to raise it.

Nothing, really. I wanted a short, memorable domain name on which to publish code, and then to get on with life. I might invent a better back-story in the future.