Best products from r/algotrading

Scott Meyers made Effective Modern C++ which has a lot of changes in the language documented and documented well. If you're proficient in C++ I highly recommend checking it out. (Or watch: https://youtu.be/xnqTKD8uD64)

The big one is ownership semantics leading to smart pointers.

The general rule of thumb is you should never use a raw pointer, except when you're not transferring ownership. Also, consider weak_ptr, and references, always references.

SFINAE in class, really? I'm impressed. Use constexpr if instead when you can (90% of the time). SFINAE should really only be used for firmware and library engineers and is on its way out, if concepts ever get finished.

Metaprogramming in C++? More like dark magic, taking advantage of C++17 plus SFINAE. No, I think you mean meta template programming, most likely. Meta template programming has been replaced with constexpr if as well. Don't do it, unless you like pranking your coworkers. You can write meta template programming to crashes IDEs when they try to read the file.

>data structure/algorithms (arrays/linked lists/trees/maps/stacks/queues/searching/sorting/graph searches and efficiency considerations)

That's more data structures than algorithms. I personally think algorithms are more important, but I digress:

std::deque is important, and no it's not a doubly linked-list. All the different hash and tree structures like std::unordered_multiset are super helpful to know, even if you never use them. Understanding sets and tuples too. None of this is specifically modern C++, except that most of these data types didn't exist or were incomplete 'till C++11. cppreference is super helpful and imho should be used regularly.

Oh and C++ has a whole slew of algorithm functions and classes now. Check them out on cppreference, but imho they're not super helpful like they are in Python or R. Really, learning how to make an algorithm is more important.

Oh, I've been rambling about old stuff. Okay back to modern: the different kinds of bracket initializations are important. Previously initialization had a lot of () in it, so auto foo = Bar(0);, should that be a () or a {}? Looking at it I can tell you it most likely should be auto foo = Bar{0}; but it's not a guarantee. I'd have to look at Bar's source code to verify.

There are modern idioms that should be considered, like aaa or almost always auto, and should be followed when possible and reasonable to do so.

Lets see, what else.. nullptr instead of NULL. A lot of the pre processor can be replaced with constexpr and constexpr if.

Ranges is definitely worth learning but that's a C++20ism. std::expected is super helpful to know but that's a C++20ism as well. (Just to know there are more ways to handle exceptions and which to use.)

They teach perfect forwarding in classes you go to? What classes are you taking? That's impressive. I'd say std::move is super important to know and understand, but it's a given if you understand ownership semantics.

Oh, there are new keywords. default and delete should be used liberally when creating a new class, in conjunction with the 0,3,5 idiom. override is important on the inheritance front, and imho should be enforced using a compiler flag.

Oh! Threading and file handling have had a complete over hall. Now C++ does it instead of using the OS' libraries. Threading is a bit of a sinkhole and should be known inside and out if you're working on your own project. If the project is large enough the framework should handle all of the threading for you. Otherwise, it is important. (eg, lockfree programming is kind of important in most situations.)

And of course lambdas. Super useful. No more void *. I can't believe I almost forgot them. Pass code around, not variables.

RVO is important when considering ownership semantics. Basically, don't std::move on return unless necessary. Don't return a pointer or a reference unless necessary.

Gosh there was something else..

Let's see, inheritance isn't taught right in any book or class I've seen. There is a prerequisite of understanding how to make types. This is important for quant work, because you'll probably be using custom types everywhere. Learning how to make them in C++ is important, not just use them, because it builds the prerequisite conceptual understanding for multiple inheritance.

Inheritance in Haskell terms is subtyping or abstract typing. Abstract classes (not necessarily fully abstract, just not concrete) are a type of class, sometimes called a subtype or abstract type. Inheritance isn't just for gluing code together. It's for having types of classes, or categories of classes. This is something understood on a senior level, but because it is so difficult to understand modern languages tend to just ban multiple inheritance out right. C++ has it, so understanding the thought process to not doing it right, but thinking about it right, is important.

