Just like the performance of a stock, the performance of a company is measured by numerical indicators. They are named key figures. Key figures play a major role in quality management, such as the ISO 9000 standards. An ISO 9000 key figure is a detail indicator, such as the number of faults in a production line, the number of bugs found in a beta test, the number of new clients acquired per day, the total of positive minus negative online reviews, an so on. Aside from being essential for an ISO 9000 certification, these key figures have two purposes:

• They give detailed insight and expose strengths and weaknesses.
• And they give a strong motivation for reaching a certain goal.

The script below opens a user interface for entering various sorts of key figures. It calculates an overall score that reflects the current performance of a company – or of a person – and displays it in a chart. If you use it not for a company, but for yourself, it helps improving your personal life. And from the short script you can see how to create a relatively complex software with relatively few lines of code.

Hackers like the concept of key figures. They are plain numbers that you can work with. Anyone can define key figures for herself. If you’re a writer, an important key figure is the number of words you’ve written today; if you’re an alcolohic, it’s the number of drinks you had today. Many self-improvement books tell you precisely what you need to do for living a healthier, wealthier, happier life – but they all suffer from the same problem: long-term motivation. If you lack the iron will to keep your daily exercises, reduce smoking, stay away from fast food, and so on – all good resolutions will eventually fall into oblivion. If you had resolutions for 2025, you’ll soon know what I mean.

Failure is less likely when you can observe your progress any day and see its immediately effect on your overall performance score. This score is a direct measure of your success in live. Whether you’re a company or a person, you want to keep this core rising. This feedback produces a strong motivation, every day again.

The above performance chart is plotted by the key figure management script in C for the Zorro platform. The red line is the overall score, derived from all key figures in a way explained below. The blue line is the key figure for which you just entered a new value (in the example it’s the number of large or small features implemented in the last 6 months in the Zorro platform). The X axis is the date in YYMMDD format.

Of course, key figures can be very different. Some may have a daily goal, some not, some shall sum up over time, others (like your bank account value) are just taken as they are. The idea is that your overall score rises when you exceed the daily goals, and goes down otherwise. All key figures and their parameters can be freely defined in a CSV file, which can be edited with a text editor or with Excel. It looks like this:

In the first column you can assign a name. The second column is the number of decimals in the display, the third is their unit in the overall score, the fourth is an offset in the score, the fifth is the daily goal, and the last tells if the figures shall sum up over time (1) or not (0).

Example. Suppose you’re a president of a large country and want to pimp up your personal performance. What’s your key figures? First, of course, approval rate. Any tenth percent adds one point to your score. So the first entry is simple:

Name, Decimals, Unit, Offset, Growth, Sum
Appr, 1, 0.1, 0, 0, 0

Next, fame. Key figure is the daily number of praises on Fox News, OneAmerica, and Newsmax. You’ve ordered a White House department to count the praises; of course you’re personally counting them too, just in case. Less than 30 praises per day would be bad and reduce your score, more will improve it. So 30 praises are daily subtracted from your score. Any 10 further praises add one point. This is an accumulative key figure:

Praise, 0, 10, 0, -30, 1

Next, health. Key figure is weight. Your enemies spread rumors that you’re unfit and obese. Your doctors urge you to shed weight. So you want to lose one pound every month, which (you have your mathematicians for calculating difficult things) is about 0.033 per day. Any lost 0.1 pound adds one point to your score. The numbers are negative since you want your weight to go down, not up. The offset is your current weight.

Weight, 1, -0.1, -250, 0.033, 0

Next, literacy. Your enemies spread rumors you’re illiterate. To prove them wrong, you’ve decided to read at least half a page per day in a real book (you’ve chosen Duck for President to begin with). Any further half page adds one point to your score. This is also an accumulative figure.

Duck, 1, 0.5, 0, -0.5, 1

Finally, net worth. You’ve meanwhile learned to better avoid business attempts. Let your net worth grow due to the value increase of your inherited real estate, which is currently at 6 billion. Any million further growth adds one point to your score (numbers given in millions):

Worth, 0, 1, -6000, 0, 0

