04_loadsave.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to DataFrames\n",
    "**[Bogumił Kamiński](http://bogumilkaminski.pl/about/), April 27, 2019**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "using DataFrames # load package"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load and save DataFrames\n",
    "We do not cover all features of the packages. Please refer to their documentation to learn them.\n",
    "\n",
    "Here we'll load `CSV` and `CSVFiles` to read and write CSV files and `Feather` and serialization, which allow us to work with a binary format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "using CSV\n",
    "using CSVFiles\n",
    "using Serialization\n",
    "using Feather"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a simple `DataFrame` for testing purposes,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"data-frame\"><thead><tr><th></th><th>A</th><th>B</th><th>C</th><th>D</th></tr><tr><th></th><th>Bool</th><th>Int64⍰</th><th>String⍰</th><th>Char⍰</th></tr></thead><tbody><p>3 rows × 4 columns</p><tr><th>1</th><td>true</td><td>1</td><td>missing</td><td>'a'</td></tr><tr><th>2</th><td>false</td><td>2</td><td>b</td><td>missing</td></tr><tr><th>3</th><td>true</td><td>missing</td><td>c</td><td>'c'</td></tr></tbody></table>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|cccc}\n",
       "\t& A & B & C & D\\\\\n",
       "\t\\hline\n",
       "\t& Bool & Int64⍰ & String⍰ & Char⍰\\\\\n",
       "\t\\hline\n",
       "\t1 & true & 1 &  & 'a' \\\\\n",
       "\t2 & false & 2 & b &  \\\\\n",
       "\t3 & true &  & c & 'c' \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "3×4 DataFrame\n",
       "│ Row │ A     │ B       │ C       │ D       │\n",
       "│     │ \u001b[90mBool\u001b[39m  │ \u001b[90mInt64⍰\u001b[39m  │ \u001b[90mString⍰\u001b[39m │ \u001b[90mChar⍰\u001b[39m   │\n",
       "├─────┼───────┼─────────┼─────────┼─────────┤\n",
       "│ 1   │ true  │ 1       │ \u001b[90mmissing\u001b[39m │ 'a'     │\n",
       "│ 2   │ false │ 2       │ b       │ \u001b[90mmissing\u001b[39m │\n",
       "│ 3   │ true  │ \u001b[90mmissing\u001b[39m │ c       │ 'c'     │"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = DataFrame(A=[true, false, true], B=[1, 2, missing],\n",
    "              C=[missing, \"b\", \"c\"], D=['a', missing, 'c'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and use `eltypes` to look at the columnwise types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Type,1}:\n",
       " Bool                  \n",
       " Union{Missing, Int64} \n",
       " Union{Missing, String}\n",
       " Union{Missing, Char}  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eltypes(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CSV.jl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use `CSV` to save `x` to disk; make sure `x1.csv` does not conflict with some file in your working directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"x1.csv\""
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CSV.write(\"x1.csv\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can see how it was saved by reading `x.csv`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A,B,C,D\n",
      "true,1,,a\n",
      "false,2,b,\n",
      "true,,c,c\n"
     ]
    }
   ],
   "source": [
    "print(read(\"x1.csv\", String))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also load it back (`use_mmap=false` disables memory mapping so that on Windows the file can be deleted in the same session, on other OSs it is not needed)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"data-frame\"><thead><tr><th></th><th>A</th><th>B</th><th>C</th><th>D</th></tr><tr><th></th><th>Bool⍰</th><th>Int64⍰</th><th>String⍰</th><th>String⍰</th></tr></thead><tbody><p>3 rows × 4 columns</p><tr><th>1</th><td>true</td><td>1</td><td>missing</td><td>a</td></tr><tr><th>2</th><td>false</td><td>2</td><td>b</td><td>missing</td></tr><tr><th>3</th><td>true</td><td>missing</td><td>c</td><td>c</td></tr></tbody></table>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|cccc}\n",
       "\t& A & B & C & D\\\\\n",
       "\t\\hline\n",
       "\t& Bool⍰ & Int64⍰ & String⍰ & String⍰\\\\\n",
       "\t\\hline\n",
       "\t1 & true & 1 &  & a \\\\\n",
       "\t2 & false & 2 & b &  \\\\\n",
       "\t3 & true &  & c & c \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "3×4 DataFrame\n",
       "│ Row │ A     │ B       │ C       │ D       │\n",
       "│     │ \u001b[90mBool⍰\u001b[39m │ \u001b[90mInt64⍰\u001b[39m  │ \u001b[90mString⍰\u001b[39m │ \u001b[90mString⍰\u001b[39m │\n",
       "├─────┼───────┼─────────┼─────────┼─────────┤\n",
       "│ 1   │ true  │ 1       │ \u001b[90mmissing\u001b[39m │ a       │\n",
       "│ 2   │ false │ 2       │ b       │ \u001b[90mmissing\u001b[39m │\n",
       "│ 3   │ true  │ \u001b[90mmissing\u001b[39m │ c       │ c       │"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = CSV.read(\"x1.csv\", use_mmap=false)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When loading in a `DataFrame` from a `CSV`, all columns allow `Missing` by default. Note that the column types have changed!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Union,1}:\n",
       " Union{Missing, Bool}  \n",
       " Union{Missing, Int64} \n",
       " Union{Missing, String}\n",
       " Union{Missing, String}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eltypes(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CSVFiles.jl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will use `CSVFiles` to achieve the same. First we save the file. Notice that we override default `nastring` that is `\"NA\"` because we have missings in non-numeric columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "x |> save(\"x2.csv\", nastring=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and peek the saved file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"A\",\"B\",\"C\",\"D\"\n",
      "true,1,,a\n",
      "false,2,\"b\",\n",
      "true,,\"c\",c\n"
     ]
    }
   ],
   "source": [
    "print(read(\"x2.csv\", String))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can load it back using `load`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"data-frame\"><thead><tr><th></th><th>A</th><th>B</th><th>C</th><th>D</th></tr><tr><th></th><th>String</th><th>Int64⍰</th><th>String</th><th>String</th></tr></thead><tbody><p>3 rows × 4 columns</p><tr><th>1</th><td>true</td><td>1</td><td></td><td>a</td></tr><tr><th>2</th><td>false</td><td>2</td><td>b</td><td></td></tr><tr><th>3</th><td>true</td><td>missing</td><td>c</td><td>c</td></tr></tbody></table>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|cccc}\n",
       "\t& A & B & C & D\\\\\n",
       "\t\\hline\n",
       "\t& String & Int64⍰ & String & String\\\\\n",
       "\t\\hline\n",
       "\t1 & true & 1 &  & a \\\\\n",
       "\t2 & false & 2 & b &  \\\\\n",
       "\t3 & true &  & c & c \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "3×4 DataFrame\n",
       "│ Row │ A      │ B       │ C      │ D      │\n",
       "│     │ \u001b[90mString\u001b[39m │ \u001b[90mInt64⍰\u001b[39m  │ \u001b[90mString\u001b[39m │ \u001b[90mString\u001b[39m │\n",
       "├─────┼────────┼─────────┼────────┼────────┤\n",
       "│ 1   │ true   │ 1       │        │ a      │\n",
       "│ 2   │ false  │ 2       │ b      │        │\n",
       "│ 3   │ true   │ \u001b[90mmissing\u001b[39m │ c      │ c      │"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = load(\"x2.csv\") |> DataFrame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us check element types again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Type,1}:\n",
       " String               \n",
       " Union{Missing, Int64}\n",
       " String               \n",
       " String               "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eltypes(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe that in columns `:C` and `:D` missings were read back as empty strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Serialization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we use serialization to save `x`. Note that in general, this process will not work if the reading and writing are done by different versions of Julia, or an instance of Julia with a different system image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "open(\"x.bin\", \"w\") do io\n",
    "    serialize(io, x)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we load back the saved file to `y` variable. Again `y` is identical to `x`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"data-frame\"><thead><tr><th></th><th>A</th><th>B</th><th>C</th><th>D</th></tr><tr><th></th><th>Bool</th><th>Int64⍰</th><th>String⍰</th><th>Char⍰</th></tr></thead><tbody><p>3 rows × 4 columns</p><tr><th>1</th><td>true</td><td>1</td><td>missing</td><td>'a'</td></tr><tr><th>2</th><td>false</td><td>2</td><td>b</td><td>missing</td></tr><tr><th>3</th><td>true</td><td>missing</td><td>c</td><td>'c'</td></tr></tbody></table>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|cccc}\n",
       "\t& A & B & C & D\\\\\n",
       "\t\\hline\n",
       "\t& Bool & Int64⍰ & String⍰ & Char⍰\\\\\n",
       "\t\\hline\n",
       "\t1 & true & 1 &  & 'a' \\\\\n",
       "\t2 & false & 2 & b &  \\\\\n",
       "\t3 & true &  & c & 'c' \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "3×4 DataFrame\n",
       "│ Row │ A     │ B       │ C       │ D       │\n",
       "│     │ \u001b[90mBool\u001b[39m  │ \u001b[90mInt64⍰\u001b[39m  │ \u001b[90mString⍰\u001b[39m │ \u001b[90mChar⍰\u001b[39m   │\n",
       "├─────┼───────┼─────────┼─────────┼─────────┤\n",
       "│ 1   │ true  │ 1       │ \u001b[90mmissing\u001b[39m │ 'a'     │\n",
       "│ 2   │ false │ 2       │ b       │ \u001b[90mmissing\u001b[39m │\n",
       "│ 3   │ true  │ \u001b[90mmissing\u001b[39m │ c       │ 'c'     │"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = open(deserialize, \"x.bin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Type,1}:\n",
       " Bool                  \n",
       " Union{Missing, Int64} \n",
       " Union{Missing, String}\n",
       " Union{Missing, Char}  "
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eltypes(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Feather.jl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we use Feather format that allows, in particular, for data interchange with R or Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Union{Missing, String},1}:\n",
       " \"a\"    \n",
       " missing\n",
       " \"c\"    "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.D = passmissing(string).(x.D) # Feather format does not support Char type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"x.feather\""
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Feather.write(\"x.feather\", x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"data-frame\"><thead><tr><th></th><th>A</th><th>B</th><th>C</th><th>D</th></tr><tr><th></th><th>Bool</th><th>Int64⍰</th><th>String⍰</th><th>String⍰</th></tr></thead><tbody><p>3 rows × 4 columns</p><tr><th>1</th><td>true</td><td>1</td><td>missing</td><td>a</td></tr><tr><th>2</th><td>false</td><td>2</td><td>b</td><td>missing</td></tr><tr><th>3</th><td>true</td><td>missing</td><td>c</td><td>c</td></tr></tbody></table>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|cccc}\n",
       "\t& A & B & C & D\\\\\n",
       "\t\\hline\n",
       "\t& Bool & Int64⍰ & String⍰ & String⍰\\\\\n",
       "\t\\hline\n",
       "\t1 & true & 1 &  & a \\\\\n",
       "\t2 & false & 2 & b &  \\\\\n",
       "\t3 & true &  & c & c \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "3×4 DataFrame\n",
       "│ Row │ A     │ B       │ C       │ D       │\n",
       "│     │ \u001b[90mBool\u001b[39m  │ \u001b[90mInt64⍰\u001b[39m  │ \u001b[90mString⍰\u001b[39m │ \u001b[90mString⍰\u001b[39m │\n",
       "├─────┼───────┼─────────┼─────────┼─────────┤\n",
       "│ 1   │ true  │ 1       │ \u001b[90mmissing\u001b[39m │ a       │\n",
       "│ 2   │ false │ 2       │ b       │ \u001b[90mmissing\u001b[39m │\n",
       "│ 3   │ true  │ \u001b[90mmissing\u001b[39m │ c       │ c       │"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = Feather.materialize(\"x.feather\") # Feather.read is a lazy alternative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Type,1}:\n",
       " Bool                  \n",
       " Union{Missing, Int64} \n",
       " Union{Missing, String}\n",
       " Union{Missing, String}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eltypes(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic bechmarking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we'll create some files, so be careful that you don't already have these files on disc!\n",
    "\n",
    "In particular, we'll time how long it takes us to write a `DataFrame` with 10^3 rows and 10^5 columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First run\n",
      "  0.745948 seconds (814.64 k allocations: 40.707 MiB, 4.48% gc time)\n",
      "  1.050906 seconds (830.88 k allocations: 42.539 MiB, 2.87% gc time)\n",
      "  0.213652 seconds (427.49 k allocations: 21.266 MiB)\n",
      "  0.318751 seconds (373.35 k allocations: 25.882 MiB, 9.61% gc time)\n",
      "Second run\n",
      "  0.024630 seconds (54.97 k allocations: 1.052 MiB)\n",
      "  0.016964 seconds (5.53 k allocations: 340.375 KiB)\n",
      "  0.022761 seconds (4.81 k allocations: 243.089 KiB)\n",
      "  0.018969 seconds (34.02 k allocations: 9.008 MiB)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4-element Array{Int64,1}:\n",
       " 558378\n",
       " 558578\n",
       "  84439\n",
       "  54072"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bigdf = DataFrame(rand(Bool, 10^3, 10^2))\n",
    "bigdf[1] = Int.(bigdf[1])\n",
    "bigdf[2] = bigdf[2] .+ 0.5\n",
    "bigdf[3] = string.(bigdf[3], \", as string\")\n",
    "println(\"First run\")\n",
    "@time CSV.write(\"bigdf1.csv\", bigdf)\n",
    "@time bigdf |> save(\"bigdf2.csv\")\n",
    "@time open(io -> serialize(io, bigdf), \"bigdf.bin\", \"w\")\n",
    "@time Feather.write(\"bigdf.feather\", bigdf)\n",
    "println(\"Second run\")\n",
    "@time CSV.write(\"bigdf1.csv\", bigdf)\n",
    "@time bigdf |> save(\"bigdf2.csv\")\n",
    "@time open(io -> serialize(io, bigdf), \"bigdf.bin\", \"w\")\n",
    "@time Feather.write(\"bigdf.feather\", bigdf)\n",
    "getfield.(stat.([\"bigdf1.csv\", \"bigdf2.csv\", \"bigdf.bin\", \"bigdf.feather\"]), :size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First run\n",
      "  0.622640 seconds (802.64 k allocations: 28.521 MiB, 2.97% gc time)\n",
      "  1.679781 seconds (2.60 M allocations: 218.270 MiB, 8.63% gc time)\n",
      "  0.042708 seconds (72.82 k allocations: 2.008 MiB)\n",
      "  0.673740 seconds (639.10 k allocations: 32.375 MiB, 4.97% gc time)\n",
      "Second run\n",
      "  0.048690 seconds (52.07 k allocations: 1.326 MiB)\n",
      "  0.099486 seconds (506.49 k allocations: 108.821 MiB, 54.91% gc time)\n",
      "  0.006630 seconds (49.60 k allocations: 951.719 KiB)\n",
      "  0.007290 seconds (26.39 k allocations: 1.200 MiB)\n"
     ]
    }
   ],
   "source": [
    "println(\"First run\")\n",
    "@time CSV.read(\"bigdf1.csv\")\n",
    "@time load(\"bigdf2.csv\") |> DataFrame\n",
    "@time open(deserialize, \"bigdf.bin\")\n",
    "@time Feather.materialize(\"bigdf.feather\")\n",
    "println(\"Second run\")\n",
    "@time CSV.read(\"bigdf1.csv\")\n",
    "@time load(\"bigdf2.csv\") |> DataFrame\n",
    "@time open(deserialize, \"bigdf.bin\")\n",
    "@time Feather.materialize(\"bigdf.feather\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's clean up. Do not run the next cell unless you are sure that it will not erase your important files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "foreach(rm, [\"x1.csv\", \"x2.csv\", \"x.bin\", \"x.feather\",\n",
    "             \"bigdf1.csv\", \"bigdf2.csv\", \"bigdf.bin\", \"bigdf.feather\"])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.0.3",
   "language": "julia",
   "name": "julia-1.0"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.1.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}