I'm sure there is more. Oh, there is a new syntax Herb Sutter has been pushing which is pretty great, if the whole code base has it. .... and I can't find the video. The skinny is int foo(double bar) becomes auto foo(double bar) -> int. The philosophy is the function name should be as far as possible to the left hand side to make code more readable, because types can get stupidly long sometimes. The C++98 equiv, which thankfully most of the code bases I've worked on do:

int
foo(double bar)

Oh and std::variant combined with constexpr replaces unions.

Basically, if it's in C there is a C++ equiv. Use that instead. The exception is native types, and functions. Even loops have changed to range based for loops eg for(auto it : foo) and with std::for_each, though C style loops are still useful and used sometimes. Oh and structs are still around and can be popular, but std::variant or std::all might be a better option depending on what you're doing.

And the most important saved for last. Read http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines learn it, love it. For example, checkout F.15. Super helpful. This is official, so you can use it for coding disputes and what not.

phew \>.\<

( please guys have fun with my answer, obviously a lot of things here are jokes. take home what fits you ).

AFAIK There is actually one OTS online platform for trading crypto, which is very buggy and have a very amateur community ( even veterans on that platform are generally noobs ), the backtest isn't even close to realistic unless you somehow compensate the slippage and some other "real life" problems ( i'm far from having the magic sauce myself, but i can tell when shit smells funny ).

Don't even try to use one of the fast bots available there, they will generally just loose your money quickly before you can actually realise wtf is going on. They have a market place with paid the strategies and they are generally very unreliable, specially because the norm is to hide the source code of the paid strategies and post backtests - not live links -, so basically it could be just a fake strategy doing the other side of the creators trade not to say backtests are generally far from the results you get in the real world, at least the backtests in @ cryptotrader.

The support is very poor and slow, some questions are simply ignored and the UI is lame ( euphemism here ), http://cryptotrader.org

Still it's the only algo trading platform for crypto i manage to have running 24hours to generate some profit while i'm building my own - so far i'm only trading ETH margin on poloniex because of it's volume.

The good side is that the language used for the bots is coffee script which is one of the most pythonish languages out there 😉

I'm a beginner myself but i already have profitable bots earning consistently ( i had to learn how to do my own after only loosing money with the famous bots out there ).

Other relevant comments:

• Quantopian backtest engine is python based and actually open source: https://github.com/quantopian/zipline
  
  
• Even tough quantopian doesn't trade crypto, they have very valuable tutorials which you will surely benefit from: https://www.quantopian.com/tutorials/getting-started their youtube channel is cool: https://www.youtube.com/channel/UC606MUq45P3zFLa4VGKbxsg/videos and also make sure you try out their IPython examples, they are pretty fun: https://www.quantopian.com/research/Tutorials%20and%20Documentation
  
  
• If you like python you probably know you should stay away from .NET and Java and C and whatever other boring languages people might recommend you, python is cool and awesome, you don't want to spend your time typing irrelevant verbosy stuff, you want to react and test stuff quickly - and have cool friends, .NET and Java programmers are notoriously the most boring people around. There is a couple of other nice other languages available, but it's not important to talk about this now.
  
  
• IMHO you are less likely to make good stress-free money with algo trading if you have a very academic approach , you might end up trapping yourself into parts of the business that won't make a big difference in your profits, obviously, studying is always good and you can always learn something from anyone and anything, remember: learning what not to do is actually learning too! not to say you won't probably learning without burning yourself a little bit. The market is 24 hours so unless you know what you doing you will probably end up not sleeping loads of nights.
  
  
• IMHO, HFT is a no go because the rate limit on important API functions is generally ridiculously limiting AND unless you have a lot of crypto to trade ( therefore paying less fees or no fees ) or a very very solid strategy the fees will eat you.
  
  
• If you want to get inspired, watch videos on youtube about algo trading, good keywords on youtube are "Ninja Trader strategy builder", "metatrader expert advisor", etcs.. there is always something to learn from those videos.
  
  
• You will eventually find other options, like this: https://www.youtube.com/watch?v=2at6ZzRIIhc but they generally sux balls big time, or aren't just relevant anymore ( generally both ) or are never released: http://cryptybots.com
  
  
• Leonardo looks great, but it seems unfinished ( i might be wrong ) and i'm not sure to which degree you can create your own strategies in here: https://www.youtube.com/watch?v=hib3xR6Ci1w&feature=youtu.be
  
  
• Since your most important skill will be "making profitable strategies" i reckon you should understand trading to a degree you won't blow your account in a couple of weeks. This book will probably help you out: https://www.amazon.co.uk/Mastering-Trade-Second-Techniques-Profiting/dp/0071775145 ( there are loads of other books you can find for sure that might suit you better ), goes without saying you should do your home work and learn a lot about indicators so you start grasping the basic building blocks and start thinking for yourself instead of being a script kiddie.
  
  
• This market is about money and if someone is rich with algo trading someone probably wouldn't be around giving advices for free, so trust no one other than you, if they are talking too much either they don't make money or they just had a line of coke. Don't even trust me!!
  
  To wrap it up:
  
  