For improving your personal performance, download the script from the 2025 repository. Copy the files KeyFigures.csv and KeyFigures.c in your Strategy folder. Edit KeyFigures.csv for entering your personal key figures, as in the above example (you can later add or remove key figures and use Excel to add or remove the new columns to the data file). This is the script:

// Pimp Your Performance with Key Figures //////////////////////

string Rules = "Strategy\\KeyFigures.csv";
string Data = "Data\\KeyData.csv"; // key figures history
string Format = "0%d.%m.%Y,f1,f,f,f,f,f,f,f,f,f,f,f,f,f,f";
int Records,Fields;

var value(int Record,int Field,int Raw)
{
	var Units = dataVar(1,Field,2);
	var Offset = dataVar(1,Field,3);
	var Growth = dataVar(1,Field,4);
	var Value = 0;
	int i;
	for(i=0; i<=Record; i++) {
		if(dataVar(2,i,Field+1) < 0.) continue; // ignore negative entries
		Value += Growth;
		if(i == Record || (dataInt(1,Field,5)&1)) // Sum up? 
			Value += dataVar(2,i,Field+1)+Offset;
	}
	if(Raw) return Value-Offset;
	else return Value/Units;
}

var score(int Record)
{
	int i,Score = 0;
	for(i=0; i<Fields; i++) 
		Score += value(Record,i,0);
	panelSet(Record+1,Fields+1,sftoa(Score,0),YELLOW,16,4);
	return Score;
}


void click(int Row,int Col)
{
	dataSet(2,Row-1,Col,atof(panelGet(Row,Col)));
	score(Row-1);
	if(dataSaveCSV(2,Format,Data)) sound("Click.wav");
	int i;
	for(i=0; i<Records; i++) {
		var X = ymd(dataVar(2,i,0)) - 20000000;
		plotBar("Score",i,X,score(i),LINE,RED);
		plotBar(dataStr(1,Col-1,0),i,NIL,value(i,Col-1,1),AXIS2,BLUE);
	}
	if(Records >= 2) plotChart("");
}

void main()
{
	int i = 0, j = 0;
	printf("Today is %s",strdate("%A, %d.%m.%Y",NOW));
	ignore(62);
	PlotLabels = 5;
// File 1: Rules
	Fields = dataParse(1,"ssss,f1,f,f,f,i",Rules);
// File 2: Content
	Records = dataParse(2,Format,Data);
	int LastDate = dataVar(2,Records-1,0);
	int Today = wdate(NOW);
	if(LastDate < Today) { // no file or add new line
		dataAppendRow(2,16);
		for(i=1; i<=Fields; i++)
			if(!(dataInt(1,i-1,5)&1))
				dataSet(2,Records,i,dataVar(2,Records-1,i));
		Records++;
	}
	dataSet(2,Records-1,0,(var)Today);

// display in panel
	panel(Records+1,Fields+2,GREY,-58);
	panelFix(1,0);
	print(TO_PANEL,"Key Figures");
	for(i=0; i<Fields; i++)
		panelSet(0,i+1,dataStr(1,i,0),ColorPanel[0],16,1);
	panelSet(0,i+1,"Score",ColorPanel[0],16,1);
	panelSet(0,0,"Date",ColorPanel[0],16,1);
	for(j=0; j<Records; j++) {
		panelSet(j+1,0,strdate("%d.%m.%y",dataVar(2,j,0)),ColorPanel[0],0,1);
		score(j);
		for(i=0; i<Fields; i++) 
			panelSet(j+1,i+1,sftoa(dataVar(2,j,i+1),-dataVar(1,i,1)),ColorPanel[2],0,2);
	}
	panelSet(-1,0,"Rules",0,0,0);
}

