01 introduction - 01 getting started.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://notebooks.gesis.org/binder/v2/gh/jolin-io/fall-in-love-with-julia/main?filepath=01%20introduction%20-%2001%20getting%20started.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![JuliaLogo](https://julialang.org/assets/infra/logo.svg)\n",
    "# Welcome to the introductory tutorial to Julia\n",
    "This tutorial will lead you through the 101 of Julia. After it you will be able to create your own Julia functions and understand the key language features like Multiple Dispatch. In other words, you will be able to program in Julia.\n",
    "\n",
    "This is a Juypter notebook which runs Julia as the kernel. You can actually interact with it, adapt code, and run code cells. You run cells and jump to the next by pressing SHIFT + ENTER. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables \n",
    "Julia was build for doing applied math and comes with a simple syntax. You can assign variables by plain `=` like in Python or R."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do some calculations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO calculate 2a + a^2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quite common in Julia is the use of greek symbols and some other cool utf-8 stuff. Typing backslash \\ and then the latex name of something, and finish with pressing TAB, you can insert many symbols quite conveniently. Try it out!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "θ = 1.34  # \\theta\n",
    "2θ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "π # some special constants already exist in Julia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a² = a*a  # a\\^2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If/Else \n",
    "In Julia you have a multiline if/else block and the ternary question mark operator ``?``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if a == 1\n",
    "    println(\"It's one Jonny!! It's one!!\")\n",
    "elseif a in (2,3,4,5)\n",
    "    println(\"It is a $a.\")\n",
    "else\n",
    "    println(\"Don't know...\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a == 3 ? \"three\" : \"other\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition you have short-cycling AND `&&`, and OR `||`. In both cases, the first argument has to be a boolean, however the last argument can be anything."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "true && 1  # && evaluates and returns the second argument if the first is true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "false && 1  # && otherwise returns false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "returnvalue = false || println(\"Note that `nothing` is returned\")  # || evaluates and returns the second argument if the first is false\n",
    "returnvalue == nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "true || error(\"this is not executed\")  # || otherwise returns true"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You see these in loops or functions commonly, where it is combined with `return`, `continue`, or `break`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "While variables are the synapsis, the brain of Julia are its functions. Really: If you understood functions in Julia, you are ready to work in Julia.\n",
    "\n",
    "There are many functions available builtin, we already saw a couple of them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "isodd(3), iseven(a), a + a, +(a, a), 1 in (1,2), in(1, [1,2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is super simple to define your own functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "    add2(a)\n",
    "    \n",
    "adds 2 to the given input and returns the result\n",
    "\"\"\"\n",
    "add2(a) = a + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the multiline string (\"\"\"...\"\"\") we just attached a documentation to our function. You can access it via ?, or by writing the open parentheses and pressing SHIFT+TAB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "?add2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "add2(  # try pressing SHIFT+TAB here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now lets actually run our function, if you haven't done so already"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO add2 to 7, 99, 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a second syntax to create functions which span multiple lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function add2(a, b)\n",
    "    a′ = add2(a)  # a\\prime = ...\n",
    "    b′ = add2(b)\n",
    "    return a′, b′ # the return statement is actually optional, the last statement in a block is automatically selected as the return value\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c, d = add2(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally you have support for arbitrary number of positional and keyword arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "args_kwargs(args...; kwargs...) = (args, kwargs)  # mind the semicolon ;\n",
    "args_kwargs(1,true, :IAmASymbol, b=4, c=\"IAmAString\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most fancy part about functions is that you can overload them for arbitrary number of arguments, as well as arbitrary argument types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func(a::Int) = a + 2\n",
    "func(a::AbstractFloat) = a/2\n",
    "func(a::Rational) = a/11\n",
    "func(a::Complex) = sqrt(a) \n",
    "func(a, b::String) = \"$a, $b\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func(3.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func(33//4)  # you have full support for working with true rational numbers in Julia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func(-2 + 0im)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func(true, \"it just works and compiles down to optimal code\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to the power of Julia!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1 - Fibonacci, Memoize, and BenchmarkTools\n",
    "By now you have everything you need to define your own fibonacci function :) https://en.wikipedia.org/wiki/Fibonacci_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO Implement fibonacci(n) returning the nth fibonacci number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This generates optimal code for small numbers of `n`, however gets quickly out of reach for larger `n` (for 45 it takes about 7 seconds for me). We can optimize the function by reusing already computed results. A quick trick to do so is to use the ``@memoize`` Macro from the ``Memoize`` package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Memoize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@memoize function fibonacci_mem(n)\n",
    "    # TODO fill with your implementation\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the help of the famous `@benchmark` macro from the `BenchmarkTools` package you can directly compare the time and memory footprint of the two functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using BenchmarkTools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@benchmark fibonacci(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@benchmark fibonacci_mem(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see the memoization kicks in and we have about constant access time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays\n",
    "\n",
    "Arrays are the best supported DataType in Julia, it is multidimensional and highly optimized. You use it as both `list` and `numpy.array` in Python, i.e. no more switching between worlds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[1,2,3,4]  # create column vector with respective elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[1 2 3 4]  # horizontally concatinate elements separated by space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[1\n",
    " 2\n",
    " 3\n",
    " 4]  # vertically concatinate elements separated by newline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[1; 2; 3; 4]  # vertically concatinate elements separated by semicolon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO create matrix with first row consisting of 1 & 2 and second row of 3 & 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many common functions for dealing with Arrays, most importantly for construction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Array{String}(undef, (2,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fill(5, (3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You also have indexing support"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [100, 200, 300]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO get the first element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the last element via special keyword \"end\"\n",
    "a[end]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A beautiful aspect of julia is that many many things are not at all hardcoded, but actually have generic implementations under the hood.\n",
    "\n",
    "One of these is applying a function elementwise to an array, also called broadcasting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "add2.(a)  # mind the dot!! Try without dot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the dot syntax translates to\n",
    "broadcast(add2, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a .== 100  # try without dot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can transpose an Array by using '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a .+ a'  # Can you understand what is happening here?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At last I want to highlight that unlike Numpy in Python, Julia's Arrays can really hold any type of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mycombine(a, b) = (a, b, [a + b])\n",
    "mycombine.(a, a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively you can construct the same with a multi-dimensional for comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[mycombine(x, y) for x in a, y in a]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2 - Fibonacci Again\n",
    "\n",
    "Now you are already able to implement your own efficient version of `fibonacci_improved` which reuses intermediate results.\n",
    "\n",
    "The exercise is not to reimplement memoize, concretely, the fibonacci call should not cache its final result, but only improve internal performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO implement fibonacci_improved"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@benchmark fibonacci_improved(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that performance improved drastically, while now having a memory footprint on each call"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NamedTuples & Structs\n",
    "\n",
    "In practice you often have a bunch of variables you need to handle at once. \n",
    "* In julia you of course can construct your own types for this, but they may be a bit clumsy at times.\n",
    "* Luckily there is also a super simple to use alternative - named tuples - which you can use for fast development."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We already saw tuples and tuple destructing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = (1,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "you can also give them names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "namedtuple = (key=1, value=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "namedtuple.key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is one of the most useful tools for fast prototyping. There is even no performance penalty in using namedtuples, actually it is able to create optimal code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In case you want to define your own types for a more stable interface between different parts of your code you can use `struct`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct MyType\n",
    "    key::Int        # always specify the types by prepending ::\n",
    "    value::String\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MyType(3, \"hi\").value  # TODO construct MyType with other arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want flexible types, best way is to parameterize your types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct MyType2{Key, Value}\n",
    "    key::Key\n",
    "    value::Value\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MyType2(\"yeah\", true)  # you see the types are automatically inferred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is also the alternative of not specifying types at all\n",
    "```julia\n",
    "struct MyType3\n",
    "    key\n",
    "    value\n",
    "end\n",
    "```\n",
    "Which is equivalent to specifying\n",
    "```julia\n",
    "struct MyType3\n",
    "    key::Any\n",
    "    value::Any\n",
    "end\n",
    "```\n",
    "Very important to know is that this leads to pour type inference and hence pourer performance. If you run ``MyType3(1, \"value\").key`` julia does not know any longer that the key is actually of type Int,  this was forgotten when wrapped into the MyType3. Hence not much code optimization can be done.\n",
    "\n",
    "Always prefer to parameterize your types, as it is not much work and gives you optimal performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func(a::MyType2) = \"$(a.key): $(a.value)\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And yes, of course you can overload functions for your own types - actually any function, also those already defined by other packages including Julia builtin functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func(MyType2(42, \"Multiple Dispatch this is called, and it is the answer to almost everything\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### At last the loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in 1:4\n",
    "    println(i)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However what does not work is adapting GLOBAL variables within a loop. It does not work within scripts and not in the Julia shell. Surprisingly, and conveniently, it works in the Jupyter Notebook though ;-)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 0\n",
    "for i in [1,2,3,4]\n",
    "    a += i\n",
    "end\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**YOUR TASK:** See it failing yourself, by opening a terminal via jupyter, starting `julia`, and copy pasting the above code snippet. It will fail with the error\n",
    "```\n",
    "ERROR: UndefVarError: a not defined\n",
    "Stacktrace:\n",
    " [1] top-level scope at ./REPL[2]:2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reason is Julia's scoping behaviour https://docs.julialang.org/en/v1/manual/variables-and-scoping/\n",
    "\n",
    "<table><tbody><tr><th style=\"text-align: right\">Construct</th><th style=\"text-align: right\">Scope type</th><th style=\"text-align: right\">Scope blocks it may be nested in</th></tr><tr><td style=\"text-align: right\"><a href=\"../../base/base/#module\"><code>module</code></a>, <a href=\"../../base/base/#baremodule\"><code>baremodule</code></a></td><td style=\"text-align: right\">global</td><td style=\"text-align: right\">global</td></tr><tr><td style=\"text-align: right\">interactive prompt (REPL)</td><td style=\"text-align: right\">global</td><td style=\"text-align: right\">global</td></tr><tr><td style=\"text-align: right\">(mutable) <a href=\"../../base/base/#struct\"><code>struct</code></a>, <a href=\"../../base/base/#macro\"><code>macro</code></a></td><td style=\"text-align: right\">local</td><td style=\"text-align: right\">global</td></tr><tr><td style=\"text-align: right\"><a href=\"../../base/base/#for\"><code>for</code></a>, <a href=\"../../base/base/#while\"><code>while</code></a>, <a href=\"../../base/base/#try\"><code>try-catch-finally</code></a>, <a href=\"../../base/base/#let\"><code>let</code></a></td><td style=\"text-align: right\">local</td><td style=\"text-align: right\">global or local</td></tr><tr><td style=\"text-align: right\">functions (either syntax, anonymous &amp; do-blocks)</td><td style=\"text-align: right\">local</td><td style=\"text-align: right\">global or local</td></tr><tr><td style=\"text-align: right\">comprehensions, broadcast-fusing</td><td style=\"text-align: right\">local</td><td style=\"text-align: right\">global or local</td></tr></tbody></table>\n",
    "\n",
    "Where you need to know\n",
    "```\n",
    "A local scope inherits all the variables from a parent local scope, both for reading and writing.\n",
    "```\n",
    "Especially, a local scope does NOT inherit variables from a parent global scope.\n",
    "\n",
    "Hence in functions, which itself introduce a local scope, everything works as intended. And as you kind of always work in functions (or juypter notebooks), you seldomly will stumble upon this. If you encounter it, you now know how to work around it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Thanks for participating ;-)\n",
    "\n",
    "In case of any questions feel free to reach me at stephan.sahm@gmx.de\n",
    "\n",
    "If you are curious for more or want to do a Julia project, just tell me. I am always glad about new enthusiasts.\n",
    "\n",
    "Believe me, it's the future of applied-math, including data-science.\n",
    "![fans](https://images.unsplash.com/photo-1429962714451-bb934ecdc4ec?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=crop&w=2250&q=80)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.6.1",
   "language": "julia",
   "name": "julia-1.6"
  },
  "language_info": {
   "name": "julia",
   "version": ""
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}