• I'm willing to help and team up with smart people if think that would be a good idea, please get in touch.
  
  
• If You plan to level up your learnings in no time i would be willing to give you a crash course on how to trade ETH on poloniex exchange for a donation, give you some basic ideas and code and then we take it from there, we can then potentially become friends and create stuff together if we see turns out to be interesting for both of us.
  
  
• My email is capybara.trades@gmail.com feel free to get in touch if you feel like:
  
  
• You want to become a friend
  
• If you would like to buy some of my time and experience in form of an "easy and fun to learn" masterclass
  
• If you don't know how to code but want to do automated trading and you willing to pay for some basic programming classes
  
  
• If you found any of these information useful, don't feel shy send me a btc tip @ 1DNvZwFpFj9C6YNf9bAhx5bQd66RssXbyp ( pro tip: every time somebody tips me Justin Bieber dies a little more )

First of all, thanks for sharing. Code & idea implementation sucks, but it might turn into a very interesting discussion! By admitting that your trade idea is far from being unique and brilliant, you make a super important step in learning. This forum needs more posts like that, and I encourage people to provide feedback!

Idea itself is decent, but your code does not implement it:

• You want to holds stocks that are going up, right? Well, imagine a stock above 100ma, 50ma, 20ma, but below 20ma and 10ma. It is just starting to turn down. According to your code, this stock is labeled as a 'rising stock', which is wrong.
  
  
• SMAs are generally not cool. Not cool due to lag of 1/2 of MA period.
  
  
• Think of other ways to implement your idea of gauging "going up stocks". Try to define what is a "stock that is going up".
  
  
• Overbought/oversold part. This part is worse. You heard that "RSI measures overbought/oversold", so you plug it in. You have to define "Overbought/oversold" first, then check if RSI implements your idea of overbought/oversold best, then include it.
  
  
• Since you did not define "overbought / oversold", and check whether RSI is good for it, you decided to throw a couple more indicators on top, just to be sure =) That is a bad idea. Mindlessly introducing more indicators does not improve your strategy, but it does greatly increase overfit.
  
  
• Labeling "Sell / Neutral / Buy " part. It is getting worse =)) How did you decide what thresholds to use for the labels? Why does ma_count and oscCount with a threshold of 0 is the best way to label? You are losing your initial idea!
  Just because 0 looks good, you decide that 0 is the best threshold. You have to do a research here. You'd be surprised by how counter intuitive the result might be, or how super unstable it might be=))
  
  