The file locations and the CSV format of the key figures history are defined at the begin. The value function calculates the contribution of a particular key figure to the overall score. The score function updates the overall score. The click function, which is called when you enter a new value, calculates the score of that day, updates the spreadsheet, and prints the chart. The main function imports the data and key figures from their CSV files into datasets, prints the current day and displays a spreadsheet of your key figures and score history, like this:

 

 
You will need Zorro S because the spreadsheet function is not available in the free version. Start the script any morning. It will open the spreadsheet, where you can click in any of the white fields and enter a new key figure value for today. You can anytime enter new figures for today or for past days. At any entry, the score is calculated and – if the history spans more than 2 days – a chart is plotted as in the above example.

Normally, personal performance depends on about 5-10 key figures (maximum is 15). For instance, miles you’ve jogged today, steps walked, exercises done, pages read, words written, words learned in a new language, value of your bank account, value of your stock portfolio, burgers eaten, cigarettes smoked, enemies killed, or number of old ladies you helped crossing the street. If you’re a president, consider the script a free present (we hope for generous tax exceptions in exchange). If you’re an ISO 9000 certified company and want to use the script for your quality management, please contact oP group to pay your fee. For personal use, the script is free. Pimp your performance and make the world a better place!

Bitcoin – hodl??

A buy and hold strategy works extremely well when a price bubble grows, and extremely bad when it bursts. And indeed, apparently all finance and economy gurus (well, all but John McAfee) tell you that the cryptocurrency market, and especially bitcoin, is a bubble, even a “scam with no substantial worth”, and will soon experience a crash “worse than the 17th century tulip mania” or the “18th century South Sea Company fraud”.

By definition, a bubble is a price largely above the ‘real value’ or ‘fair value’ of an asset, and it bursts when people realize that. So what is the fair value of a bitcoin? Obviously not zero, since blockchain based currencies have (aside from their disadvantages) several advantages over traditional currencies, on the economy level as well as on the private level. Such as:

• They break the link of money and debt. Cryptocurrencies don’t require the bank credit mechanism for money creation.
• They can be used where normal money would be impractical, such as fee transfers between machines or trading in multiplayer games.
• They allow low-cost and anonymous money transactions. At least in theory.
• They replace banks for storing and mattresses for stashing money.

I’m ready to believe that blockchain is the future of money transfer and storage. But that does not mean an ever-rising bitcoin price. Hundreds of cryptocurrencies came out in the last two years, any single of them with a better blockchain technology than bitcoin, and any good programmer can add a new coin anytime. Few will survive. Countries or big companies might sooner or later issue their own crypto tokens, as Venezuela already is attempting. The release of an official blockchain Dollar, Yuan, or Euro would leave the old bitcoin with its energy hungry transaction algorithm in thin air. Thus, when investing in bitcoin, we should not hope for a rosy future, but look for its present ‘real value’.

Due to its extreme volatility, bitcoin can not replace bank tresors. But it is already used in some situations for reducing money transfer costs, since the miners get any transaction rewarded in bitcoin. And above all, anonymity can be a substantial motive to own it. When you need a hacker to delete your drunk driving record, pay her in bitcoin. But how big is the online market for illegal hacker jobs, kill contracts, money laundering, drugs, weapons, or pro-Trump facebook advertisements? No one knows, but when we compare it with cash, another form of anonymous payment, we get interesting results.

The current cash in circulation in the US is approximately $1.5 trillion dollars. And the current bitcoin supply, about 17 million bitcoins, represents a total value of about $250 billion. Which means that you can already replace 15% of all US cash with bitcoin! Not to mention all the other cryptos. I fear that this supply already exceeds the demand of anonymous online payment for today and also the next future.

For those reasons, a bitcoin “hodl” system, despite its extreme historical performance, is high risk. We don’t know when and how the bubble will burst – maybe bitcoin will go up to $100,000 before – but we have some reason to suspect that at some point sooner or later the bitcoin price might drop like a stone down to its ‘real value’. Which is unknown, but for practical purposes is probably not in the $15,000 area, but more like $15.

So we need some other method to tackle the cryptocurrency trading problem. The first question: Has the crypto market already developed price curve inefficiencies that can be exploited in a trading system? In (1) we see some tests with basic bitcoin strategies. Our own tests came to the same results. Momentum based strategies can work, and mean-variance optimizing portfolio systems can achieve even extreme returns with crytrocurrencies – up to 10 times higher than “hodl”. But that’s not really surprising due to the high momentums and volatilities of crypto coins. The problem is that all crypto portfolios are exposed to high risk. Other conventional model-based strategies don’t work well anyway with cryptos.

