My wish list:

• Auto parallelised execution: parallel loops
  
• Ability to check variables. Also watch, inspect and visualise at a later time.
  
• Complex order types: E.g. trailing stop limit, VWAP orders, etc.
  
• Multiple frequency data
  
• Modularised strategies for re use. Indicator framework separated.
  
• Charting and visualisation
  
• Custom reports
  
• Live L1 and L2 data feeds
  
• User define aggregation of data: 5 min, 10 min data starting with specific offset to the natural wall clock boundary (If I run real money in a community shared algo I will not be trading with the other thus overall trade timing will not be predictable)
  
• Index, ETF, Mutual fund, other reported fund constituent data
  
• OTC feeds (Super Derivatives, FX, Options)
  
• Programmatic instrument search and universe selection: Derivative underliers, option chains, future chains, ETF / Mutual Fund / Fund / Index holding search
  
• Relative reference of derivatives from ATM and current month / period. E.g. ATM + 1, Current month + 1
  

Thanks Suminda,

I'm not in the trading industry (and don't dabble as an individual retail trader, either), so many of your items above are unfamiliar to me. One observation, though, is that Quantopian is working in a retail space, initially through Interactive Brokers (IB). Are some of the items on your wish list presently only available to institutional traders? One possible organization:

1. Features that are typically available to retail traders, but missing from Quantopian.
   
2. Features that could be added to Quantopian and would be fundamentally new to retail quantitative trading.

One general comment is that Quantopian needs to improve its tools for online collaboration. It is really awkward to collaborate on an algorithm...as I see it, presently, the only sensible way to do it would be to set up the code on a separate site (e.g. github) for development and revision control, and then copy-and-paste it into Quantopian for testing.

Grant

Only L1 & L2 data can be considered institutional but IB provides them. IB provides multiple order types and most of the functionality.

Any way what is it you might want to ask Quantopian to implement.

Suminda the increasing frequency of new threads you start is starting to distract away from actual algorithims. I look forward to the day we get a proper forum with sections for all these one line requests.

If everybody posted like you this community would not work. Please consider this.

Maybe forum support for mathjax so we could type in LaTeX? So we could talk maths..

Suminda and all,

You might add your ideas to https://www.quantopian.com/posts/feature-requests-what-changes-would-you-like-to-see, started by Dan Dunn, rather than creating new threads.

Grant

Multiple frequency data is really holding me up. I've tried the work arounds, but they get very complicated, and you then lose the benefits of ta lib. If I had 15min,30min, or 1 hour frequency, I could code up all of my hand traded algorithms in a day, or perhaps the after noon. As it is, I'm am stymied trying to become a python expert. Python is great is you are doing something closer to scripting, but if you have to do move complicated data structures, it becomes a un reliable mess. Solution, multiple frequencies.

Hello Richard,

Would you be willing to share a bit more detail? When you say "15min,30min, or 1 hour frequency" what do you mean? I started looking into some of the pandas tools for rolling statistics (see http://pandas.pydata.org/pandas-docs/dev/computation.html). So, if you want to do analyses over a trailing window of 15/30/60 minutes, the batch transform along with pandas might work.

If you can specify what you need to do, then I can try to pull together an example.

Regarding TA-Lib, have a look at https://www.quantopian.com/posts/help-needed-ta-lib. Peter sorted out how to feed his own accumulated data to TA-Lib (daily closing prices in a minutely backtest). So, I think it'd be feasible to do something similar on 15/30/60 minute data.

Grant

Hello Grant,

There is lot of information around on trading multiple timeframes usually along the lines of identifying a potential entry in one timeframe but getting confirmation from (an)other timeframe(s). See http://www.tradingmarkets.com/recent/improving_the_odds_by_trading_multiple_time_frames-639825.html for example.

P.

Peter,

The pandas rolling window/stats should be applicable. In Quantopian, by selecting the batch transform window to be relatively long, compared to the pandas rolling window, you get a timeseries (vector) of the transformed data looking back over the entire batch transform window (and over multiple securities, if you want). A firehose of data.

Grant

Hello Grant,

Could we collaborate on this either offline (my email is in my profile.) or in a new thread? The algo doesn't even need any trading logic. I think the lack of multiple timeframes is quite significant - I agree with Richard above - and I suspect it will be a while before Quantopian address it (hopefully I'm wrong). At the moment my minutely algo with multiple SIDs over several years fails to complete it's run but that is another issue.

The algos here are making good progress in part beacuse some of the participants (not me!) are finance professionals - interesting strategies, multiple SIDs, margin control, end-of-day checks and many TA-Lib indicators built-in. Multiple time frames is the next big one for me. That and performance! The consensus demand for Forex data is understandable but I think the infrastructure needs to be worked on before the data sources.

P.

Hi Grant,
I'd be delighted to elaborate. I believe the type of trading I do is performed by a lot of people. Basically, I have a hand traded system which uses daily moving averages and daily stochastics (others use various other indicators) to do swing trading, entering stocks for periods of 2 days to 2 months. When an entry point appears, it's important to detect that entry point prior to the close, because one momentum is detectable on the chart, there is often a gap the next day. Next day systems vastly underperform systems which trade towards the end of the same day. I've verified this using multi charts. Using something like stockcharts,com, it's easy to trade this way, because the daily indicators are updated continuously with the latest values.
Now, using RIZM, which has 15 minute, 30 minute, etc time scales, it's easy to work around this by simply multiplying out the moving average, chaining a 10 day moving average to 130 30minute periods for instance. RIZM has the drawback of having a poor backtester and limited programing functionality.
I tried this using minute period in Quantopian, but couldn't get the 3900 minute and 23000 minute moving averages doesn't seem like a good solution. I would like a solution which allows me to use the standard set of libraries to get indicators, rather than have to rewrite my own. I admit I just learned the python tutorial, so I'm lost how to get batch transform to do this.
It would be great to have other timeframes, but an example of how to set it up using the current system would be of great help.

Rich

Thanks Richard,

I think I'll need to do a little background work, since I am not a trader. I don't quite grasp the idea of the various timeframes, since with minute-level data you can have any timeframe you want, down to a minute. But I definitely appreciate that there is a learning curve to both Python and Quantopian. I might be able to provide an example, but I'm not sure what you need to do.

Peter,

Yes, we can discuss on a different thread.

Grant

I put up a new thread called "Timeframes discussion"

Could we have logs redirected to a text account, or an email account. This would help monitor the algorithm while we are on the golf course. ;-)

Have you tried using a deque?

from collections import deque

# e.g. only sample bars every 15 minutes  
MINS = 15  
# Time window of sampled bars (e.g. 100 bars every 15 mins)  
MXLEN = 100

def initialize(context):  
    # Build your portfolio...  
    context.stocks = [sid(8554), ...]  
    context.deq = {}  
    for stk in context.stocks:  
        context.deq[stk] = deque(maxlen=MXLEN)

def handle_data(context, data):  
    # Only sample prices every [X] minutes  
    exch_time = pd.Timestamp(get_datetime()).tz_convert('US/Eastern')  
    if exch_time.minute % MINS is not 0:  
        # do nothing until every [15th] minute  
        return

    stocks = context.stocks  
    for stock in stocks:  
        stock_data = data[stock]  
        price = stock_data.price  
        context.deq[stock].appendleft(price)  # Or high, low, VWAP, etc...  
        # OPTIONAL:  Wait until deque is full before commencing to trade  
        if len(context.deq[stock]) < context.deq[stock].MXLEN:  
            return

       ...  

You can then have a time series of 15 min prices over a time window of a given length (easily extendable to bars) that you can use for other functions.