• Last but not least. Pls count the number of parameters. MAs, RSI, OSC, BBand + thresholds for RSI, OSC + Label thresholds ... I don't want to count, but I am sure it is well above 10 (maybe 15+?). Now even if you test at least 6-7 combinations of your parameters, your parameter space will be 10k+ of possible combinations. And that is just for a simple strategy.
  
  
• With 10k+ combinations on a daily data, I can overfit to a perfect straight line pnl. There is no way with so many degrees of freedom to tell if you overfit or not. Even on a 1min data!
  
  The lesson is: idea first. Define it well. Then try to pick minimal number of indicators (or functions) that implement it. Check for parameter space. If you have too many parameters, discard your idea, since you will not be able to tell if it is making/losing money because it has an edge or just purely by chance!
  
  What is left out of this discussion: cross validation and picking best parameters going forward
  
  Recommended reading:
  
• https://www.amazon.com/Building-Winning-Algorithmic-Trading-Systems/dp/1118778987/
  
• https://www.amazon.com/Elements-Statistical-Learning-Prediction-Statistics/dp/0387848576/

Well, the trick is to do one step at a time. Your goal is a very reasonable one, but you'll want to focus on the foundation first. For a non-programmer, I would recommend starting off with Code Academy or Coursera. The advantage of the second link is that it immediately provides you with a sense of direction while learning a language. Code Academy's Python tutorial is really nice in providing interaction with your code. Regardless, you'll want to first gain a sense of syntax on your language of choice.

After you're familiar with at least one language, the next most important thing is to become familiar with data structures and algorithms. This book on Amazon is amazing for giving beginner advice in the area: http://www.amazon.com/gp/product/1468108867