When we concentrate on bitcoin, our proposed system must be a fast trading, trend-agnostic strategy. That means it holds positions only a few minutes, and is not exposed to the bubble risk. I can already tell that short-term mean reversion – even with a more sophisticated system as in (1) – produces no good result with cryptos. So only a few possibilities remain. One of them is exploiting short-term price patterns. This is the strategy that we will develop. And I can already tell that it works. But for this we’ll need a deep machine learning system for detecting the patterns and determining their rules.

Selecting a machine learning library

The basic structure of such a machine learning system is described here. Due to the low signal-to-noise ratio and to ever-changing market conditions, analyzing price series is one of the most ambitious tasks for machine learning. Compared with other AI algorithms, deep learning systems have the highest success rate. Since we can connect any Zorro based trading script to the data analysis software R, we’ll use a R based deep learning package. There are meanwhile many available. Here’s the choice:

• Deepnet, a lightweight and straightforward neural net library with a stacked autoencoder and a Boltzmann machine. Produces good results when the feature set is not too complex. The basic train and predict functions for using a deepnet autoencoder in a Zorro strategy:

  library('deepnet') 
  
  neural.train = function(model,XY) 
  {
    XY <- as.matrix(XY)
    X <- XY[,-ncol(XY)]
    Y <- XY[,ncol(XY)]
    Y <- ifelse(Y > 0,1,0)
    Models[[model]] <<- sae.dnn.train(X,Y,
        hidden = c(30), 
        learningrate = 0.5, 
        momentum = 0.5, 
        learningrate_scale = 1.0, 
        output = "sigm", 
        sae_output = "linear", 
        numepochs = 100, 
        batchsize = 100)
  }
  
  neural.predict = function(model,X) 
  {
    if(is.vector(X)) X <- t(X)
    return(nn.predict(Models[[model]],X))
  }
  

• H2O, an open-source software package with the ability to run on distributed computer systems. Coded in Java, so the latest version of the JDK is required. Aside from deep autoencoders, many other machine learning algorithms are supported, such as random forests. Features can be preselected, and ensembles can be created. Disadvantage: While batch training is fast, predicting a single sample, as usually needed in a trading strategy, is relatively slow due to the server/client concept. The basic H2O train and predict functions for Zorro:

  library('h2o') 
  # also install the Java JDK
  
  neural.train = function(model,XY) 
  {
    XY <- as.h2o(XY)
    Models[[model]] <<- h2o.deeplearning(
      -ncol(XY),ncol(XY),XY,
      hidden = c(30),  seed = 365)
  }
  
  neural.predict = function(model,X) 
  {
    if(is.vector(X)) X <- as.h2o(as.data.frame(t(X)))
    else X <- as.h2o(X)
    Y <- h2o.predict(Models[[model]],X)
    return(as.vector(Y))
  }

• Tensorflow in its Keras incarnation, a neural network kit by Google. Supports CPU and GPU and comes with all needed modules for tensor arithmetics, activation and loss functions, covolution kernels, and backpropagation algorithms. So you can build your own neural net structure. Keras offers a simple interface for that.

  Keras is available as a R library, but installing it requires also a Python environment. First install Anaconda from www.anaconda.com. Open the Anaconda Navigator and install the RStudio application (installing Keras outside an Anaconda environment fails on some PCs with an error message). Then open Rstudio inside the Navigator, install the Keras package, then finally execute library(‘keras’) and install_keras(). These steps usually succeed.

  The Keras train and predict functions for Zorro:

  library('keras')
  #needs Python 3.6 and Anaconda
  #call install_keras() after installing the package
  
  neural.train = function(model,XY) 
  {
    X <- data.matrix(XY[,-ncol(XY)])
    Y <- XY[,ncol(XY)]
    Y <- ifelse(Y > 0,1,0)
    Model <- keras_model_sequential() 
    Model %>% 
      layer_dense(units=30,activation='relu',input_shape = c(ncol(X))) %>% 
      layer_dropout(rate = 0.2) %>% 
      layer_dense(units = 1, activation = 'sigmoid')
    
    Model %>% compile(
      loss = 'binary_crossentropy',
      optimizer = optimizer_rmsprop(),
      metrics = c('accuracy'))
    
    Model %>% fit(X, Y, 
      epochs = 20, batch_size = 20, 
      validation_split = 0, shuffle = FALSE)
    
    Models[[model]] <<- Model
  }
  
  neural.predict = function(model,X) 
  {
    if(is.vector(X)) X <- t(X)
    X <- as.matrix(X)
    Y <- Models[[model]] %>% predict_proba(X)
    return(ifelse(Y > 0.5,1,0))
  }
  

