Tableside Open Source Collaboration

December is a good month to work on something serendipitous. We started a little experiment to sit a few random developers at a table to build something from scratch together. This wasn't anything big like a hackathon. We wanted to create a cozy (or as the Danish would say, hygge) space for people to get together to work on something fun. In the beginning of the month, I sent out this call for participation for a weekly hack night for December.

Meetup screenshot

To my delight, a couple developers actually came on the first day!

First Git commit with Julia and Mark

Julia, Mark, and I spent our first gathering hashing out the idea for 99issues.

99issues is a Github issues discovery web application for finding easy/newbie issues in your favourite languages for use during dojos or hack days.

One of the deliverables that we got done on the first day was this memes. Priorities!

99issues memes

It was like musical chair for the rest of the month. People came, gone, and returned. Usually we have 3 to 4 people around the table. For each session, one person that were here the previous week would induct the newcomers on what's happening.

As you can imagine, this is a project management challenge. One thing we did well was spent time up-front to discuss user needs, draft requirements, and document design choices. So everyone that came onboard subsequently are clear on the direction. We documented extensively on pen and paper and on Github issues. For each session, we break down work into doable-for-the-day chunks and made use of the usual open source collaboration Gitflow process. Nothing special here. Just divide and conquer.

Another hurdle for us that occurred early on is that as it's a general functional programming group, everyone have their own programming language of choice. Mark is into F#. Julia is into Haskell. Nandan is into Javascript. And RasmusErik is into Clojure.

Seeing that we didn't actually commit any code after the first session, I sneakily bootstrapped the project in ClojureScript and that was the end of story for this language war. (Thanks guys for putting up with my dictatorship!)

After a grand total of 3 hack nights (we skipped 23 Dec), we managed to get the project shipped with a bare scaffolding. We still need to work on the design and flush out the functionality. Pull requests are welcome! I had a lot of fun working side-by-side and getting to know these guys at the pub. We have different background but share a love for programming. I'm looking forward to doing this again next time I'm in town.

JFUtil: An open-source JForex utilities library

JFUtil is a open-source project focused on reusable JForex trading strategy components. Latest version is 2.1.3 released on April 8, 2011. Please keep your local JFUtil library up to date for the latest patches and features.

Main Features

1. Access to IContext and IAccount from anywhere in your project files. The one and only JForexContext object in JFUtil is a thread-safe, singleton object which can be called from anywhere within your projects, across any class file. No need to declare global IContext variables. No need to pass it around in parameters.

2. Simplify order submission with ticket builder. Set your trade order parameters with an order ticket object using a builder constructor. You can build ticket with as few or as many parameters as you like. All with intuitive method names in the same ticket class.

buySpTicket = new OrderTicket.Builder(label, instrument,IEngine.OrderCommand.BUY, 0.1)
                .setStopLossPrice(stopPrice)     // set stop price to ticket
                .setTakeProfitPrice(targetPrice) // set target

3. No more confusion about indicator methods. Indicators are encapsulated into their own bean object with their full function name and parameters are set using intuitive, clearly described methods.

// get an EMA indicator value by building an indicator bean
MovingAverage maBean = IndicatorBeanFactory.getMovingAverage();
// then sets its parameters with obvious method names
    .setMAType(IIndicators.MaType.EMA) .setWidth(14);
// all of these are optional parameters
// feed the bean into a generic calculation method to get the result
double ema = Indicating.calculate(instrument, Period.ONE\_MIN, maBean);

4. Implicit multi-threading for ordering. Ease your main thread's workload for processing incoming data and avoid your order manager holding up the traffic. All automatically performed in the background without extra coding for you. 5. Built-in popular numerical functions for forex trading. Calculate expected profit or loss in your account currency. Saves you from writing boilerplate codes and reinventing the wheel. 6. Continuous improvements! JFUtil is continuously being improved based on feedback from traders like you. See the changelog below for major changes since the initial release in November 2010.


To best illustrate how JFUtil can make your JForex programming life easier, see this JForex strategy source code example.


Download the latest JFUtil library jar file including the javadoc for your own use (use the @Library annotation in your strategy) or fork the project at Github to participate in this open-source project to make programming trading strategies in JForex easier for everyone.


Please report any issue or discuss your question or recommendation in the [comments section below][]. Alternatively, you can contact me directly.

Major Releases:

v2.1.0 - March 22, 2011 - indicator bean, label maker v2.0.0 - March 8, 2011 - singleton access to JForex objects, order ticket building, global currency conversion, global printer utility. v1.0 - November 24, 2010 - JFUtil 1.0