Week1_3-REPL.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": [
    "<h1> The Julia REPL: strings, arithmetic</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>In this lecture</h2>\n",
    "\n",
    "- [Outcome](#Outcome)\n",
    "- [The REPL](#The-REPL)\n",
    "- [Further REPL examples](#Further-REPL-examples)\n",
    "- [Points of note](#Points-of-note)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Outcome</h2>\n",
    "\n",
    "After this lecture, you will be able to\n",
    "- Say what the Julia REPL is and what it does \n",
    "- Understand and use ``println()``\n",
    "- Make strings, and combine them using ``*`` and ``^``\n",
    "- Say what is special about the characters ``\\`` and ``$``\n",
    "\n",
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>The REPL</h2>\n",
    "\n",
    "The basic process in Julia is the REPL, which stands for \"Read-Evaluate-Print Loop\".\n",
    "\n",
    "Every time you take a step in Julia (hitting Shift-Enter in JuliaBox, for instance), you run through this loop.\n",
    "\n",
    "Try it: open a new notebook in JuliaBox (just click on New towards the top right), and in the cell (NB! leave it in code mode!) type the line below, then press Shift-Enter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "println(\"Hello, world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Famously, the first program in any language. A one-liner. Let's see how it works."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The ``println()`` part\n",
    "\n",
    "This is one of Julia's built-in functions. The word \"println\" is the name of the function, and it points to the code that the function uses to do its work.\n",
    "\n",
    "The parentheses ``( )`` is how Julia knows that it is dealing with a function. You need to watch carefully for the different kinds of delimiters in Julia. Here, it is ``()``, which we will call parentheses. Julia also uses ``[ ]`` which we will call brackets, and ``{ }``, which we will call braces.\n",
    "\n",
    "Note that when we mention Julia code in text, it appears in a grey box. You should take those literally: they are letter for letter, symbol for symbol, of the code to be executed by Julia. Computer code needs to be exact. Small changes might not confuse people, for example *printline* instead of *println* but Julia will simply send you an error message and then stop executing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The ``\"Hello, World!\"`` part\n",
    "\n",
    "Whatever is inside the parentheses of a function, is called the *argument* of that function. In this case, you see that the argument is inside quotation marks, and guess what? Yes---the function ``println()`` does not care about what the message means, it just puts whatever is inside the quotation marks on the screen.\n",
    "\n",
    "More or less in the way that a telephone needs to be indifferent to what human beings are actually saying ...\n",
    "\n",
    "In particular, ``println()`` must treat the argument purely as signs to be printed. By enclosing the message in double quotation marks, you turn it into a string which println() then displays without paying any attention to its contents.\n",
    "\n",
    "In Julia, strings are *immutable*. You can, if you like, use some part of a string, you can put strings together---but you can't actually change a string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Further REPL examples</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5   # this is a comment: the value 5 is entered ... and echoed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5+5   # 5+5 is entered, evaluated, and the result is echoed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2000000000000002\n",
      "16.8 ... evaluated!            lots of empty space\n"
     ]
    }
   ],
   "source": [
    "println(5-3.8)  # println() treats numbers intelligently ... more or less\n",
    "\n",
    "println(5+15-3.2, \" ... evaluated!\" , \"            lots of empty space\") \n",
    "             # one can mix numbers and strings in println()   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello! My word!\n"
     ]
    }
   ],
   "source": [
    "println(\"Hello!\" * \" My word!\")  # strings are combined using *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello! My word! My word! My word!\n"
     ]
    }
   ],
   "source": [
    "println(\"Hello!\" * \" My word!\"^3) # strings are repeated using ^"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Points of note</h2>\n",
    "\n",
    "As I said, REPL stands for \"Read-Evaluate-Print Loop\". It is a feature of dynamic languages such as Julia, Python, and Matlab. \n",
    "\n",
    "Using the acronym REPL just emphasises that a dynamic language continually stands ready to execute one more line of code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings\n",
    "\n",
    "Anything included in double quotes is a string in Julia. Of course, the only things you can include are items you can type out. These include ALMOST all the characters on your keyboard---letters, numbers, quotation marks.\n",
    "\n",
    "For example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"abc!@#%^ .. kyking:;'<,>.?/\""
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"abc!@#%^ .. kyking:;'<,>.?/\"   # string of odd characters ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The exceptions are the *escape* characters like ``\\`` and ``$`` (the most important ones for Julia). As follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "syntax: incomplete: invalid string syntax",
     "output_type": "error",
     "traceback": [
      "syntax: incomplete: invalid string syntax",
      ""
     ]
    }
   ],
   "source": [
    "\"\\\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our first bug! It is also a bug if the you try ``\"$\"``. But try ``\"\\$\"`` and ``println(\"\\$\")`` ... they don't throw any error message, but that doesn't mean they're doing what you want them to!\n",
    "\n",
    "Bugs are a big deal in programming --- some would say the main difference between expert and lay programmers is in how they deal with bugs.\n",
    "\n",
    "Learn to read bug reports, learn to love them. You will certainly see a great many if you carry on programming!\n",
    "\n",
    "The truth is, the error messages that tell you about bugs aren't always that helpful. This is one is not too bad, at least it talks about string syntax, so you know where to look.\n",
    "\n",
    "\n",
    "Incidentally, the interactive notebook can warn you about this particular bug"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\\n"
     ]
    }
   ],
   "source": [
    "println(\"\\\\\")   #note the colour of the closing parenthesis---the argument is not a string"
   ]
  },
  {
   "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
}