• MxNet, Amazon’s answer on Google’s Tensorflow. Offers also tensor arithmetics and neural net building blocks on CPU and GPU, as well as high level network functions similar to Keras (the next Keras version will also support MxNet). Just as with Tensorflow, CUDA is supported, but not (yet) OpenCL, so you’ll need a Nvidia graphics card to enjoy GPU support. In direct comparison (2), MxNet was reported to be less resource hungry and a bit faster than Tensorflow, but so far I could not confirm this. The standard train and predict functions:

  # how to install the CPU version:
  #cran <- getOption("repos")
  #cran["dmlc"] <- "https://s3-us-west-2.amazonaws.com/apache-mxnet/R/CRAN/"
  #options(repos = cran)
  #install.packages('mxnet')
  library('mxnet')
  
  neural.train = function(model,XY) 
  {
    X <- data.matrix(XY[,-ncol(XY)])
    Y <- XY[,ncol(XY)]
    Y <- ifelse(Y > 0,1,0)
    Models[[model]] <<- mx.mlp(X,Y,
         hidden_node = c(30), 
         out_node = 2, 
         activation = "sigmoid",
         out_activation = "softmax",
         num.round = 20,
         array.batch.size = 20,
         learning.rate = 0.05,
         momentum = 0.9,
         eval.metric = mx.metric.accuracy)
  }
  
  neural.predict = function(model,X) 
  {
    if(is.vector(X)) X <- t(X)
    X <- data.matrix(X)
    Y <- predict(Models[[model]],X)
    return(ifelse(Y[1,] > Y[2,],0,1))
  }
  

By replacing the neural.train and neural.predict functions, and other functions for saving and loading models that are not listed here, you can run the same strategy with different deep learning packages and compare. We’re currently using Keras for most machine learning strategies, and I’ll also use it for the short-term bitcoin trading system presented in the upcoming 2nd part of this article. There is no bitcoin futures data available yet, so tick based price data from several bitcoin exchanges will have to do for the backtest.

I’ve uploaded the interface scripts for Deepnet, H2O, Tensorflow/Keras, and MxNet to the 2018 script repository, so you can run your own deep learning experiments and compare the packages. Here’s a Zorro script for downloading bitcoin prices from Quandl – EOD only, though, since the exchanges demand dear payment for their tick data.

void main()
{
  assetHistory("BITFINEX/BTCUSD",FROM_QUANDL);
}

You can also get Bitcoin M1 data from Kaggle in CSV format. Here’s a Zorro script for converting it to a Zorro T6 dataset:

void main()
{
	string InName = "History\\bitstampUSD_1-min_data_2012-01-01_to_2019-03-13.csv";
	string Format = "+%t,f3,f1,f2,f4,f6";
	dataParse(1,Format,InName); 
	dataSave(1,"History\\BTCUSD.t6");
}

Further reading

(1) Nicolas Rabener, Quant Strategies in the Cryptocurrency Space

(2) Julien Simon, Tensorflow vs MxNet

(3) Zachary Lipton et al, MxNet – The Straight Dope
(Good introduction in deep learning with MxNet / Gluon examples)

(4) F.Chollet/J.J.Allaire, Deep Learning with R
(Excellent introduction in Keras)

