<p><div><div><div><div data-width="100" data-show-faces="false" data-send="true" data-layout="button_count" data-height="21" data-href="https://www.r-bloggers.com/the-end-of-the-honeymoon-falling-out-of-love-with-quantstrat/"></div></div><div></div></div><div></div></div>
<div>
(This article was first published on <strong><a href="https://ntguardian.wordpress.com/2017/05/22/the-end-of-the-honeymoon-falling-out-of-love-with-quantstrat/"> R – Curtis Miller's Personal Website</a></strong>, and kindly contributed to <a rel="nofollow" href="https://www.r-bloggers.com/">R-bloggers)</a> </div>
<h2>Introduction</h2>
<p>I spent good chunks of Friday, Saturday, and Sunday attempting to write another blog post on using R and the <strong>quantstrat</strong> package for backtesting, and all I have to show for my work is frustration. So I’ve started to fall out of love with <strong>quantstrat</strong> and am thinking of exploring Python backtesting libraries from now on.</p>
<p>Here’s my story…</p>
<p><span></span></p>
<h2>Cross-Validation</h2>
<p>Let’s suppose you’ve read <a target="_blank" rel="nofollow" href="https://ntguardian.wordpress.com/2017/03/27/introduction-stock-market-data-r-1/">my</a> <a target="_blank" rel="nofollow" href="https://ntguardian.wordpress.com/2017/04/03/introduction-stock-market-data-r-2/">past</a> <a target="_blank" rel="nofollow" href="https://ntguardian.wordpress.com/2017/04/10/transaction-costs-not-an-afterthought-quantstrat/">blog</a> <a target="_blank" rel="nofollow" href="https://ntguardian.wordpress.com/2017/04/24/order-type-parameter-optimization-quantstrat/">posts</a> on using R for analyzing stock data, in particular <a target="_blank" rel="nofollow" href="https://ntguardian.wordpress.com/2017/04/24/order-type-parameter-optimization-quantstrat/">the most recent blog post on R for finance, on parameter optimization and order types</a>. You’ll notice that we’ve been doing two things (perhaps among others):</p>
<ul>
<li>We only used most recent data as out-of-sample data. What if there are peculiarities unique to the most-recent time frame, and it’s not a good judge (alone) of future performance?</li>
<li>We evaluate a strategy purely on its returns. Is this the best approach? What if a strategy doesn’t earn as much as another but it handles risk well?</li>
</ul>
<p>I wanted to write an article focusing on addressing these points, by looking at cross-validation and different metrics for evaluating performance.</p>
<p>Data scientists want to fit training models to data that will do a good job of predicting <em>future</em>, out-of-sample data points. This is <em>not</em> done by finding the model that performs the best on the training data. This is called overfitting; a model may appear to perform well on training data but will not generalize to out-of-sample data. Techniques need to be applied to prevent against it.</p>
<p>A data scientist may first split her data set used for developing a predictive algorithm into a training set and a test set. The data scientist locks away the test set in a separate folder on the hard drive, never looking at it until she’s satisfied with the model she’s developed using the training data. The test set will be used once a final model has been found to determine the final model’s expected performance.</p>
<p>She would like to be able to simulate out-of-sample performance with the training set, though. The usual approach to do this is split the training set into, say, 10 different folds, or smaller data sets, so she can apply cross-validation. With cross-validation, she will choose one of the folds to be held out, and she fits a predictive model on the remaining nine folds. After fitting the model, she sees how the fitted model performs on the held-out fold, which the fitted model has not seen. She then repeats this model for the nine other folds, to get a sense of the distribution of the performance of the model, or average performance, on out-of-sample data. If there are hyperparameters (which are parameters that describe some higher-order aspect of a model and not learned from the data in the usual way other prarameters are; they’re difficult to define rigorously), she may try different combinations of them and see which combination lead to the model with the best predictive ability in cross-validation. After determining which predictive model generally leads to the best results and which hyperparameters lead to optimal results, she trains a model on the training set with those hyperparameters, evaluates its performance on the test set, and reports the results, perhaps deploying the model.</p>
<p>For those developing trading algorithms, the goals are similar, but there are some key differences:</p>
<ol>
<li>We evaluate a trading method not by predictive accuracy but by some other measure of performance, such as profitability or profitability relative to risk. (<em>Maybe</em> predictive accuracy is profitable, maybe not; if the most profitable trading system always underestimates its profitability, we’re fine with it.)</li>
<li>We are using data where time and the order in which data comes in is thought to matter. We cannot just reshuffle data; important features would be lost. So we cannot divide up the data set randomly into different folds; order must be preserved.</li>
</ol>
<p>I’ll talk more about how we could evaluate a trading system later; for now, let’s focus on how we can apply the idea of cross-validation analysis.</p>
<p><img alt="Walk-forward analysis, from the book The caret Package* by Max Kuhn; http://topepo.github.io/caret/splitting/Split_time-1.png" src="https://ntguardian.files.wordpress.com/2017/05/split_time-1.png?w=456" data-recalc-dims="1"></p>
<p><em>(Illustration by Max Kuhn in his book,</em> <a target="_blank" rel="nofollow" href="http://topepo.github.io/caret/splitting/Split_time-1.png">The <code>caret</code> Package</a><em>.)</em></p>
<p>For time-dependent data, we can employ walk-forward analysis or rolling forecast origin techniques. This comes in various flavors (see the above illustration), but I will focus on one flavor. We first divide up the data set into, say, ten periods. We first fit a trading algorithm on the first period in the data set, then see how it performs on the “out-of-sample” second period. Then we repeat for the second and third periods, third and fourth periods, and so on until we’ve run to the end of the data set. The out-of-sample data sets are then used for evaluating the potential performance of the trading system in question. If we like, we may be keeping a final data set, perhaps the most recent data set, for final evaluation of whatever trading system passes this initial test.</p>
<p>Other variants include overlapping training/testing periods (as described, my walk-forward analysis approach does not overlap) or ones where the initial window grows from beginning to end. Of these, I initially think either the approach I’ve described or the approach with overlapping training/testing periods makes most sense.</p>
<h2>Attempting to Use <strong>quantstrat</strong></h2>
<p>I discovered that <strong>quantstrat</strong> has a function that I <em>thought</em> would implement the type of walk-forward analysis I wanted, called <code>walk.forward()</code>. I was able to define a training period duration, a testing period duration, an objective function to maximize, and many other features I wanted. It could take a strategy designed for optimization with <code>apply.paramset()</code> and apply a walk-forward analysis.</p>
<p>So I tried it once and the results were cryptic. The function returns a list with the results of training… but no sign of the test results. I would try looking at the portfolio object and <code>tradeStats()</code> output, but there was no sign of a portfolio. I had no idea why. I still have no idea where the portfolio went initially. I would try clearing my environments and restarting R and doing the whole process again. Same results: no sign of a portfolio, and all I got was a list of results for training data, with no sign of results for testing data. I looked at the source code. I saw that it was doing <em>something</em> with the test data: it was using <code>applyStrategy()</code> on the test data.</p>
<p>I had no idea what the hell that meant. When I use <code>applyStrategy()</code> as the user, I have to assume that the portfolio is wiped out, the account is reset, and every application is effectively a fresh start. So when I saw that line, it looked as if the function got an optimized function, applied it to the test data, and would repeat this process all the while forgetting the results of previous applications of the optimized strategy to test data sets. But online sources said that was <em>not</em> what was happening; the results of this backtesting were being appended back-to-back, which did not mesh with either my notion of walk-forward analysis (which allows for overlapping time frames, which does not mean you can “glue” together test data results) or what <code>applyStrategy()</code> does. And it still does not make sense to me. (That is what it does, though.)</p>
<p>The fact that the demonstration of <code>walk.forward()</code> supplied with <strong>quantstrat</strong> is bugged (and I never found how to fix all its bugs) didn’t help.</p>
<p>So I tried using the function’s auditing feature; by supplying a string to <code>audit.prefix</code>, <code>*.RData</code> files will be created containing the results of training and testing, storing them in a special <code>.audit</code> environment. So I changed the working directory to one specifically meant for the audit files (there could be a lot of them and I didn’t want to clutter up my other directories; I hate clutter), passed a string to <code>audit.prefix</code>, and tried again. After the analysis was completed, I look in the directory to see the files.</p>
<p>There’s nothing there.</p>
<p>It took hours and I had to go through a debugger to finally discover that <code>walk.forward()</code> <em>was</em> saving files, but it was using my Documents directory as the working directory, not the directory I <code>setwd()</code>ed into. Why? I have no idea. It could be <strong>quantstrat</strong>, <strong>blotter</strong>, or RStudio’s workbooks. I have no idea how long it took to figure out where my files had gone, but it was too long however long it was.</p>
<p>Good news though was that I now could try and figure out what was happening to the test data. <a target="_blank" rel="nofollow" href="https://4310b1a9-a-a8fb2076-s-sites.googlegroups.com/a/r-programming.org/home/files/WFA.pdf?attachauth=ANoY7cpt-IfFGdChackzf9TZgof47XSr2zN8MZ6FRLQZz7Gt3xh8066hZ0OC2zweRUzLZA6oEsnXCjPs_HtpjvFqLoVHlq3PRk6Mr3Z7y300iRnl4YllQtCewPcXNF1aOyDcswEG9qaxP55h0CbPcN3vBWOD5Wvr1LycCD64tRo1YWukMF9muYEx7mQqUymS2LMfsFwMKdX7vETw0MTLUswoM7OclM6kBQ%3D%3D&attredirects=2">This presentation by Guy Yollin</a> was helpful, though it still took a while to get it figured out.</p>
<p>From what I can tell, what <code>walk.forward()</code> does is simulate a trading strategy that optimizes, trades, and re-optimizes on new data, and trades. So it doesn’t look like cross-validation as I described but rather a trading strategy, and that’s not really what I wanted here. I wanted to get a sense of the distribution of returns when using window sizes chosen optimally from backtesting. I don’t think there’s any simple way to do that with <strong>quantstrat</strong>.</p>
<p>Furthermore, I can’t see how I can collect the kind of statistics I want, such as a plot of the value of the account or the account’s growth since day one, with the way the walk-forward analysis is being done. Furthermore, the results I did get look… strange. I don’t know how those kinds of results would appear… at all. They look like nonsense. So I don’t even know if the function is working right.</p>
<p>Oh, did I mention that I discovered that the way I thought backtesting was being done isn’t how it’s actually done in <strong>quantstrat</strong>? When I was doing backtesting, I would rather see the results of the backtest on a variety of stocks instead of just one. I imagine an automated backtest behaving like a trader with an account, and active trades tie up the trader’s funds. So if the trader sees an opportunity but does not have the cash to act on it, the trader does not take the trade. (There is no margin here.)</p>
<p>I thought <code>applyStrategy()</code> was emulating such a trader, but the documentation (and the logs produced, for that matter), suggest that’s <em>not</em> what’s happening. It backtests on each symbol separately, unaware of any other positions that may exist. I don’t like that.</p>
<p>It was very difficult to figure this all out, especially given the state of the documentation currently. That said, in the developers’ defense, <strong>quantstrat</strong> is still considered under heavy development. Maybe in the future the documentation will be better. I feel, though, that creating good documentation is not something done once you’ve completed coding; you write good documentation <em>as</em> you code, not <em>after</em>.</p>
<h2><strong>blotter</strong>: The Fatal Flaw</h2>
<p>Granted, I’m an ignorant person, but I don’t feel like all the confusion that lead to me wasting my weekend is completely my fault. <strong>quantstrat</strong>‘s design is strange and, honestly, not that intuitive. I think the problem stems from <strong>quantstrat</strong>‘s building off an older, key package: <strong>blotter</strong>.</p>
<p><strong>blotter</strong> is a package intended to manage transactions, accounts, portfolios, financial instruments, and so on. All the functions for creating accounts and portfolios are <strong>blotter</strong> functions, not <strong>quantstrat</strong> functions. <strong>blotter</strong> does this by setting up its own environment, the <strong>.blotter</strong> environment, and the functions I’ve shown are for communicating with this environment, adding and working with entities stored in it.</p>
<p>I don’t know what the purpose of creating a separate environment for managing those objects is. I feel that by doing so a wall has been placed between me and the objects I’m trying to understand. <strong>quantstrat</strong> takes this further by defining a <strong>.strategy</strong> environment where strategies actually “live”, so we must use special functions to interact with that separate universe, adding features to our strategies, deleting and redefining them with special functions, and so on.</p>
<p>To me, this usage of environments feels very strange, and I think it makes <strong>quantstrat</strong> difficult and unintuitive. In some sense, I feel like strategies, portfolios, accounts, etc. are pseudo-objects in the object oriented programming (OOP) sense, and the developers of <strong>blotter</strong> and <strong>quantstrat</strong> are trying to program like R is a language that primarily follows the OOP paradigm.</p>
<p>While R does support OOP, it’s a very different kind of OOP and I would not call R an OOP language. R is a <em>functional</em> programming language. Many see the <strong>tidyverse</strong> as almost revolutionary in making R easy to use. That’s because the <strong>tidyverse</strong> of package, including <strong>ggplot2</strong>, <strong>magrittr</strong>, <strong>dplyr</strong>, and others, recognize that R relies on the functional programming paradigm and this paradigm does, in fact, lead to elegant code. Users can write pipelines and functions to put into pipelines that make complicated tasks easy to program. No part of the pipeline is cut off from the user, and the process of building the pipeline is very intuitive.</p>
<p>When I wrote my first blog post on R for finance and trading, one of the common comments I heard was, “<strong>tidyquant</strong> is better.” I have yet to look seriously at <strong>tidyquant</strong>, and maybe it is better, but so far all I’ve seen is <strong>tidyquant</strong> replace <strong>quantmod</strong>‘s functionality, and I have no complaint with <strong>quantmod</strong> (although <strong>tidyquant</strong> may also be suffering from the original sin of relying too heavily on environments). That said, the <strong>tidyquant</strong> approach may yet be the future of R backtesting.</p>
<p>Let’s try re-imagining what a better R backtesting package might look like, one that takes lessons from the <strong>tidyverse</strong>. Let’s first look at defining a strategy with <strong>quantstrat</strong> (after all the obnoxious boilerplate code).</p>
<pre>
portfolio_st &lt;- &quot;myStrat&quot;

rm.strat(strategy_st)  # Must be done to delete or define a new strategy
strategy(strategy_st, store = TRUE)  # This is how to create a strategy

add.indicator(strategy = strategy_st, name = &quot;SMA&quot;,
              arguments = list(x = quote(Cl(mktdata)),
                               n = 20),
              label = &quot;fastMA&quot;)
add.indicator(strategy = strategy_st, name = &quot;SMA&quot;,
              arguments = list(x = quote(Cl(mktdata)),
                               n = 50),
              label = &quot;slowMA&quot;)

add.signal(strategy = strategy_st, name = &quot;sigCrossover2&quot;,  # Remember me?
           arguments = list(columns = c(&quot;fastMA&quot;, &quot;slowMA&quot;),
                            relationship = &quot;gt&quot;),
           label = &quot;bull&quot;)
add.signal(strategy = strategy_st, name = &quot;sigCrossover2&quot;,
           arguments = list(columns = c(&quot;fastMA&quot;, &quot;slowMA&quot;),
                            relationship = &quot;lt&quot;),
           label = &quot;bear&quot;)
add.rule(strategy = strategy_st, name = &quot;ruleSignal&quot;,
         arguments = list(sigcol = &quot;bull&quot;,
                          sigval = TRUE,
                          ordertype = &quot;market&quot;,
                          orderside = &quot;long&quot;,
                          replace = FALSE,
                          TxnFees = &quot;fee&quot;,
                          prefer = &quot;Open&quot;,
                          osFUN = osMaxDollarBatch,
                          maxSize = quote(floor(getEndEq(account_st,
                                                   Date = timestamp) * .1)),
                          tradeSize = quote(floor(getEndEq(account_st,
                                                   Date = timestamp) * .1)),
                          batchSize = 100),
         type = &quot;enter&quot;, path.dep = TRUE, label = &quot;buy&quot;)
add.rule(strategy = strategy_st, name = &quot;ruleSignal&quot;,
         arguments = list(sigcol = &quot;bull&quot;,
                          sigval = TRUE,
                          ordertype = &quot;market&quot;,
                          orderside = &quot;long&quot;,
                          replace = FALSE,
                          TxnFees = &quot;fee&quot;,
                          prefer = &quot;Open&quot;,
                          osFUN = osMaxDollarBatch,
                          maxSize = quote(floor(getEndEq(account_st,
                                                   Date = timestamp) * .1)),
                          tradeSize = quote(floor(getEndEq(account_st,
                                                   Date = timestamp) * .1)),
                          batchSize = 100),
         type = &quot;enter&quot;, path.dep = TRUE, label = &quot;buy&quot;)
add.rule(strategy = strategy_st, name = &quot;ruleSignal&quot;,
         arguments = list(sigcol = &quot;bear&quot;,
                          sigval = TRUE,
                          orderqty = &quot;all&quot;,
                          ordertype = &quot;market&quot;,
                          orderside = &quot;long&quot;,
                          replace = FALSE,
                          TxnFees = &quot;fee&quot;,
                          prefer = &quot;Open&quot;),
         type = &quot;exit&quot;, path.dep = TRUE, label = &quot;sell&quot;)
add.distribution(strategy_st,
                 paramset.label = &quot;MA&quot;,
                 component.type = &quot;indicator&quot;,
                 component.label = &quot;fastMA&quot;,
                 variable = list(n = 5 * 1:10),
                 label = &quot;nFAST&quot;)
add.distribution(strategy_st, paramset.label = &quot;MA&quot;,
                 component.type = &quot;indicator&quot;, component.label = &quot;slowMA&quot;,
                 variable = list(n = 5 * 1:10), label = &quot;nSLOW&quot;)
add.distribution.constraint(strategy_st,
                            paramset.label = &quot;MA&quot;,
                            distribution.label.1 = &quot;nFAST&quot;,
                            distribution.label.2 = &quot;nSLOW&quot;,
                            operator = &quot;&lt;&quot;,
                            label = &quot;MA.Constraint&quot;)
</pre>
<p>After all this code, we have a strategy that lives in the <code>.strategy</code> environment, locked away from us. What if we were to create strategies like we create plots in <strong>ggplot2</strong>? The code might look like this:</p>
<pre>
myStrat &lt;- strategy() +
               indicator(SMA, args = list(x = Close, n = 20),
                         label = &quot;fastMA&quot;) +
               indicator(SMA, args = list(x = Close, n = 50),
                         label = &quot;slowMA&quot;) +
               signal(sigCrossover, quote(fastMA > slowMA), label = &quot;bull&quot;) +
               signal(sigCrossover, quote(fastMA &lt; slowMA), label = &quot;bear&quot;) +
               rule( ..... ) +
               rule( ..... ) +
               distribution( ...... ) +
               distribution( ...... ) +
               distribution_constraint( ...... )
</pre>
<p>In <strong>blotter</strong> (and thus <strong>quantstrat</strong>) we create porfolios and accounts like so:</p>
<pre>
portfolio_st &lt;- &quot;myPortf&quot;
account_st &lt;- &quot;myAcct&quot;

rm.strat(portfolio_st)
rm.strat(account_st)
# This creates a portfolio
initPortf(portfolio_st, symbols = symbols,
          initDate = initDate, currency = &quot;USD&quot;)
# Then an account
initAcct(account_st, portfolios = portfolio_st,
         initDate = initDate, currency = &quot;USD&quot;,
         initEq = 100000)
# And finally an orderbook
initOrders(portfolio_st, store = TRUE)
</pre>
<p>Then we run the strategy with:</p>
<pre>
applyStrategy(strategy_st, portfolios = portfolio_st)
</pre>
<p>and we see the results with this code:</p>
<pre>
updatePortf(portfolio_st)
dateRange &lt;- time(getPortfolio(portfolio_st)$summary)[-1]
updateAcct(account_st, dateRange)
updateEndEq(account_st)
tStats &lt;- tradeStats(Portfolios = portfolio_st, use=&quot;trades&quot;,
                     inclZeroDays = FALSE)
tStats[, 4:ncol(tStats)] &lt;- round(tStats[, 4:ncol(tStats)], 2)
print(data.frame(t(tStats[, -c(1,2)])))

final_acct &lt;- getAccount(account_st)
plot(final_acct$summary$End.Eq[&quot;2010/2016&quot;] / 100000,
     main = &quot;Portfolio Equity&quot;, ylim = c(0.8, 2.5))
lines(SPY$SPY.Adjusted / SPY$SPY.Adjusted[[1]], col = &quot;blue&quot;)
</pre>
<p>A <strong>tidyverse</strong> approach might look like the following:</p>
<pre>
# Create an account with a pipe
myAcct &lt;- symbols %>%
            portfolio(currency = &quot;USD&quot;) %>%
            account(currency = &quot;USD&quot;, initEq = 100000)

# Backtesting generates an object containing the orderbook and all other
# necessary data (such as price at trade)
ob &lt;- myAcct %>% myStrat  # This is a backtest
</pre>
<p>Other functions would then extract any information we need from the object <code>ob</code>, when we ask for them.</p>
<p>If I wanted to optimize, I might do the following:</p>
<pre>
ob_list &lt;- myAcct %>% myStrat(optim = &quot;MA&quot;)  # Gives a list of orderbooks, and
                                             # optimizes the parameter set MA
</pre>
<p>And as for the original reason I started to gripe, I might be able to find slices for the analysis with <strong>caret</strong> functions (they exist), subset the data in <code>symbols</code> according to these slices, and get <code>ob</code> in, say, an <code>lapply()</code> loop.</p>
<p>I like the idea for this interface, myself.</p>
<h2>Conclusion (On To Python)</h2>
<p>I do not have the time to write a package like this myself. I don’t know enough and I <em>am</em> a Ph.D. student and <em>should</em> be preparing for qualifying exams/research/etc.. For now, though, I’m turned off to <strong>quantstrat</strong>, and thus R for backtesting and trading.</p>
<p>That said, my stock data analysis posts are still, by far, the most popular content of this blog, and I still would like to find a good backtesting system. I’m looking at going back to Python, and the <a target="_blank" rel="nofollow" href="https://www.backtrader.com/"><strong>backtrader</strong></a> package has caught my eye. I will either use that or <a target="_blank" rel="nofollow" href="http://www.zipline.io/index.html"><strong>zipline</strong></a>, but I am leaning to <strong>backtrader</strong>, since initially I like its logging features and its use of OOP.</p>
<p>I would love to hear thoughts and comments, especially from users of either <strong>backtrader</strong> or <strong>zipline</strong> or Python for stock data analysis in general.</p>
<p> <a target="_blank" rel="nofollow" href="http://feeds.wordpress.com/1.0/gocomments/ntguardian.wordpress.com/2938/"><img alt="" src="http://feeds.wordpress.com/1.0/comments/ntguardian.wordpress.com/2938/" border="0"></a> <img alt="" src="https://i1.wp.com/pixel.wp.com/b.gif?resize=1%2C1&ssl=1" border="0" data-recalc-dims="1"></p>
<p>
<div>
<div>To <strong>leave a comment</strong> for the author, please follow the link and comment on their blog: <strong><a href="https://ntguardian.wordpress.com/2017/05/22/the-end-of-the-honeymoon-falling-out-of-love-with-quantstrat/"> R – Curtis Miller's Personal Website</a></strong>.</div>
<hr>
<a rel="nofollow" href="https://www.r-bloggers.com/">R-bloggers.com</a> offers <strong><a rel="nofollow" href="https://feedburner.google.com/fb/a/mailverify?uri=RBloggers">daily e-mail updates</a></strong> about <a title="The R Project for Statistical Computing" rel="nofollow" href="https://www.r-project.org/">R</a> news and <a title="R tutorials" rel="nofollow" href="https://www.r-bloggers.com/search/tutorial">tutorials</a> on topics such as: <a title="Data science" rel="nofollow" href="https://www.r-bloggers.com/search/data%20science">Data science</a>, <a title="Big Data" rel="nofollow" href="https://www.r-bloggers.com/search/Big%20Data">Big Data, <a title="R jobs" rel="nofollow" href="https://www.r-users.com/">R jobs</a>, visualization (<a title="ggplot and ggplot2 tutorials" rel="nofollow" href="https://www.r-bloggers.com/search/ggplot2">ggplot2</a>, <a title="Boxplots using lattice and ggplot2 tutorials" rel="nofollow" href="https://www.r-bloggers.com/search/boxplot">Boxplots</a>, <a title="Maps and gis" rel="nofollow" href="https://www.r-bloggers.com/search/map">maps</a>, <a title="Animation in R" rel="nofollow" href="https://www.r-bloggers.com/search/animation">animation</a>), programming (<a title="RStudio IDE for R" rel="nofollow" href="https://www.r-bloggers.com/search/RStudio">RStudio</a>, <a title="Sweave and literate programming" rel="nofollow" href="https://www.r-bloggers.com/search/sweave">Sweave</a>, <a title="LaTeX in R" rel="nofollow" href="https://www.r-bloggers.com/search/LaTeX">LaTeX</a>, <a title="SQL and databases" rel="nofollow" href="https://www.r-bloggers.com/search/SQL">SQL</a>, <a title="Eclipse IDE for R" rel="nofollow" href="https://www.r-bloggers.com/search/eclipse">Eclipse</a>, <a title="git and github, Version Control System" rel="nofollow" href="https://www.r-bloggers.com/search/git">git</a>, <a title="Large data in R using Hadoop" rel="nofollow" href="https://www.r-bloggers.com/search/hadoop">hadoop</a>, <a title="Web Scraping of google, facebook, yahoo, twitter and more using R" rel="nofollow" href="https://www.r-bloggers.com/search/Web+Scraping">Web Scraping</a>) statistics (<a title="Regressions and ANOVA analysis tutorials" rel="nofollow" href="https://www.r-bloggers.com/search/regression">regression</a>, <a title="principal component analysis tutorial" rel="nofollow" href="https://www.r-bloggers.com/search/PCA">PCA</a>, <a title="Time series" rel="nofollow" href="https://www.r-bloggers.com/search/time+series">time series</a>, <a title="finance trading" rel="nofollow" href="https://www.r-bloggers.com/search/trading">trading</a>) and more...
<img height="1" alt="" width="1" src="http://feeds.feedburner.com/~r/RBloggers/~4/GaidogcwIIA"></a></div>