Renamed research to sandbox experiments

2 files changed, 605 insertions, 0 deletions

diff --git a/src/sandbox/encoding-binary-data-into-dna-sequence.md b/src/sandbox/encoding-binary-data-into-dna-sequence.md
new file mode 100644
index 0000000..3bfeaab
--- /dev/null
+++ b/src/sandbox/encoding-binary-data-into-dna-sequence.md
@@ -0,0 +1,345 @@
+title: Encoding binary data into DNA sequence
+date: 2019-01-03
+tags: research
+hide: false
+----
+
+## Initial thoughts
+
+Imagine a world where you could go outside and take a leaf from a tree and put it through your personal DNA sequencer and get data like music, videos or computer programs from it. Well, this is all possible now. It was not done on a large scale because it is quite expensive to create DNA strands but it's possible.
+
+Encoding data into DNA sequence is relatively simple process once you understand the relationship between binary data and nucleotides and scientists have been making large leaps in this field in order to provide viable long-term storage solution for our data that would potentially survive our specie if case of global disaster. We could imprint all the world's knowledge into plants and ensure the survival of our knowledge.
+
+More optimistic usage for this technology would be easier storage of ever growing data we produce every day. Once machines for sequencing DNA become fast enough and cheaper this could mean the next evolution of storing data and abandoning classical hard and solid state drives in data warehouses.
+
+As we currently stand this is still not viable but it is quite an amazing and cool technology.
+
+My interests in this field are purely in encoding processes and experimental testing mainly because I don't have the access to this expensive machines. My initial goal was to create a toolkit that can be used by everybody to encode their data into a proper DNA sequence.
+
+## Glossary
+
+**deoxyribose**
+:  A five-carbon sugar molecule with a hydrogen atom rather than a hydroxyl group in the 2′ position; the sugar component of DNA nucleotides.
+
+**double helix**
+:  The molecular shape of DNA in which two strands of nucleotides wind around each other in a spiral shape.
+
+**nitrogenous base**
+:  A nitrogen-containing molecule that acts as a base; often referring to one of the purine or pyrimidine components of nucleic acids.
+
+**phosphate group**
+:  A molecular group consisting of a central phosphorus atom bound to four oxygen atoms.
+
+**RGB**
+:  The RGB color model is an additive color model in which red, green and blue light are added together in various ways to reproduce a broad array of colors.
+
+**GCC**
+:  The GNU Compiler Collection is a compiler system produced by the GNU Project supporting various programming languages.
+
+## Data encoding
+
+**TL;DR:** Encoding involves the use of a code to change original data into a form that can be used by an external process [^1].
+
+Encoding is the process of converting data into a format required for a number of information processing needs, including:
+
+- Program compiling and execution
+- Data transmission, storage and compression/decompression
+- Application data processing, such as file conversion
+
+Encoding can have two meanings[^1]:
+
+- In computer technology, encoding is the process of applying a specific code, such as letters, symbols and numbers, to data for conversion into an equivalent cipher.
+- In electronics, encoding refers to analog to digital conversion.
+
+## Quick history of DNA
+
+- **1869** - Friedrich Miescher identifies "nuclein".
+- **1900s** - The Eugenics Movement.
+- **1900** – Mendel's theories are rediscovered by researchers.
+- **1944** - Oswald Avery identifies DNA as the 'transforming principle'.
+- **1952** - Rosalind Franklin photographs crystallized DNA fibres.
+- **1953** - James Watson and Francis Crick discover the double helix structure of DNA.
+- **1965** - Marshall Nirenberg is the first person to sequence the bases in each codon.
+- **1983** - Huntington's disease is the first mapped genetic disease.
+- **1990** - The Human Genome Project begins.
+- **1995** - Haemophilus Influenzae is the first bacterium genome sequenced.
+- **1996** - Dolly the sheep is cloned.
+- **1999** - First human chromosome is decoded.
+- **2000** – Genetic code of the fruit fly is decoded.
+- **2002** – Mouse is the first mammal to have its genome decoded.
+- **2003** – The Human Genome Project is completed.
+- **2013** – DNA Worldwide and Eurofins Forensic discover identical twins have differences in their genetic makeup [^2].
+
+## What is DNA?
+
+Deoxyribonucleic acid, a self-replicating material which is **present in nearly all living organisms** as the main constituent of chromosomes. It is the **carrier of genetic information**.
+
+> The nitrogen in our DNA, the calcium in our teeth, the iron in our blood, the carbon in our apple pies were made in the interiors of collapsing stars. We are made of starstuff.
+>
+> **-- Carl Sagan, Cosmos**
+
+The nucleotide in DNA consists of a sugar (deoxyribose), one of four bases (cytosine (C), thymine (T), adenine (A), guanine (G)), and a phosphate. Cytosine and thymine are pyrimidine bases, while adenine and guanine are purine bases. The sugar and the base together are called a nucleoside.
+
+![DNA](/files/dna-sequence/dna-basics.jpg#center)
+
+*DNA (a) forms a double stranded helix, and (b) adenine pairs with thymine and cytosine pairs with guanine. (credit a: modification of work by Jerome Walker, Dennis Myts) [^3]*
+
+## Encode binary data into DNA sequence
+
+As an input file you can use any file you want:
+- ASCII files,
+- Compiled programs,
+- Multimedia files (MP3, MP4, MVK, etc),
+- Images,
+- Database files,
+- etc.
+
+Note: If you would copy all the bytes from RAM to file or pipe data to file you could encode also this data as long as you provide file pointer to the encoder.
+
+### Basic Encoding
+
+As already mentioned, the Basic Encoding is based on a simple mapping. Since DNA is composed of 4 nucleotides (Adenine, Cytosine, Guanine, Thymine; usually referred using the first letter). Using this technique we can encode
+
+$$ log_2(4) = log_2(2^2) = 2 bits $$
+
+using a single nucleotide. In this way, we are able to use the 4 bases that compose the DNA strand to encode each byte of data.
+
+| Two bits | Nucleotides      |
+| -------- | ---------------- |
+| 00       | **A** (Adenine)  |
+| 10       | **G** (Guanine)  |
+| 01       | **C** (Cytosine) |
+| 11       | **T** (Thymine)  |
+
+With this in mind we can simply encode any data by using two-bit to Nucleotides conversion
+
+```pascal
+{ Algorithm 1: Naive byte array to DNA encode }
+procedure EncodeToDNASequence(f) string
+begin
+  enc string
+  while not eof(f) do
+    c byte := buffer[0]                             { Read 1 byte from buffer }
+    bin integer := sprintf('08b', c)                { Convert to string binary }
+    for e in range[0, 2, 4, 6] do
+      if e[0] == 48 and e[1] == 48 then             { 0x00 - A (Adenine) }
+        enc += 'A'
+      else if e[0] == 48 and e[1] == 49 then        { 0x01 - G (Guanine) }
+        enc += 'G'
+      else if e[0] == 49 and e[1] == 48 then        { 0x10 - C (Cytosine) }
+        enc += 'C'
+      else if e[0] == 49 and e[1] == 49 then        { 0x11 - T (Thymine) }
+        enc += 'T'
+  return enc                                        { Return DNA sequence }
+end
+```
+
+Another encoding would be **Goldman encoding**. Using this encoding helps with Nonsense mutation (amino acids replaced by a stop codon) that occurs and is the most problematic during translation because it leads to truncated amino acid sequences, which in turn results in truncated proteins. [^4]
+
+[Where to store big data? In DNA: Nick Goldman at TEDxPrague](https://www.youtube.com/watch?v=a4PiGWNsIEU)
+
+### FASTA file format
+
+In bioinformatics, FASTA format is a text-based format for representing either nucleotide sequences or peptide sequences, in which nucleotides or amino acids are represented using single-letter codes. The format also allows for sequence names and comments to precede the sequences. The format originates from the FASTA software package, but has now become a standard in the field of bioinformatics. [^5]
+
+The first line in a FASTA file started either with a ">" (greater-than) symbol or, less frequently, a ";" (semicolon) was taken as a comment. Subsequent lines starting with a semicolon would be ignored by software. Since the only comment used was the first, it quickly became used to hold a summary description of the sequence, often starting with a unique library accession number, and with time it has become commonplace to always use ">" for the first line and to not use ";" comments (which would otherwise be ignored).
+
+```text
+;LCBO - Prolactin precursor - Bovine
+; a sample sequence in FASTA format
+MDSKGSSQKGSRLLLLLVVSNLLLCQGVVSTPVCPNGPGNCQVSLRDLFDRAVMVSHYIHDLSS
+EMFNEFDKRYAQGKGFITMALNSCHTSSLPTPEDKEQAQQTHHEVLMSLILGLLRSWNDPLYHL
+VTEVRGMKGAPDAILSRAIEIEEENKRLLEGMEMIFGQVIPGAKETEPYPVWSGLPSLQTKDED
+ARYSAFYNLLHCLRRDSSKIDTYLKLLNCRIIYNNNC*
+
+>MCHU - Calmodulin - Human, rabbit, bovine, rat, and chicken
+ADQLTEEQIAEFKEAFSLFDKDGDGTITTKELGTVMRSLGQNPTEAELQDMINEVDADGNGTID
+FPEFLTMMARKMKDTDSEEEIREAFRVFDKDGNGYISAAELRHVMTNLGEKLTDEEVDEMIREA
+DIDGDGQVNYEEFVQMMTAK*
+
+>gi|5524211|gb|AAD44166.1| cytochrome b [Elephas maximus maximus]
+LCLYTHIGRNIYYGSYLYSETWNTGIMLLLITMATAFMGYVLPWGQMSFWGATVITNLFSAIPYIGTNLV
+EWIWGGFSVDKATLNRFFAFHFILPFTMVALAGVHLTFLHETGSNNPLGLTSDSDKIPFHPYYTIKDFLG
+LLILILLLLLLALLSPDMLGDPDNHMPADPLNTPLHIKPEWYFLFAYAILRSVPNKLGGVLALFLSIVIL
+GLMPFLHTSKHRSMMLRPLSQALFWTLTMDLLTLTWIGSQPVEYPYTIIGQMASILYFSIILAFLPIAGX
+IENY
+```
+
+FASTA format was extended by [FASTQ](https://en.wikipedia.org/wiki/FASTQ_format) format from the [Sanger Centre](https://www.sanger.ac.uk/) in Cambridge.
+
+### PNG encoded DNA sequence
+
+| Nucleotides   | RGB         | Color name |
+| ------------- | ----------- | ---------- |
+| A -> Adenine  | (0,0,255)   | Blue       |
+| G -> Guanine  | (0,100,0)   | Green      |
+| C -> Cytosine | (255,0,0)   | Red        |
+| T -> Thymine  | (255,255,0) | Yellow     |
+
+With this in mind we can create a simple algorithm to create PNG representation of a DNA sequence.
+
+```pascal
+{ Algorithm 2: Naive DNA to PNG encode from FASTA file }
+procedure EncodeDNASequenceToPNG(f)
+begin
+  i image
+  while not eof(f) do
+    c char := buffer[0]                             { Read 1 char from buffer }
+    case c of
+      'A': color := RGB(0, 0, 255)                  { Blue }
+      'G': color := RGB(0, 100, 0)                  { Green }
+      'C': color := RGB(255, 0, 0)                  { Red }
+      'T': color := RGB(255, 255, 0)                { Yellow }
+    drawRect(i, [x, y], color)
+  save(i)                                           { Save PNG image }
+end
+```
+
+## Encoding text file in practice
+
+In this example we will take a simple text file as our input stream for encoding. This file will have a quote from Niels Bohr and saved as txt file.
+
+> How wonderful that we have met with a paradox. Now we have some hope of making progress.
+> ― Niels Bohr
+
+First we encode text file into FASTA file.
+
+```bash
+./dnae-encode -i quote.txt -o quote.fa
+2019/01/10 00:38:29 Gathering input file stats
+2019/01/10 00:38:29 Starting encoding ...
+ 106 B / 106 B [==================================] 100.00% 0s
+2019/01/10 00:38:29 Saving to FASTA file ...
+2019/01/10 00:38:29 Output FASTA file length is 438 B
+2019/01/10 00:38:29 Process took 987.263µs
+2019/01/10 00:38:29 Done ...
+```
+
+Output of `quote.fa` file contains the encoded DNA sequence in ASCII format.
+
+```text
+>SEQ1
+GACAGCTTGTGTACAAGTGTGCTTGCTCGCGAGCGGGTACGCGCGTGGGCTAACAAGTGA
+GCCAGCAGGTGAACAAGTGTGCGGACAAGCCAGCAGGTGCGCGGACAAGCTGGCGGGTGA
+ACAAGTGTGCCGGTGAGCCAACAAGCAGACAAGTAAGCAGGTACGCAGGCGAGCTTGTCA
+ACTCACAAGATCGCTTGTGTACAAGTGTGCGGACAAGCCAGCAGGTGCGCGGACAAGTAT
+GCTTGCTGGCGGACAAGCCAGCTTGTAAGCGGACAAGCTTGCGCACAAGCTGGCAGGCCT
+GCCGGCTCGCGTACAAATTCACAAGTAAGTACGCTTGCGTGTACGCGGGTATGTATACTC
+AACCTCACCAAACGGGACAAGATCGCCGGCGGGCTAGTATACAAGAACGCTTGCCAGTAC
+AACC
+```
+
+Then we encode FASTA file from previous operation to encode this data into PNG.
+
+```bash
+./dnae-png -i quote.fa -o quote.png
+2019/01/10 00:40:09 Gathering input file stats ...
+2019/01/10 00:40:09 Deconstructing FASTA file ...
+2019/01/10 00:40:09 Compositing image file ...
+ 424 / 424 [==================================] 100.00% 0s
+2019/01/10 00:40:09 Saving output file ...
+2019/01/10 00:40:09 Output image file length is 1.1 kB
+2019/01/10 00:40:09 Process took 19.036117ms
+2019/01/10 00:40:09 Done ...
+```
+
+After encoding into PNG format this file looks like this.
+
+![Encoded Quote in PNG format](/files/dna-sequence/quote.png)
+
+The larger the input stream is the larger the PNG file would be.
+
+Compiled basic Hello World C program with [GCC](https://www.gnu.org/software/gcc/) would [look like](/files/dna-sequence/sample.png).
+
+```c
+// gcc -O3 -o sample sample.c
+#include <stdio.h>
+
+main() {
+  printf("Hello, world!\n");
+  return 0;
+}
+```
+
+## Toolkit for encoding data
+
+I have created a toolkit with two main programs:
+- dnae-encode (encodes file into FASTA file)
+- dnae-png (encodes FASTA file into PNG)
+
+Toolkit with full source code is available on [github.com/mitjafelicijan/dna-encoding](https://github.com/mitjafelicijan/dna-encoding).
+
+### dnae-encode
+
+```bash
+> ./dnae-encode --help
+usage: dnae-encode --input=INPUT [<flags>]
+
+A command-line application that encodes file into DNA sequence.
+
+Flags:
+      --help             Show context-sensitive help (also try --help-long and --help-man).
+  -i, --input=INPUT      Input file (ASCII or binary) which will be encoded into DNA sequence.
+  -o, --output="out.fa"  Output file which stores DNA sequence in FASTA format.
+  -s, --sequence=SEQ1    The description line (defline) or header/identifier line, gives a name and/or a unique identifier for the sequence.
+  -c, --columns=60       Row characters length (no more than 120 characters). Devices preallocate fixed line sizes in software.
+      --version          Show application version.
+```
+
+### dnae-png
+
+```bash
+> ./dnae-png --help
+usage: dnae-png --input=INPUT [<flags>]
+
+A command-line application that encodes FASTA file into PNG image.
+
+Flags:
+      --help              Show context-sensitive help (also try --help-long and --help-man).
+  -i, --input=INPUT       Input FASTA file which will be encoded into PNG image.
+  -o, --output="out.png"  Output file in PNG format that represents DNA sequence in graphical way.
+  -s, --size=10           Size of pairings of DNA bases on image in pixels (lower resolution lower file size).
+      --version           Show application version.
+```
+
+## Benchmarks
+
+First we generate some binary sample data with dd.
+
+```bash
+dd if=<(openssl enc -aes-256-ctr  -pass pass:"$(dd if=/dev/urandom bs=128 count=1 2>/dev/null | base64)" -nosalt < /dev/zero) of=1KB.bin bs=1KB count=1 iflag=fullblock
+```
+
+Our freshly generated 1KB file looks something like this (its full of garbage data as intended).
+
+![Sample binary file 1KB](/files/dna-sequence/sample-binary-file.png)
+
+We create following binary files:
+- 1KB.bin
+- 10KB.bin
+- 100KB.bin
+- 1MB.bin
+- 10MB.bin
+- 100MB.bin
+
+After this we create FASTA files for all the binary files by encoding them into DNA sequence.
+
+```bash
+./dnae-encode -i 100MB.bin -o 100MB.fa
+```
+
+Then we GZIP all the FASTA files to see how much the can be compressed.
+
+```bash
+gzip -9 < 10MB.fa > 10MB.fa.gz
+```
+
+[Download ODS file with benchmarks](/files/dna-sequence/benchmarks.ods).
+
+## References
+
+[^1]: https://www.techopedia.com/definition/948/encoding
+[^2]: https://www.dna-worldwide.com/resource/160/history-dna-timeline
+[^3]: https://opentextbc.ca/biology/chapter/9-1-the-structure-of-dna/
+[^4]: https://arxiv.org/abs/1801.04774
+[^5]: https://en.wikipedia.org/wiki/FASTA_format
diff --git a/src/sandbox/using-digitalocean-spaces-object-storage-with-fuse.md b/src/sandbox/using-digitalocean-spaces-object-storage-with-fuse.md
new file mode 100644
index 0000000..099fbef
--- /dev/null
+++ b/src/sandbox/using-digitalocean-spaces-object-storage-with-fuse.md
@@ -0,0 +1,260 @@
+title: Using DigitalOcean Spaces Object Storage with FUSE
+date: 2018-01-16
+tags: research
+hide: false
+----
+
+Couple of months ago [DigitalOcean](https://www.digitalocean.com) introduced new product called [Spaces](https://blog.digitalocean.com/introducing-spaces-object-storage/) which is Object Storage very similar to Amazon's S3. This really peaked my interest, because this was something I was missing and even the thought of going over the internet for such functionality was in no interest to me. Also in fashion with their previous pricing this also is very cheap and pricing page is a no-brainer compared to AWS or GCE. [Prices are clearly and precisely defined and outlined](https://www.digitalocean.com/pricing/). You must love them for that :)
+
+### Initial requirements
+
+* Is it possible to use them as a mounted drive with FUSE? (tl;dr YES)
+* Will the performance degrade over time and over different sizes of objects? (tl;dr NO&YES)
+* Can storage be mounted on multiple machines at the same time and be writable? (tl;dr YES)
+
+> Let me be clear. This scripts I use are made just for benchmarking and are not intended to be used in real-life situations. Besides that, I am looking into using this approaches but adding caching service in front of it and then dumping everything as an object to storage. This could potentially be some interesting post of itself. But in case you would need real-time data without eventual consistency please take this scripts as they are: not usable in such situations.
+
+## Is it possible to use them as a mounted drive with FUSE?
+
+Well, actually they can be used in such manor. Because they are similar to [AWS S3](https://aws.amazon.com/s3/) many tools are available and you can find many articles and [Stackoverflow items](https://stackoverflow.com/search?q=s3+fuse).
+
+To make this work you will need DigitalOcean account. If you don't have one you will not be able to test this code. But if you have an account then you go and [create new Droplet](https://cloud.digitalocean.com/droplets/new?size=s-1vcpu-1gb&region=ams3&distro=debian&distroImage=debian-9-x64&options=private_networking,install_agent). If you click on this link you will already have preselected Debian 9 with smallest VM option.
+
+* Please be sure to add you SSH key, because we will login to this machine remotely.
+* If you change your region please remember which one you choose because we will need this information when we try to mount space to our machine.
+
+Instuctions on how to use SSH keys and how to setup them are available in article [How To Use SSH Keys with DigitalOcean Droplets](https://www.digitalocean.com/community/tutorials/how-to-use-ssh-keys-with-digitalocean-droplets).
+
+![DigitalOcean Droplets](/files/do-fuse/fuse-droplets.png)
+
+After we created Droplet it's time to create new Space. This is done by clicking on a button [Create](https://cloud.digitalocean.com/spaces/new) (right top corner) and selecting Spaces. Choose pronounceable ```Unique name``` because we will use it in examples below. You can either choose Private or Public, it doesn't matter in our case. And you can always change that in the future.
+
+When you have created new Space we should [generate Access key](https://cloud.digitalocean.com/settings/api/tokens). This link will guide to the page when you can generate this key. After you create new one, please save provided Key and Secret because Secret will not be shown again.
+
+![DigitalOcean Spaces](/files/do-fuse/fuse-spaces.png)
+
+Now that we have new Space and Access key we should SSH into our machine.
+
+```bash
+# replace IP with the ip of your newly created droplet
+ssh root@IP
+
+# this will install utilities for mounting storage objects as FUSE
+apt install s3fs
+
+# we now need to provide credentials (access key we created earlier)
+# replace KEY and SECRET with your own credentials but leave the colon between them
+# we also need to set proper permissions
+echo "KEY:SECRET" > .passwd-s3fs
+chmod 600 .passwd-s3fs
+
+# now we mount space to our machine
+# replace UNIQUE-NAME with the name you choose earlier
+# if you choose different region for your space be careful about -ourl option (ams3)
+s3fs UNIQUE-NAME /mnt/ -ourl=https://ams3.digitaloceanspaces.com -ouse_cache=/tmp
+
+# now we try to create a file
+# once you mount it may take a couple of seconds to retrieve data
+echo "Hello cruel world" > /mnt/hello.txt
+```
+
+After all this you can return to your browser and go to [DigitalOcean Spaces](https://cloud.digitalocean.com/spaces) and click on your created space. If file hello.txt is present you have successfully mounted space to your machine and wrote data to it.
+
+I choose the same region for my Droplet and my Space but you don't have to. You can have different regions. What this actually does to performance I don't know.
+
+Additional information on FUSE:
+
+* [Github project page for s3fs](https://github.com/s3fs-fuse/s3fs-fuse)
+* [FUSE - Filesystem in Userspace](https://en.wikipedia.org/wiki/Filesystem_in_Userspace)
+
+## Will the performance degrade over time and over different sizes of objects?
+
+For this task I didn't want to just read and write text files or uploading images. I actually wanted to figure out if using something like SQlite is viable in this case.
+
+### Measurement experiment 1: File copy
+
+```bash
+# first we create some dummy files at different sizes
+dd if=/dev/zero of=10KB.dat bs=1024 count=10 #10KB
+dd if=/dev/zero of=100KB.dat bs=1024 count=100 #100KB
+dd if=/dev/zero of=1MB.dat bs=1024 count=1024 #1MB
+dd if=/dev/zero of=10MB.dat bs=1024 count=10240 #10MB
+
+# now we set time command to only return real
+TIMEFORMAT=%R
+
+# now lets test it
+(time cp 10KB.dat /mnt/) |& tee -a 10KB.results.txt
+
+# and now we automate
+# this will perform the same operation 100 times
+# this will output results into separated files based on objecty size
+n=0; while (( n++ < 100 )); do (time cp 10KB.dat /mnt/10KB.$n.dat) |& tee -a 10KB.results.txt; done
+n=0; while (( n++ < 100 )); do (time cp 100KB.dat /mnt/100KB.$n.dat) |& tee -a 100KB.results.txt; done
+n=0; while (( n++ < 100 )); do (time cp 1MB.dat /mnt/1MB.$n.dat) |& tee -a 1MB.results.txt; done
+n=0; while (( n++ < 100 )); do (time cp 10MB.dat /mnt/10MB.$n.dat) |& tee -a 10MB.results.txt; done
+```
+
+Files of size 100MB were not successfully transferred and ended up displaying error (cp: failed to close '/mnt/100MB.1.dat': Operation not permitted).
+
+As I suspected, object size is not really that important. Sadly I don't have the time to test performance over periods of time. But if some of you would do it please send me your data. I would be interested in seeing results.
+
+**Here are plotted results**
+
+You can download [raw result here](/files/do-fuse/copy-benchmarks.tsv). Measurements are in seconds.
+
+<script src="//cdn.plot.ly/plotly-latest.min.js"></script>
+<div id="copy-benchmarks"></div>
+<script>
+(function(){
+        var request = new XMLHttpRequest();
+        request.open("GET", "/files/do-fuse/copy-benchmarks.tsv", true);
+        request.onload = function() {
+                if (request.status >= 200 && request.status < 400) {
+                        var payload = request.responseText.trim();
+                        var tsv = payload.split("\n");
+                        for (var i=0; i<tsv.length; i++) { tsv[i] = tsv[i].split("\t"); }
+                        var traces = [];
+                        var headers = tsv[0];
+                        tsv.shift();
+                        Array.prototype.forEach.call(headers, function(el, idx) {
+                                var x = [];
+                                var y = [];
+                                for (var j=0; j<tsv.length; j++) {
+                                        x.push(j);
+                                        y.push(parseFloat(tsv[j][idx].replace(",", ".")));
+                                }
+                                traces.push({ x: x, y: y, type: "scatter", name: el, line: { width: 1, shape: "spline" } });
+                        });
+                        var copy = Plotly.newPlot("copy-benchmarks", traces, { legend: {"orientation": "h"}, height: 400, margin: { l: 40, r: 0, b: 20, t: 30, pad: 0 }, yaxis: { title: "execution time in seconds", titlefont: { size: 12 } }, xaxis: { title: "fn(i)", titlefont: { size: 12 } } });
+                } else { }
+        };
+        request.onerror = function() { };
+        request.send(null);
+})();
+</script>
+
+As far as these tests show, performance is quite stable and can be predicted which is fantastic. But this is a small test and spans only over couple of hours. So you should not completely trust them.
+
+### Measurement experiment 2: SQLite performanse
+
+I was unable to use database file directly from mounted drive so this is a no-go as I suspected. So I executed code below on a local disk just to get some benchmarks. I inserted 1000 records with DROPTABLE, CREATETABLE, INSERTMANY, FETCHALL, COMMIT for 1000 times to generate statistics. As you can see performance of SQLite is quite amazing. You could then potentially just copy file to mounted drive and be done with it.
+
+```python
+import time
+import sqlite3
+import sys
+
+if len(sys.argv) < 3:
+  print("usage: python sqlite-benchmark.py DB_PATH NUM_RECORDS REPEAT")
+  exit()
+
+def data_iter(x):
+  for i in range(x):
+    yield "m" + str(i), "f" + str(i*i)
+
+header_line = "%s\t%s\t%s\t%s\t%s\n" % ("DROPTABLE", "CREATETABLE", "INSERTMANY", "FETCHALL", "COMMIT")
+with open("sqlite-benchmarks.tsv", "w") as fp:
+  fp.write(header_line)
+
+start_time = time.time()
+conn = sqlite3.connect(sys.argv[1])
+c = conn.cursor()
+end_time = time.time()
+result_time = CONNECT = end_time - start_time
+print("CONNECT: %g seconds" % (result_time))
+
+start_time = time.time()
+c.execute("PRAGMA journal_mode=WAL")
+c.execute("PRAGMA temp_store=MEMORY")
+c.execute("PRAGMA synchronous=OFF")
+result_time = PRAGMA = end_time - start_time
+print("PRAGMA: %g seconds" % (result_time))
+
+for i in range(int(sys.argv[3])):
+  print("#%i" % (i))
+
+  start_time = time.time()
+  c.execute("drop table if exists test")
+  end_time = time.time()
+  result_time = DROPTABLE = end_time - start_time
+  print("DROPTABLE: %g seconds" % (result_time))
+
+  start_time = time.time()
+  c.execute("create table if not exists test(a,b)")
+  end_time = time.time()
+  result_time = CREATETABLE = end_time - start_time
+  print("CREATETABLE: %g seconds" % (result_time))
+
+  start_time = time.time()
+  c.executemany("INSERT INTO test VALUES (?, ?)", data_iter(int(sys.argv[2])))
+  end_time = time.time()
+  result_time = INSERTMANY = end_time - start_time
+  print("INSERTMANY: %g seconds" % (result_time))
+
+  start_time = time.time()
+  c.execute("select count(*) from test")
+  res = c.fetchall()
+  end_time = time.time()
+  result_time = FETCHALL = end_time - start_time
+  print("FETCHALL: %g seconds" % (result_time))
+
+  start_time = time.time()
+  conn.commit()
+  end_time = time.time()
+  result_time = COMMIT = end_time - start_time
+  print("COMMIT: %g seconds" % (result_time))
+
+  print
+  log_line = "%f\t%f\t%f\t%f\t%f\n" % (DROPTABLE, CREATETABLE, INSERTMANY, FETCHALL, COMMIT)
+  with open("sqlite-benchmarks.tsv", "a") as fp:
+    fp.write(log_line)
+
+start_time = time.time()
+conn.close()
+end_time = time.time()
+result_time = CLOSE = end_time - start_time
+print("CLOSE: %g seconds" % (result_time))
+```
+
+You can download [raw result here](/files/do-fuse/sqlite-benchmarks.tsv). And again, these results are done on a local block storage and do not represent capabilities of object storage. With my current approach and state of the test code these can not be done. I would need to make Python code much more robust and check locking etc.
+
+<div id="sqlite-benchmarks"></div>
+<script>
+(function(){
+        var request = new XMLHttpRequest();
+        request.open("GET", "/files/do-fuse/sqlite-benchmarks.tsv", true);
+        request.onload = function() {
+                if (request.status >= 200 && request.status < 400) {
+                        var payload = request.responseText.trim();
+                        var tsv = payload.split("\n");
+                        for (var i=0; i<tsv.length; i++) { tsv[i] = tsv[i].split("\t"); }
+                        var traces = [];
+                        var headers = tsv[0];
+                        tsv.shift();
+                        Array.prototype.forEach.call(headers, function(el, idx) {
+                                var x = [];
+                                var y = [];
+                                for (var j=0; j<tsv.length; j++) {
+                                        x.push(j);
+                                        y.push(parseFloat(tsv[j][idx].replace(",", ".")));
+                                }
+                                traces.push({ x: x, y: y, type: "scatter", name: el, line: { width: 1, shape: "spline" } });
+                        });
+                        var sqlite = Plotly.newPlot("sqlite-benchmarks", traces, { legend: {"orientation": "h"}, height: 400, margin: { l: 50, r: 0, b: 20, t: 30, pad: 0 }, yaxis: { title: "execution time in seconds", titlefont: { size: 12 } } });
+                } else { }
+        };
+        request.onerror = function() { };
+        request.send(null);
+})();
+</script>
+
+## Can storage be mounted on multiple machines at the same time and be writable?
+
+Well, this one didn't take long to test. And the answer is **YES**. I mounted space on both machines and measured same performance on both machines. But because file is downloaded before write and then uploaded on complete there could potentially be problems is another process is trying to access the same file.
+
+## Observations and conslusion
+
+Using Spaces in this way makes it easier to access and manage files. But besides that you would need to write additional code to make this one play nice with you applications.
+
+Nevertheless, this was extremely simple to setup and use and this is just another excellent product in DigitalOcean product line. I found this exercise very valuable and am thinking about implementing some sort of mechanism for SQLite, so data can be stored on Spaces and accessed by many VM's. For a project where data doesn't need to be accessible in real-time and can have couple of minutes old data this would be very interesting. If any of you find this proposal interesting please write in a comment box below or shoot me an email and I will keep you posted.