Coding contracts can work out well or fail miserably. It depends on you and on the coder. But mostly on you. As a contract coder* who often hires other contract coders, I got meanwhile some experiences with both sides of the medal. So here are some coder hiring suggestions for increasing the chance to get something useful back for your money.

Find the coder

There are three Internet places where you can look for strategy coders: trader forums, freelancer websites, and tool vendors. The latter is my preferred way to acquire coding manpower. I check out advertised indicators, trading systems, or software tools that have some relation to the project at hand. If I like what I see, I contact the developer and ask if she or he does contract work. Most do. This way I know that the new coder has knowledge about the subject, can bring in her experience, and can do commercial quality work.

When contracting on trader forums or freelancer websites, be aware that coding abilities are not equally distributed among the population. Speed and code quality by freelancers differ by factors up to 10. So you need some means to judge the coding beforehand. Check out example projects (obviously, don’t hire someone who has nothing to show). If you can’t decide among five coders, hire all five. Give them all a small task, a little script, something that can be done in about 3 hours. Pay all five for the small task, then select the one with the best work for the real project. The invested money is well spent. A connection to a good coder is a very valuable asset.

Grill the coder

Before hiring, interrogate the freelancer about his skills and his approach to the project. And put attention on clear and prompt answers. Many issues arise from misunderstanding. Freelance coders must be able to express themselves not only in script, but also in plain English. As you’ll most likely communicate by email, test the promptness. If it takes your aspiring coder three days to respond on an email even in the negotiating phase, he’ll likely need three weeks to react on an issue after delivery and payment – if at all.

One important thing to ask is how the coder tests his scripts. In software development, proper test procedures are more important than writing code. A good coder has some test framework for putting his code under stress. This is twice important when the coder, as I sometimes do, sub-contracts parts of the task to other coders. Understanding and testing other people’s scripts is an additional effort that pays back in better code quality.

Naturally you should also make sure that the coder has basic understanding of trading, and knowledge in math and statistics – or can at least quickly come to grips with a new field of knowledge. A degree in math, physics, engineering, or computer science is of advantage, even if it pushes up the coder’s fees. But understanding the algorithm on a deep level can be essential for coding a serious trade system. My favorite way to grill a coder was giving her a sheet of paper and asking her for a quick proof of Pythagoras’ theorem. Unfortunately, this only works in a face to face interview, not by email.

Feed the coder

An essential part of cooperation with coders is your project description. Know your goals precisely, but not too precisely. Some clients are able to describe clearly what they want. Others send long and utterly confused project specifications that leave you completely in the dark of what you have to code. From some clients I got laconic flow diagrams like this: “Analyze price curve with neural network – open position when profitable – close position at price maximum – repeat”. Others have 22-page concepts with a complex strategy described up to the finest detail of the user interface button colors. And as they felt that all this could somehow limit the flexibility, they usually require any detail to be adjustable with many different parameters and modes.

A trading strategy is no iPhone app. No one knows beforehand if your idea will work or not. If not, any implemented additional details are wasted money. So split your project into milestones. Or let the coder do it. The first milestone is always the proof of concept: a script of just your trade idea, with no stops, extra filters, money management, user interface, or other gimmicks. This should be coded at first, and carefully tested in all possible variants. If this script turns out to be profitable, go on with the next step. Otherwise you won’t need all the rest.

If your trade idea or algorithm is very secret, the coder should offer you a non-disclosure agreement. This way he accepts the responsibility to keep your trade method for himself. Which he should do anyway, of course.

Don’t listen to the coder

At least not to me. I used to advise clients about the success chances of their concept – even before coding and testing it. For instance I declared a certain strategy doomed to fail since it seemed just a complex hodgepodge of conventional indicators. The client was unimpressed. He told me to code it nevertheless. Now, 18 months later, he’s still living from the returns of that system. Since then I refrain from unsolicited advising.

But you should very well listen to the coder when he suggests different methods of implementing your system, or modifications for simplifying the algorithm or making it more effective. The coder possibly knows your algorithm better than you.

Pay the coder