The book is not overly complex and mathematical compared to many other books, and it provides a fairly reasonable foundation for any beginner. If you ever want to practice writing basic algorithms out (optional), visit Codility's lessons to try things out. Once you can comfortably complete some of their lessons with a high grade and understand their topics, you should be ready to dive into the math/finance side. I feel that at this point, the Max Dama paper is a great way to get an overview of the basics. Regardless of the financial instruments you're trading (I've mainly worked with equities), you'll need a sense of portfolio management. Here's two books that may be worth running through:

http://www.amazon.com/Quantitative-Equity-Portfolio-Management-Construction/dp/0071459391

http://www.amazon.com/Expected-Returns-Investors-Harvesting-Rewards/dp/1119990726

They're both equities based (and I could be wrong here about FX), but it's probably a good idea to get a sense of how to measure returns. Regardless of the asset class you're planning to trade, all algorithms should be rigorously backtested and simulated (traded with virtual money) prior to being moved into production, and one of the best ways to improve your outcome is to know how to measure the returns and risks associated in your backtesting/simulations.

Hope this isn't too much information at once, but it should be a start. The first two courses throw-it-out mentioned in Coursera is a great start too.

Edit: I'd also take some time to browse some of the links on the sidebar in this subreddit. Some of those links are immensely helpful (especially the Statistical Learning one). Many of the strategy links are fairly easy reads and are recommended as well.

Do you have an edge? You mention you've been trading for 2 years, so I'll assume you do (but its ok if you haven't nailed it down).

Basically, you just take your edge, write it into python (or whichever language you want) and get it to generate a buy, sell or close signal. Once you have that down, just use an exchange's API to place your orders.

I do have a channel dedicated to this stuff, but at this point I think you're probably a bit more advanced than total beginner, it still might help you out though :)

https://www.youtube.com/watch?v=1nX4YEcTJlc

>what to learn/focus on & recommended resources: math, programming, strategy creation?

For me I've found that, programming wise, its never really that complicated. Sure, if you're going to be using some ML or advanced data analysis or something you might need to sharpen your programming but at least for me, the best resources I found had to do with market psychology and understanding the broader markets and trading in general. Some books I can recommend there are:

Trading in the Zone, By Mark Douglas - https://www.amazon.com/Trading-Zone-Confidence-Discipline-Attitude/dp/0735201447

Fooled by Randomness, by Nassim Taleb - https://www.amazon.com/Fooled-Randomness-Hidden-Markets-Incerto/dp/0812975219/ref=sr_1_1?crid=13LH3VBFX62OH

Skin in the Game, by Nassim Taleb - https://www.amazon.com/Skin-Game-Hidden-Asymmetries-Daily/dp/042528462X/

Algos to Live By, by Brian Christian - https://www.amazon.com/Algorithms-Live-Computer-Science-Decisions/dp/1250118360/

A Short History of Financial Euphoria, by John Galbraith - https://www.amazon.com/History-Financial-Euphoria-Penguin-Business/dp/0140238565/

>process beginning to go live: collect data, write code, test code, start trading?

In simplest terms (this is how I do it), get data via websocket, feed it into your algo, have the algo generate signals, use (write) another program to use those signals to trade. I find splitting up the risk management, buy, sell and close into different parts helps. I would also back and forward test too. Essentially that's all there is to it. 99% of this stuff for me at least is optimizing my algos and trying to run them on multiple markets. The programming behind them isn't that complex, its the math and theory.

Its not terribly impressive but this is what I was able to do with some algos recently:

https://twitter.com/robswc/status/1093328001243189248
https://twitter.com/robswc/status/1082782861869109253

even today I got one in:

https://twitter.com/robswc/status/1121943953564164102

but really, there's ppl out there that can do much better. I'm pretty content with my algos performance. I thought about tweeting every position once upon a time but realized since I'm not shilling some stupid course I don't have to really prove anything other than I'm not pulling stuff out of thin air lol.

I would definitely do forward testing though, whatever you do. Perhaps even add a human element to manage the risk at first. Just get the edge down and go from there, good luck! :)

My most successful algorithmics are based on sound financial ideas, that have been either implemented and well documented by famous fund managers / investors or well researched methodologies documented on white papers by PhDs in the area. The algorithmic simply automates that idea and provides consistency.

Specifically on some models that I have developed, the goal is to have a trading portfolio made of models that are driven by different factors, with low correlation between them. I got models for both US and Canada exchanges. These models rebalance weekly or monthly, so they're not meant for daytrading, but more for swing trading with low to moderate turnover.

For example, one model is focused in income, by seeking quality companies with low volatility. This research paper has the details behind to why it works: https://www.researchaffiliates.com/documents/True%20Grit_The%20Durable%20Low%20Volatility%20Effect%20pdf.pdf
This model makes use of market timing based on economic factors, to switch to other asset classes during times that equities underperform, such as in recession.

Another model is based on growth, exploring inefficiencies from Nasdaq companies, which are the great for growth as they drive innovation and are strategic for mature companies to continue to be competitive. This model relies on both fundamentals and technical analysis, to take advantage of price momentum (and therefore, overvaluation), which wouldn't be possible to capture with a value approach focused on fundamentals only. The technical analysis uses the principal of this book: https://www.amazon.com/How-Make-Money-Stocks-Winning/dp/0071373616

I've recently created a model focused on momentum of fundamentals, basically exploring the inefficiencies of small cap companies with decent fundamentals but with price disconnected from that quality, which are also increasing the rate of which fundamentals keep getting better (while stock price doesn't keep up with the same pace). This is based on this research paper: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2538867
This paper also explains the benefits when combining value, size and momentum, as per this paper: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=1720139
The model also makes use of these criteria regarding quality: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2287202

These are some ideas which I have had good success out-of-sample, and these models have been backtested since 1999 using non-survivalship biased data.

I have a website with more details on that, so feel free to PM for more info.

There are always inefficiencies to be explored in the market - any model that looks into mechanism to explore these inefficiencies in a consistent way can provide superior adjusted risk return.

> I have the backtrader and pyfolio modules, but I have ZERO idea where to start with those. I wanna start backtesting and create my own portfolio in Python.

