Week1_7-Variables.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\r\n",
       "<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\r\n",
       "<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\r\n",
       "<link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'>\r\n",
       "<link href='http://fonts.googleapis.com/css?family=Philosopher:400,700,400italic,700italic' rel='stylesheet' type='text/css'>\r\n",
       "\r\n",
       "<style>\r\n",
       "\r\n",
       "@font-face {\r\n",
       "    font-family: \"Computer Modern\";\r\n",
       "    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\r\n",
       "}\r\n",
       "\r\n",
       "\r\n",
       "\r\n",
       "/* Formatting for header cells */\r\n",
       ".text_cell_render h1 {\r\n",
       "    font-family: 'Philosopher', sans-serif;\r\n",
       "    font-weight: 400;\r\n",
       "    font-size: 2.2em;\r\n",
       "    line-height: 100%;\r\n",
       "    color: rgb(0, 80, 120);\r\n",
       "    margin-bottom: 0.1em;\r\n",
       "    margin-top: 0.1em;\r\n",
       "    display: block;\r\n",
       "}\t\r\n",
       ".text_cell_render h2 {\r\n",
       "    font-family: 'Philosopher', serif;\r\n",
       "    font-weight: 400;\r\n",
       "    font-size: 1.9em;\r\n",
       "    line-height: 100%;\r\n",
       "    color: rgb(200,100,0);\r\n",
       "    margin-bottom: 0.1em;\r\n",
       "    margin-top: 0.1em;\r\n",
       "    display: block;\r\n",
       "}\t\r\n",
       "\r\n",
       ".text_cell_render h3 {\r\n",
       "    font-family: 'Philosopher', serif;\r\n",
       "    margin-top:12px;\r\n",
       "    margin-bottom: 3px;\r\n",
       "    font-style: italic;\r\n",
       "    color: rgb(94,127,192);\r\n",
       "}\r\n",
       "\r\n",
       ".text_cell_render h4 {\r\n",
       "    font-family: 'Philosopher', serif;\r\n",
       "}\r\n",
       "\r\n",
       ".text_cell_render h5 {\r\n",
       "    font-family: 'Alegreya Sans', sans-serif;\r\n",
       "    font-weight: 300;\r\n",
       "    font-size: 16pt;\r\n",
       "    color: grey;\r\n",
       "    font-style: italic;\r\n",
       "    margin-bottom: .1em;\r\n",
       "    margin-top: 0.1em;\r\n",
       "    display: block;\r\n",
       "}\r\n",
       "\r\n",
       ".text_cell_render h6 {\r\n",
       "    font-family: 'PT Mono', sans-serif;\r\n",
       "    font-weight: 300;\r\n",
       "    font-size: 10pt;\r\n",
       "    color: grey;\r\n",
       "    margin-bottom: 1px;\r\n",
       "    margin-top: 1px;\r\n",
       "}\r\n",
       "\r\n",
       ".CodeMirror{\r\n",
       "        font-family: \"PT Mono\";\r\n",
       "        font-size: 100%;\r\n",
       "}\r\n",
       "\r\n",
       "</style>\r\n",
       "\r\n"
      ],
      "text/plain": [
       "HTML{String}(\"<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\\r\\n<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\\r\\n<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\\r\\n<link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'>\\r\\n<link href='http://fonts.googleapis.com/css?family=Philosopher:400,700,400italic,700italic' rel='stylesheet' type='text/css'>\\r\\n\\r\\n<style>\\r\\n\\r\\n@font-face {\\r\\n    font-family: \\\"Computer Modern\\\";\\r\\n    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\\r\\n}\\r\\n\\r\\n\\r\\n\\r\\n/* Formatting for header cells */\\r\\n.text_cell_render h1 {\\r\\n    font-family: 'Philosopher', sans-serif;\\r\\n    font-weight: 400;\\r\\n    font-size: 2.2em;\\r\\n    line-height: 100%;\\r\\n    color: rgb(0, 80, 120);\\r\\n    margin-bottom: 0.1em;\\r\\n    margin-top: 0.1em;\\r\\n    display: block;\\r\\n}\\t\\r\\n.text_cell_render h2 {\\r\\n    font-family: 'Philosopher', serif;\\r\\n    font-weight: 400;\\r\\n    font-size: 1.9em;\\r\\n    line-height: 100%;\\r\\n    color: rgb(200,100,0);\\r\\n    margin-bottom: 0.1em;\\r\\n    margin-top: 0.1em;\\r\\n    display: block;\\r\\n}\\t\\r\\n\\r\\n.text_cell_render h3 {\\r\\n    font-family: 'Philosopher', serif;\\r\\n    margin-top:12px;\\r\\n    margin-bottom: 3px;\\r\\n    font-style: italic;\\r\\n    color: rgb(94,127,192);\\r\\n}\\r\\n\\r\\n.text_cell_render h4 {\\r\\n    font-family: 'Philosopher', serif;\\r\\n}\\r\\n\\r\\n.text_cell_render h5 {\\r\\n    font-family: 'Alegreya Sans', sans-serif;\\r\\n    font-weight: 300;\\r\\n    font-size: 16pt;\\r\\n    color: grey;\\r\\n    font-style: italic;\\r\\n    margin-bottom: .1em;\\r\\n    margin-top: 0.1em;\\r\\n    display: block;\\r\\n}\\r\\n\\r\\n.text_cell_render h6 {\\r\\n    font-family: 'PT Mono', sans-serif;\\r\\n    font-weight: 300;\\r\\n    font-size: 10pt;\\r\\n    color: grey;\\r\\n    margin-bottom: 1px;\\r\\n    margin-top: 1px;\\r\\n}\\r\\n\\r\\n.CodeMirror{\\r\\n        font-family: \\\"PT Mono\\\";\\r\\n        font-size: 100%;\\r\\n}\\r\\n\\r\\n</style>\\r\\n\\r\\n\")"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Setting up a custom stylesheet in IJulia\n",
    "file = open(\"style.css\") # A .css file in the same folder as this notebook file\n",
    "styl = read(file, String) # Read the file\n",
    "HTML(\"$styl\") # Output as HTML"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables in Julia have a name, a value and a type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<h2>In this lecture</h2>\n",
    "\n",
    "- [Outcome](#Outcome)\n",
    "- [Array types](#Array-types)\n",
    "- [Assignment: how variables get their values](#Assignment:-how-variables-get-their-values)\n",
    "- [Valid variable names in Julia](#Valid-variable-names-in-Julia)\n",
    "- [The three parts of a Julia variable](#The-three-parts-of-a-Julia-variable)\n",
    "- [Example of a variable created with abstract type](#Example-of-a-variable-created-with-abstract-type)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<h2>Outcome</h2>\n",
    "\n",
    "After this lecture, you will be able to: \n",
    "\n",
    "- Describe ``Array`` types and say how to create values using ``Array()``\n",
    "- Say how to access values in an array\n",
    "- Say how a variable gets a value in Julia\n",
    "- Say exactly how a variable in Julia is structured\n",
    "- Determine the type of a variable in Julia\n",
    "- Say why variables (unlike values) can have abstract types\n",
    "- Use brackets to access an element of an array\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Array types</h2>\n",
    "\n",
    "Julia has excellent support for arrays, on par with Matlab.\n",
    "\n",
    "Multidimensional arrays are easy to create in Julia. For example, ``Array{Int64}(undef, 3)`` creates a 3 x 1 array of integers (the ``undef`` in this bit of code means that no value is supplied --- note that Julia hates empty arrays of numbers, so it supplies some ``Int64`` numbers anyway):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       "               0\n",
       " 139818365353985\n",
       "               0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Array{Int64}(undef, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The type of the array is ``Array{Int64, 1}``.\n",
    "\n",
    "Further note that the type is has a 1 where the code that specifies it has a 3. They refer to completely different things! In the statement ``Array{Int64}(undef, 3)``, the 3 is the number of elements in the first dimension. Since this is the only dimension, we end up with a one-dimensional array. The type is ``Array{Int64, 1}``. The 1 specifies that it is a one-dimensional array; the ``Int64`` specifies that each element of the array has type ``Int64``.\n",
    "\n",
    "It is of interest that if you re-evaluate the line (just hit Shift-Enter again), Julia changes the numbers in the array. This is not for any deep reason: Julia always has some junk numbers that need tidying away, so it is convenient simply to use them here.\n",
    "\n",
    "Finally, try the expressions ``Array{String}(undef, 3)`` and ``Array{Any}(undef, 3)`` to see what Julia does if the junk to hand is not of admissible type. This emphasises, by the way, that to create an array, you *must* specify the type of each element (it is possible to specify a mixture of types, but that is an advanced topic we do not cover on this course)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Assignment: how variables get their values</h2>\n",
    "\n",
    "The assignment operator is ``=``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Hello, world!\""
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting = \"Hello, world!\"  # creates a variable called \"greeting\" whose value is a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "println(greeting)          # println uses the value of greeting when it prints the message"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Be very careful to use ``=`` when you want do assignments and ``==`` when you want to do comparisons. The similarity of these operators is an unfortunate heritage from many older programming languages. You just have to work on not using the one where the other is intended.\n",
    "\n",
    "And no matter how careful you are, some mistakes will occur. The possible errors because of ``=`` for ``==`` is one of the most prolific sources of bugs.\n",
    "\n",
    "### That's it!\n",
    "\n",
    "That's how variables get values in Julia: they are assigned using ``=``.\n",
    "\n",
    "\n",
    "To be exact, the *value* of the expression on the right of ``=`` is bound to the *name* on the left. It is useful to remember that one could read ``a = 5`` as \"the variable a takes the value 5\". Similarly, ``a = b`` can be read as \"the variable a takes the value of the variable b\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Valid variable names in Julia</h2>\n",
    "\n",
    "A variable name can be almost any string that starts with a letter and continues with letters, numbers or a few other characters.\n",
    "\n",
    "Note that here, letters include many Unicode characters. You could name all your variables using Mandarin, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Float64,1}:\n",
       " 20.0  \n",
       " 11.111"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "人 = 20\n",
    "生 = 11.111\n",
    "[人, 生]           # another way to make a 1-dimensional array: comma-separated list inside brackets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The initial character may also be an underscore (as can later ones):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"short string\""
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_this_is_my_idea_of_a_long_variable_name_ = \"short string\"  # community standard is NOT to use underscores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"wake-up call\""
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "very_important!pay_attention = \"wake-up call\"       # again, this example violates Julia community standard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "User-defined variables should avoid capital letters. This is the community standard, it is not absolutely obligatory, but is widely observed. Here's why\n",
    "\n",
    "*oficial Julia code reserves initial capitals for two uses: type names and module names.* \n",
    "\n",
    "User-defined types and modules (we don't discuss modules on this course) do usually have initial capitals, and sometimes also internal capitals (so-called camel case). The community standard on camel case is also to reserve it for the names of types and modules.\n",
    "\n",
    "Likewise, a final \"!\" on a function name, by general agreement, is reserved for those functions that modify their arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>The three parts of a Julia variable</h2>\n",
    "\n",
    "A Julia variable has name and a value. The assignment operator binds the name to the value.\n",
    "\n",
    "But there is a third item: the type. As noted in the lecture on types, in Julia only values have types. So what does it mean to say that a variable has a type?\n",
    "\n",
    "Well, if the variable has a definite value, then the type of the variable is the type of its value.\n",
    "\n",
    "But it is often the case that one refers to a variable only by its name. In that case its value is not known. It may even be that the variable has not yet been created (or, what it the same, not loaded). For instance, consider the command ``println(greeting)`` we used above. The function ``println()`` was written without knowing the type of the variable ``greeting``.\n",
    "\n",
    "When a variable is known only by its name, it is given the abstract type ``Any``, which is the most abstract type in Julia. That means it has no supertype, only subtypes. It is often useful to use a more restricted but still abstract subtype like ``Integer`` or ``AbstractString``, but we do not go into the details of that in this course.\n",
    "\n",
    "A variable with an abstract type can do quite a lot of things without actually being given a value that has a concrete type (see below for a simple example).\n",
    "\n",
    "A variable with abstract type must be given a value before it is used in a computation, otherwise Julia throws an error (see below).\n",
    "\n",
    "It is therefore slightly wrong to say that a variable has a type. It is the value of the variable that has a type. It's just that while a variable waits to have a particular value and hence a concrete type, it can useful to have in hand a limited set of possible types it can have. For that we use abstract types.\n",
    "\n",
    "Another slightly wrong way to say all this is the following: a variable may have abstract type only while it waits for its value to be assigned."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Example of a variable created with abstract type</h2>\n",
    "\n",
    "As noted above, a variable may have abstract type. Since it is not obvious how to create a variable with abstract type, I give an example here, using ``Array()``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×3 Array{Integer,2}:\n",
       " #undef  #undef  #undef\n",
       " #undef  #undef  #undef"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abstypevariable = Array{Integer}(undef, 2,3) # A two-dimensional array with 2 rows and 3 columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Array{Integer,2}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(abstypevariable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the value of ``abstypevariable`` is now an array where the elements are of type ``Integer``, which is an abstract type. \n",
    "\n",
    "But note that there are actually no values in here---the elements of the array remain undefined. So this is a variable still waiting to get its values. In a sense it has only be been half-created.\n",
    "\n",
    "I illustrate this by attempting to access an element of the array.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "UndefRefError",
     "evalue": "UndefRefError: access to undefined reference",
     "output_type": "error",
     "traceback": [
      "UndefRefError: access to undefined reference",
      "",
      "Stacktrace:",
      " [1] getindex(::Array{Integer,2}, ::Int64, ::Int64) at ./array.jl:732",
      " [2] top-level scope at In[14]:1"
     ]
    }
   ],
   "source": [
    "abstypevariable[2,1]    #NB --- note the brackets, that's how to access elements of an array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously, attempting to access a value that does not exist must be an error.\n",
    "\n",
    "However, you can assign a value to a single element. For example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abstypevariable[1,1] = 1    # Int64 is a subtype of Integer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that ``abstypevariable`` is still abstract, even if it contains an element of definite type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×3 Array{Integer,2}:\n",
       "   1     #undef  #undef\n",
       " #undef  #undef  #undef"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abstypevariable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia will convert values that are assigned if it can:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abstypevariable[1,2] = 5.0  # given value is of type Float64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×3 Array{Integer,2}:\n",
       "   1       5     #undef\n",
       " #undef  #undef  #undef"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abstypevariable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So although 5.0 was given to ``abstypevariable`` as a value, what Julia actually put there was a value converted to a subtype of ``Integer``. Julia will do such conversions whenever it can, in order to keep your program running. But if it has to do lots of conversions, your code will be running slower than it can---the fastest code *never* has to do any conversions.\n",
    "\n",
    "By the way, if you attempt to assign a value that cannot be converted, Julia throws an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: Cannot `convert` an object of type String to an object of type Integer\nClosest candidates are:\n  convert(::Type{T<:Number}, !Matched::T<:Number) where T<:Number at number.jl:6\n  convert(::Type{T<:Number}, !Matched::Number) where T<:Number at number.jl:7\n  convert(::Type{T<:Integer}, !Matched::Ptr) where T<:Integer at pointer.jl:23\n  ...",
     "output_type": "error",
     "traceback": [
      "MethodError: Cannot `convert` an object of type String to an object of type Integer\nClosest candidates are:\n  convert(::Type{T<:Number}, !Matched::T<:Number) where T<:Number at number.jl:6\n  convert(::Type{T<:Number}, !Matched::Number) where T<:Number at number.jl:7\n  convert(::Type{T<:Integer}, !Matched::Ptr) where T<:Integer at pointer.jl:23\n  ...",
      "",
      "Stacktrace:",
      " [1] setindex!(::Array{Integer,2}, ::String, ::Int64, ::Int64) at ./array.jl:771",
      " [2] top-level scope at In[22]:1"
     ]
    }
   ],
   "source": [
    "abstypevariable[2,2] = \"stringystringstr\"  # strings cannot be converted to any Integer type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, and this is often a good idea, you can create a variable with unknown but concrete values, for example by by replacing type ``Integer`` above with type Int64. (We've seen this already, of course)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×3 Array{Int64,2}:\n",
       " 139820382288080  139820382288208  139820382253792\n",
       " 139820382288176  139820382288240  139820381944560"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arbconcretevariable = Array{Int64}(undef,2,3)  # no actual value specified, \n",
    "#                                             ... so Julia assigns arbitrary values\n",
    "#                                                  (this is a repeat of behaviour you saw before)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## YOU CAN ALMOST ALWAYS IGNORE TYPES WHEN YOU WRITE JULIA CODE\n",
    "\n",
    "One of the nicest things about Julia is that, while its type system is totally amazing, you can ignore it if you like. People often do---you write code as rapidly as you can, to see whether an idea could possibly work. Then if you like what you see, but the code runs slowly, you tweak it. And in Julia, this means you work on getting the types right, and thereby avoiding type conversion.\n",
    "\n",
    "There is one case however where type cannot be ignored: when you get an error message that complains about type. That is, for purposes of debugging it is essential to know about Julia's type system, and that is why we include it this early in the course, even though you need never specify type in any of the assignments in this course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Julia 1.0.0",
   "language": "julia",
   "name": "julia-1.0"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.0.0"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}