I will be frank: For almost all coders (I’m no exception), coding is one of the greatest things on earth. For some, it’s better than sex. We all would code for free if there were no alternative. However, professional ethics and our bank account require that we demand payment.

Since coding speed can be very different, it’s normally not advised to pay a coder by hour, unless you’ve worked with her a long time and know her well. Normally the coder will quote the project at a fixed price. The price should include not only the coding, but also a support and warranty period after delivery. It usually does not include training the script or adjusting the parameters. This is your task, as it’s very time consuming and thus would be expensive, but requires no code knowledge.

Just as coding speed and quality, coding prices vary strongly among freelancers. Obviously the cheap price is not always the best. On the other hand, if the project is really interesting and the coder would really like to get the job, you can often negotiate a discount. Some ballpark figures: My own contracts start at EUR 170 per strategy, which is my employer’s required minimum for a simple script. Contracts for complex projects with options trading or machine learning algorithms are in the EUR 1000-2000 range; individual user interfaces, and special analysis or input / output methods can raise the contract to EUR 10,000 or more. My largest contract so far was 1.5 million EUR. Sadly, the small contracts are much more frequent than the large ones…

Coders usually demand advance payment. How much depends on your prominence in relation to the coder. If you are Warren Buffett and the coder is an unknown guy from India, you’ll be able to negotiate payment after delivery. If you’re a nondescript retail trader and the coder is employed by a large company, he’ll likely ask you for 100% advance payment. In most cases the terms will be 50% in advance and 50% after delivery.

If the script works, pay the rest immediately. This won’t cost you much, but makes a good impression on the coder. I only ever had one single case where the contract price was not paid at all. This is always a bad idea: We coders talk to each other. Not paying a contract might get you in trouble to ever find a coder again. Or worse: You might find one who implements a little surprise in your trading script…

Be independent of the coder

Even when you hire a coder, it makes sense when you acquire a basic understanding of coding – for instance through the Zorro tutorial. It will take a day or two. But it will allow you not only to better judge the code quality, but also to modify the script beyond just setting parameters. Then you don’t need to always wait for a new quote by the coder. And you save money. Remember, I have to charge EUR 170 (at least) no matter if I re-write the script completely or only modify a single line.

Conclusion

Be very, very meticulous in selecting a coder and working with her or him, and try to understand as much of the code and its structure as possible. This can be the deciding factor for the success of your project. – In case you’re curious about my above mentioned one point five million contract, or about the single case when a contract was not paid, or about my most bizarre experience as a hired coder so far: You can read that story here. But it is not suited for minors. So if you’re below 18, please do not click on that link. Thank you.

* Some coders prefer to be referred to as ‘programmers’. The rationale is that a coder just converts an algorithm in code, while a programmer develops the algorithm. This distinction is not really useful: You can not code a trading strategy when you’re illiterate in algorithms. Thus, I don’t care if I’m a coder or a programmer as long as I’m paid.

Because the money amount always corresponds to the same amount of private and public debt, this debt amount also must inevitably grow, in spite of all the political lamentoes. Reducing public debt would either destroy money or increase private debt proportionately. This happened in fact in the United States around the turn of the millennium, when then-President Bill Clinton managed to get by without borrowing, and even achieved a budget surplus. Which caused interests to drop and banks to look elsewhere for distributing their money. The indirect result of Clinton’s good deed was a massive increase in private debt that eventually led to the mortgage crash of 2007.

How to acquire it in large amounts

Money is considered a good thing in almost all cultures. After all, it allows you to do the things you want, and – even more important – not to do things you don’t want to do. It thus represents freedom. You can get to it with different methods. The most obvious is taking away other people’s money. Here’s the Top Ten fortunes by known villains, according to Forbes (in US $):

1. Hugo Drax – 7.6 billion
2. Auric Goldfinger – 6.5 billion
3. Max Zorin – 5.3 billion
4. Lex Luthor – 4.7 billion
5. Franz Sanchez – 1 billion
6. Ernst Stavro Blofeld – 640 million
7. Karl Stromberg – 640 million
8. Elektra King – 420 million
9. Francisco Scaramanga – 115 million
10. Dr. Julius No – 110 million