That someone uses my platform (backtrader) is always good for the ego, but the platform is not the starting point (pyfolio isn't either) if you really don't know where to go. From your message it would seem (and my interpretation may be wrong) that you have little or no experience trading or at least not with technical indicators like the moving averages you mention having already created.

There are many factors to take into account to set an objective. For example:

• Timeframe
  
  Are you going to work with minutes, hours, days, weeks? Are you going to base your analysis in multiple timeframes?
  
  
• Technical Analysis (aka Indicators) vs Quantitative Analysis vs Machine Learning
  
  One would gladly master all possible disciplines and do it in less than a week. But we are only humans with some other things to do (day job, studies, you name it ...) and fully concentrating on one is enough. Some will say that Technical analysis is the poor brother of Quantitative Analysis and some others that the only way forward is Machine Learning. Choose what better fits your starting point and your psychology.
  
  I would personally recommend that you use a free charting platform and spend some countless hours looking at many different indicators against different assets and timeframes to try to build up patterns in your brain, which will later allow to model ideas for algorithmic trading. You can of course do the same by looking at countless different statitics for a Quantitative approch
  
  
• Assets
  
  Are you going to trade stocks? And if yes, penny stocks? Futures? (from indices, currencies, commodities?) Forex? Cryptocurrencies? options? (raw options or strategies like butterflies, condors ...?) There are many other things, but that's already enough.
  
  They all have different behaviours and there are two things to look for: that you can find the edge and that it fits your psychology. Even if you are 100% algotrading there will be losses and you need to trust the system and be able to accept the losses with no hesitation. Some assets and how they produce losses will better fit you. Some will let you easily go long and short and some only long.
  
  
• Position sizing. How will you address how much you will be staking with each bet? Linear, kelly, exponential?
  
  My real recommendation would be this book
  
  
• Amazon - Trade Your Way to Financial Freedom
  
  Or the modern version which talks about electronic trading:
  
  
• Amazon - Financial Freedom Through Electronic Day Trading
  
  But I would still recommend the 1st version. It's not going to tell you how to do it. It's going to give you the principles to do it. Some months ago and following a questionhere about the settings for the MACD and based on some of the ideas presented in this book I posted this, you may want to have a look:
  
  
• Backtrader blog - MACD Settings
  
  It shows how a system goes from losing to winning by controlling for example position sizing.
  
  Hope all this helps.

It actually does use indicators, and those indicators predict trends.

Mathematical models: I have only studied indicators. In the beginning of my project, I tried to create my own indicators using parametric equations, but it wasn't working. I couldn't get the algorithms to produce results better than random backtests. So I moved from that into real indicators.

Books:
The Ultimate Day Trader
It was the most helpful when I was getting started and learning about indicators. It taught me how trading was done, and it introduced the typical algorithmic trading like MACD crossovers, bullish convergence/divergence. It may be too much for beginners. As a warning, reviewers on Amazon don't think highly of the book.

I had to learn a lot on my own through trial and error and the occasional google search, so I The Ultimate Day Trader is the only book that I fully read.

Building Winning Algorithmic Trading Systems
Gives a lot of good information in getting good backtest results, and the steps an algorithm should have to pass in order to be traded with.

Algorithmic trading: Winning strategies and their rationale.
Currently reading this, and it starts off basic, like most books. It talks about look-ahead biases and that sort of stuff. It also talks about the different backtesting software and programming languages. I'm only on page 40/200, and it looks like it gets more complex.

I also have a few books on options, but those don't have to do with algorithmic trading.

Monte Carlo can take your historical data and then use the distribution to pick out values which could have had happened in the past. Say, if the distribution shows that there was an equal chance of the price increasing 1 dollar during a minute as there was a chance of the price decreasing 1 dollar a minute, then MC can flip a coin in the past and thus create a different kind of market history. You can thus play out events which were probably going to happen, but for some reason, such as randomness, never did. You may thus find that your strategy was either over- or underperforming in the timeline which is considered the real market history -- if you let out the price history play out more enough times, you will find variations in which you had astronomical gains and ones in which you were margin called every day. The idea is to find where exactly are you sitting with it currently.

Markov Chains then improve on the Monte Carlo by creating the possibility of occurrence of values which never were in the original distribution. In other words, this lets you play out timelines which are considered impossible by the historical data. This may further help you solidify your strategy even for the unlikely.

A book which introduces you to the importance of MC using an exhaustive amount of anecdotes is for example: https://www.amazon.com/Fooled-Randomness-Hidden-Markets-Incerto/dp/0812975219

This is a great book. The other book that is a bit less mathematical in nature, and covers similar topics, is Introduction to Statistical Learning. It is also a good one to have in your collection if you prefer a less mathematical treatment. https://www.amazon.com/Introduction-Statistical-Learning-Applications-Statistics/dp/1461471370

100x though, that's a bit much :) If you read effectively and take notes effectively, you should only have to go through this book with any depth 1 time. And yes, I did spend time learning how read books like this, and it's worth learning!

I would highly recommend to read the following book

https://www.amazon.com/Hands-Machine-Learning-Scikit-Learn-TensorFlow/dp/1491962291/ref=mp_s_a_1_2?keywords=machine+learning&qid=1566810016&s=gateway&sprefix=machi&sr=8-2

I think it is the best one about ml/dl. Not sure that they already updated the tensorflow examples to tf 2.0 and keras.

And as tensorflow includes keras now, and has perfect pipeline for deploying your model, i think it is the perfect choice. :)

Right now I'm reading The Art of R Programming. It seems like it has a lot of good knowledge but also seems really disorganized. The author uses control statements without explanation in the 2nd chapter about vectors to demonstrate their ability, and then doesn't get back to control statements until chapter 7. But being a seasoned programmer I don't think things like that will bother you too much. This is the only R book I've used, so my opinion isn't very broad based. The reviews for R Cookbook seem pretty good and I'm a little sorry I didn't start with that instead.

Hopefully someone else can chime in.

Probably start with something like:

• Mathematical Financial Economics
  
  
  
• Trading and Exchanges: Market Microstructure for practioners
  
  
  
• Building Winning Algorithmic Trading Systems
  
  And then you decide whether you are going to focus on one of the two primary trading strategies (mean reversion or momentum) and focus on that one for a bit.
  
  
• Optimal Mean Reversion Trading
  
• Algorithmic Trading: Winning Strategies and their Rationale
  
  And that's assuming you have the programming knowledge to implement a system that can handle this of course - otherwise I'd go start with C# or C++ until further notice.

Got a suggestion to read this book that actually shows the real amount of work behind big algo trading companies. https://www.amazon.com/gp/product/B079KLDW21/ref=ppx_yo_dt_b_d_asin_title_o00?ie=UTF8&psc=1

I was also thinking to do on my own, but right now I think it's easier to work towards own indicators(via TradingView pine script) that are good for my trading style and follow them closely, most likely I will automate trading this way.

Technical analysis on its own is literally astrology. There is no feedback loop to tell you if you're right, or lucky, even if you don't lose money.

Not to say that technicals are inherently bad. It's just that the good indicators were absorbed into the quantitative school of thought some time ago, while the random shapes were largely discarded.

3rd, how you size your bets in relation to how certain you are about direction isn't really covered by technical analysis.

4th) the key insight to fundamental analysis; that a dollar is still worth a dollar regardless of whether you pay 40c, 50c, or w/e, doesn't apply to trading, because timing matters greatly. This is why you'll want to look into standardizing your volatilities.

this is a great high level book. The author breaks down exactly who would use what aspects of a quantitative system, and you only have to read those sections. Although I imagine you'll be interested enough to cover the whole thing