But the most successful in money taking are not, as you might think, drug cartel bosses or leaders of criminal underground organizations, but presidents and other heads of state. They can take their share of money with no risk, since they need not fear the law. Here’s the Top Ten of the acquired fortunes by this way (in US $):

1. Muammar Gaddafi, Libya – 55 billion
2. Hosni Mubarak, Egypt – 50 billion
3. Mohamed Suharto, Indonesia – 25 billion
4. Alexander Lukashenko, Belarus – 12 billion
5. Mobutu Sese Seko, Congo – 7 billion
6. Ben Ali, Tunisia – 4 billion
7. Gnassingbé Eyadéma, Togo – 4 billion
8. Obiang Nguema, Equatorial Guinea – 3 billion
9. Slobodan Milosevic, Serbia – 1 billion
10. ‘Baby Doc’ Duvalier, Haiti – 600 million

This list does naturally not include assets of monarchs such as the Sultan of Brunei, who have no need of pilfering because the country belongs to them by law anyway. Or of dictators like Wladimir Putin, whose estimated 125 billion booty (plus a 17,000 sqft palace) officially does not belong to them, but is kept for them by friendly oligarchs. The listed sums must also be considered in relation to the economy of the country. To bag 600 million in grinding poor Haiti is a much more impressive performance than the lousy one billion that Milosevic could siphon off in industrialized Serbia. But as long as you’re neither a supervillain, nor a head of state, nor both at the same time, you have no choice but to use other means to acquire money. There’s also the method of buying something cheap and selling it dear. Not as profitable as being a head of state, but it still can produce some handsome gains (annual income in US $):

1. Jim Simons, Renaissance – 1.7 billion
2. Ken Griffin, Citadel – 1.7 billion
3. Raymond Dalio, Bridgewater – 1.4 billion
4. David Tepper, Apaloosa – 1.4 billion
5. Izzy Englander, Millenium – 1.1 billion
6. David Shaw, Shaw Group – 750 million
7. John Overdeck, Two Sigma – 500 million
8. David Siegel, Two Sigma – 500 million
9. Andreas Halvorsen, Viking – 370 million
10. Joseph Edelman, Perceptive – 300 million

All in this list acquired their wealth with algorithmic trading. Which is the topic of most of the rest of this blog. It does not produce any goods. But on the other hand, it does not steal from anyone. On the contrary, private, small-scale financial trading can boost demand and soften economic inequality. It can redistribute money from the rich to the poor. So it should be rewarded by the government, for instance by a tax exemption. Well, one can dream, at least…

Why financial hacking?

Part of my job is developing financial tools and trading systems for clients. So far we coded hundreds of trading strategies with all sorts of algorithms for all sorts of financial instruments. Some worked and fulfilled the client’s expectations. Some failed miserably. And some worked in the backtest, but not in live trading. Coming from a background of theoretical physics and computer game programming, I wondered why trading seems not to be an exact science at all. What is the difference between a successful and a doomed strategy? And how can you determine that before actually trading it?

On this blog I’ll attempt a hacking approach to algorithmic trading. Hacking is nothing illegal, it’s just a pragmatic way to solve problems. Hackers prefer experiment over theory. They don’t give a damn about the wisdom of gurus or authorities. So I’ll start with considering all praised trade systems worthless and all “trader’s wisdom” irrational and nonsense until proven otherwise. I will try to evaluate by systematic experimenting whether, why, when, and how algorithmic trading does work. My goal is to find out how it can be a reliable income source for a private trader. This might require complex statistical or machine learning algorithms – but that’s no big deal with today’s software tools. All scripts and software to the articles will be put up for download, so anyone interested can reproduce all the results and use the strategies. After all, successful private trading is for the common good.

As this blog is about algorithmic trading, I’m going to post here a lot of algorithms and source code. Naturally not any trader is able to read code. On the other hand, some basic code and math understanding is required for making sense of the articles. To go from zero to a full understanding of the articles on this blog, here’s a list of Useful Books.