Not sure if this book covers all of your requests, but surely a good place to start.

Algorithmic Trading and DMA: An introduction to direct access trading strategies https://www.amazon.com/dp/0956399207/ref=cm_sw_r_cp_api_i_r4TBCb4THD9C8

I started my journey almost a year ago. I read many books but I found Trading Systems to be the best beginners book. In terms of algo trading, its a different beast on its own. Your biggest challenge is getting the data.

Let's say that the dev. has read

https://www.amazon.com/Trading-Exchanges-Market-Microstructure-Practitioners/dp/0195144708

cover to cover (like I have many years ago): then what?

which market/asset do you recommend for the quickest way to their hands "dirty"?

i am sure you would not recommend they pay USD 5000/m for the NYSE openbook ultra feed and start playing with that at home.

They're not really "backtesting resources" but Ernie Chan's books all use matlab code examples, and he has all of the full example code on his website (viewable with a password obtained from the book)

• Quantitative Trading: How to Build Your Own Algorithmic Trading Business
  
  
• Algorithmic Trading: Winning Strategies and Their Rationale
  
  
• Machine Trading: Deploying Computer Algorithms to Conquer the Markets
  

If you haven't heard of quantopian I'd recommend checking that site out. It's a platform for quantitative trading with python. They have getting started materials there as well. For learning the "quantitative" part, this book gets recommended a lot: https://www.amazon.com/Algorithmic-Trading-Winning-Strategies-Rationale/dp/1118460146

Another great book for me was Hands-on Machine Learning with scikit learn and TensorFlow. This one I think is where I started to get some intuition on what some of the ML algo's were actually doing, and he provides lots of material on algorithm tuning.

My school had a book from Ernest Chan in the library. I recommend something like it https://www.amazon.com/Algorithmic-Trading-Winning-Strategies-Rationale/dp/1118460146

Algorithmic Trading: Winning Strategies and Their Rationale by Ernie Chan
Trading and Exchanges: Market Microstructure for Practitioners by Larry Harris
Algorithmic Trading and DMA: An introduction to direct access trading strategies by Barry Johnson

Interesting book, I downloaded it.

Tomasini is frequently recommended.

http://www.amazon.ca/Trading-Systems-development-portfolio-optimisation/dp/1905641796

For trading & quant background reading try:

Algorithmic Trading: Winning Strategies and T... http://www.amazon.com/dp/1118460146/ref=cm_sw_r_tw_dp_w795tb18DWJYM via @amazon

Volatility Trading, + CD-ROM by Euan Sinclair http://www.amazon.com/dp/0470181990/ref=cm_sw_r_tw_dp_z895tb04AE5BJ via @amazon

Nuclear phynance http://www.nuclearphynance.com

Stocktwits www.stocktwits.com

https://www.amazon.com/Algorithmic-Trading-DMA-introduction-strategies/dp/0956399207

Main problem with that is that it's kinda dated. The market's changed somewhat and newer execution algos are more sophisticated.

This book is language agnostic, but contains most if not all of the fundamentals for understanding and building algorithmic trading systems:

https://www.amazon.com/Algorithmic-Trading-DMA-introduction-strategies/dp/0956399207

How about these books? have you heard anything about them?

http://www.amazon.com/Trading-Systems-Methods-Website-Wiley/dp/1118043561/ref=pd_bxgy_14_img_2?ie=UTF8&refRID=1X0Y2BRSS0H1EWVB5HKC

http://www.amazon.com/Building-Winning-Algorithmic-Trading-Systems/dp/1118778987/ref=pd_sim_14_1?ie=UTF8&dpID=51eM1r6mrRL&dpSrc=sims&preST=_AC_UL160_SR127%2C160_&refRID=0HJDDFQYBW3A4V6WGXXX

[Link for the lazy] (https://www.amazon.com/Algorithmic-Trading-Winning-Strategies-Rationale-ebook/dp/B00CY5HC0U/)