nbs/nk-features.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><h1>Nelu-Kernelu</h1></center>\n",
    "\n",
    "# The basics\n",
    "The following NodeJS standard elements/classes are available to use within a cell:\n",
    "* `console`\n",
    "* `__dirname` and `__filename`\n",
    "* `setImmediate`, `setInterval`, `setTimeout` with their `clearImmediate`, `clearInterval`, `clearInterval` (with a special _something_ discussed further down)\n",
    "* `exports`, `module` and `require`\n",
    "* `Buffer`\n",
    "* `URL` and `URLSearchParams`\n",
    "* `WebAssembly`\n",
    "* `Promise` and `Error`\n",
    "\n",
    "As you can see, and for security purposes, `process` and `global` are not part of this list.\n",
    "\n",
    "Replacing `process` is a `kernel` object through which you can access the NodeJS's functionality and info.\n",
    "\n",
    "### For instance ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... you can print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm going to get printed underneath a code cell."
     ]
    }
   ],
   "source": [
    "kernel.print(\"I'm going to get printed underneath a code cell.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and [format](https://nodejs.org/api/util.html#util_util_format_format_args) what you print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42 is a nice number while 'John' is a regular name."
     ]
    }
   ],
   "source": [
    "kernel.print(\"%d is a nice number while '%s' is a regular name.\", 42, \"John\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> #### A note on `console.log`\n",
    "> `console.log` does not print inside the notebook. Instead, it logs into the Notebook's process terminal like any normal console would expected to do.\n",
    "> This means that this:\n",
    "![console.log in](imgs/console_log_cell.png)\n",
    "> will actually be visible here:\n",
    "![console.log out](imgs/console_log_out.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and find out who's currently running the kernel session, if you want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "victor.adascalitei"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kernel.userName"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "### Feeling like reporting an error?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "Here you go!",
     "output_type": "error",
     "traceback": [
      "evalmachine.<anonymous>:4",
      "                    throw new Error('Here you go!');",
      "                    ^",
      "",
      "Error: Here you go!",
      "    at evalmachine.<anonymous>:4:27",
      "    at Script.runInContext (vm.js:137:20)",
      "    at Object.runInContext (vm.js:300:6)",
      "    at MessageLoop._handleExecuteCodeRequest (/Users/victor.adascalitei/Projects/NodeJS/ijs-playground/src/session/message_loop.js:134:36)"
     ]
    }
   ],
   "source": [
    "throw new Error('Here you go!');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What's a cell result? Simple ... whatever your last evaluation turns out to be"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let a = 2\n",
    "const b = 5\n",
    "\n",
    "a*b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... except for _undefined_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "undefined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And no, if you were wondering, _null_ doesn't suffer from this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "null"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### By the way ... a and b are not available anymore because they are scoped to the cell\n",
    "_let_ and _const_ have this behaviour."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ReferenceError: a is not defined"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ReferenceError: b is not defined"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... but if you declare something like this (with _var_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "var c = 3;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... you can reference it later on"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Promises are resolved before their result is returned like so"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "I'm a result resolved by a Promise."
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Promise.resolve(\"I'm a result resolved by a Promise.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... this also works nested twice (_but don't do that_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2nd Promise resolved me"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new Promise((accept, reject) => accept(new Promise((accept2, reject2) => accept2(\"2nd Promise resolved me\"))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How about versioning? How does that work?\n",
    "We expose `kernel.version` to the user-cell which gives access to both a `name` and a `code`. \n",
    "\n",
    "The `name` is a dot separated, traditional, version name in the form of `x.y.z.w` where `x.y.z` is the actual supported [Jupyter Client protocol version](https://jupyter-client.readthedocs.io/en/stable/#) while `w` is the build number.\n",
    "If you want a more numerical value (rather than a string), just go for the `code` which is computed as being `xyz000` + `w` where `x`, `y` and `z` are digits while `w` might be a number which, again is the source-build number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{ name: '5.3.0.1', code: 530001 }"
     ]
    }
   ],
   "source": [
    "kernel.print(kernel.version)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Want to render HTML? \n",
    "Return an object that has a _\\_toHtml_ function which returns the HTML string you want rendered like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<b>I'm a bolded text!</b>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class RenderedAsHtml {\n",
    "    _toHtml() { \n",
    "        return \"<b>I'm a bolded text!</b>\";\n",
    "    }\n",
    "}\n",
    "new RenderedAsHtml()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... if _\\_toHtml_ returns a Promise instead, we'll resolve it and render that"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<b>I'm a <i>promised</i> bolded text!</b>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class RenderedAsPromisedHtml {\n",
    "    _toHtml() { \n",
    "        return Promise.resolve(\"<b>I'm a <i>promised</i> bolded text!</b>\");\n",
    "    }\n",
    "}\n",
    "new RenderedAsPromisedHtml()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Timers\n",
    "They behave as you might expect with 2 caveats ([they're not covered by ECMAScript](https://stackoverflow.com/questions/8852198/settimeout-if-not-defined-in-ecmascript-spec-where-can-i-learn-how-it-works) so we allowed ourselves this insolence).\n",
    "If a timer function is the last instruction the kernel sees in a cell, it blocks execution until it gets resolved meaning that:\n",
    "* `setImmediate` - doesn't block execution (well, it does, but you never percieve it)\n",
    "* `setTimeout` - blocks execution until the timer is triggered\n",
    "* `setInterval` - blocks execution until `clearInterval` is triggered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Will print immediatelly without a noticeable delay."
     ]
    }
   ],
   "source": [
    "setImmediate(() => kernel.print(\"Will print immediatelly without a noticeable delay.\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Will print after 2 seconds blocking execution in the meantime."
     ]
    }
   ],
   "source": [
    "setTimeout(() => kernel.print(\"Will print after 2 seconds blocking execution in the meantime.\"), 2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Will print 3 ticks and then it will stop. Tick!  Tick!  Tick! "
     ]
    }
   ],
   "source": [
    "let cnt = 0;\n",
    "let timer;\n",
    "\n",
    "kernel.print(\"Will print 3 ticks and then it will stop.\");\n",
    "timer = setInterval(() => {\n",
    "    if (cnt == 3) clearInterval(timer);\n",
    "    else {\n",
    "        kernel.print(' Tick! ');\n",
    "        cnt++;\n",
    "    }\n",
    "}, 1000)\n",
    "\n",
    "// We need to return the timer so that it's the last thing evaluated in the cell\n",
    "timer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oh and whatever you return from an immediate/timeout timer callback will be the value that that cell resolves to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing from within the immediate callback"
     ]
    },
    {
     "data": {
      "text/plain": [
       "and returned this string."
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setImmediate(() => {\n",
    "    kernel.print(\"Printing from within the immediate callback\");\n",
    "    return \"and returned this string.\"\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, this is JS so we are still talking about an [event loop execution context](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/) which means that"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This will print first ...\n",
      "This will print second ..."
     ]
    }
   ],
   "source": [
    "setImmediate(() => kernel.print(\"This will print second ...\"))\n",
    "kernel.print(\"This will print first ...\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The juicy stuff\n",
    "## Comms\n",
    "`comms` are a way to [relay data](https://jupyter-client.readthedocs.io/en/stable/messaging.html#custom-messages) between the kernel and Jupyter. The best example of their usage is the [Jupyter Widgets](https://ipywidgets.readthedocs.io/en/latest/index.html) project. To make these mechanics possible, we export `kernel.commManager` which lets you work with them.\n",
    "\n",
    "### Opening one\n",
    "This is how you do in the fastest way possible:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "let comm = kernel.commManager.newComm()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, they start-off with an empty data payload `{}` and it targets `jknb.comm` (the 'jknb' prefix was left for historical reasons). If you want to have a different target-name, a payload and/or a metadata even, you can use the more sophisticated way of opening a comm via the `kernel.commManager.newCommFor` method call like so: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "var myComm = kernel.commManager.newCommFor({\n",
    "    targetName: 'my-target-name',\n",
    "    initialData: {\n",
    "        aVariable: 42\n",
    "        // ... other props (if needed)\n",
    "    },\n",
    "    metaData: {\n",
    "        version: 1\n",
    "        // ... anything else?\n",
    "    }\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This has the consequence that a `comm_open` is immediatelly broadcast to `iopub` as dictated by the [Jupyter Client Specs](https://jupyter-client.readthedocs.io/en/stable/messaging.html#opening-a-comm). \n",
    "This is how it looks like if you want to feel brave:\n",
    "![comm_open on wire](imgs/comm_open_on_wire.png)\n",
    "### Sending data through a comm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "myComm.send({\n",
    "    anotherVariable: 24\n",
    "    // add here whatever data needs to be sent\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This ends up calling `comm_msg` and will look (on _the wire_) something like this:\n",
    "![comm_msg on wire](imgs/comm_msg_on_wire.png)\n",
    "\n",
    "### ... and receving some"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[object Object]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myComm.on(\"message\", ({ data }) => {\n",
    "    // ... do whatever you want with 'data' inside the NodeJS kernel process\n",
    "    kernel.print(JSON.stringify(data));\n",
    "});"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Displays\n",
    "Allow for [embedding more sofisticated results](https://jupyter-client.readthedocs.io/en/stable/messaging.html#display-data) into an output cell.\n",
    "\n",
    "### Creating one\n",
    "Is achieved by calling the `kernel.display` method passing in an instance of a class that extends `JupyterDisplayableMessage` and overrides the _\\_toDisplay()_ method. \n",
    "\\_toDisplay() needs to return a object that has the following structure:\n",
    "```js\n",
    "{\n",
    "    \"<mime_1>\" : \"value #1\",\n",
    "    \"<mime_2>\" : \"value #2\",\n",
    "    // ...\n",
    "    \"<mime_n>\" : \"value #n\"\n",
    "}\n",
    "```\n",
    "For example, this will just display a `text/plain`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "I'm a plain text displayed value."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class JustAText extends JupyterDisplayableMessage {\n",
    "    _toDisplay() { \n",
    "        return { \"text/plain\": \"I'm a plain text displayed value.\" };\n",
    "    }\n",
    "}\n",
    "kernel.display(new JustAText());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### _Bonus!_ Emulating a LabelView Jupyter Widget from NodeJs\n",
    "> Note 1: You need to have `ipywidgets` installed to make use of them. [Here's](https://ipywidgets.readthedocs.io/en/latest/user_install.html) how you do it.  \n",
    "> Note 2: The data payloads you see here on `comms` were reversed engineered from Jupyter Widgets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "896b8a82a4544db2814a62ad73cbecfe",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Label(value='This is how we start: $E=mc^2$')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class LabelView extends JupyterDisplayableMessage {\n",
    "    constructor(value) {\n",
    "        super();\n",
    "        this._value = value;\n",
    "        this._wComm = kernel.commManager.newCommFor({\n",
    "                targetName: 'jupyter.widget',\n",
    "                initialData: {\n",
    "                    state: {\n",
    "                        _model_module: \"@jupyter-widgets/controls\",\n",
    "                        _model_module_version: \"1.4.0\",\n",
    "                        _model_name: \"LabelModel\",\n",
    "                        _view_module: \"@jupyter-widgets/controls\",\n",
    "                        _view_module_version: \"1.4.0\",\n",
    "                        _view_name: \"LabelView\",\n",
    "                        description: \"?\",\n",
    "                        description_tooltip: \"\",\n",
    "                        placeholder: \"​\",\n",
    "                        value: this._value\n",
    "                    },\n",
    "                    buffer_paths: []\n",
    "                },\n",
    "                metaData: {\n",
    "                    version: \"2.0.0\"\n",
    "                }\n",
    "            });\n",
    "        \n",
    "        this._wComm.on(\"message\", ({ data }) => {\n",
    "            if (data.method === 'request_state') {\n",
    "                this._wComm.send({\n",
    "                    method: \"update\",\n",
    "                    state: {\n",
    "                        _dom_classes: [],\n",
    "                        _model_module: \"@jupyter-widgets/controls\",\n",
    "                        _model_module_version: \"1.4.0\",\n",
    "                        _model_name: \"LabelModel\",\n",
    "                        _view_count: null,\n",
    "                        _view_module: \"@jupyter-widgets/controls\",\n",
    "                        _view_module_version: \"1.4.0\",\n",
    "                        _view_name: \"LabelView\",\n",
    "                        description: \"\",\n",
    "                        description_tooltip: null,\n",
    "                        placeholder: \"​\",\n",
    "                        value: this._value\n",
    "                    },\n",
    "                    buffer_paths: []\n",
    "                });\n",
    "            }\n",
    "        });\n",
    "    }\n",
    "    \n",
    "    set value(newValue) {\n",
    "        this._value = newValue;\n",
    "        this._wComm.send({\n",
    "            buffer_paths: [],\n",
    "            method: \"update\",\n",
    "            state: {\n",
    "                value: this._value\n",
    "            }\n",
    "        })\n",
    "    }\n",
    "    \n",
    "    _toDisplay() {\n",
    "        return {\n",
    "            \"text/plain\": `Label(value='${this._value}')`,\n",
    "            \"application/vnd.jupyter.widget-view+json\": {\n",
    "                version_major: 2,\n",
    "                version_minor: 0,\n",
    "                model_id: this._wComm.id\n",
    "            }\n",
    "        };\n",
    "    }\n",
    "}\n",
    "\n",
    "// Instantiate it and display it\n",
    "var label = new LabelView(\"This is how we start: $E=mc^2$\");\n",
    "kernel.display(label);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### and if you later go an change the label.value, guess what happens then?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "And this is how we end: ..."
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label.value = `And this is how we end: ...`;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interrupting the kernel\n",
    "I'm talking about clicking this:\n",
    "![Kernel Interrupt Button](imgs/kernel_interrupt_button.png)\n",
    "when you have this (don't ask why!):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Error: Script execution was interrupted by `SIGINT`"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "while(1) {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### or this (_never say never_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "Error",
     "evalue": "Script execution was interrupted by `SIGINT`",
     "output_type": "error",
     "traceback": [
      "Error: Script execution was interrupted by `SIGINT`",
      "    at Script.runInThisContext (vm.js:126:20)",
      "    at Object.runInThisContext (vm.js:316:38)",
      "    at Immediate._onImmediate (/Users/victor.adascalitei/Projects/NodeJS/ijs-playground/src/session/models/promisified_timers.js:23:47)",
      "    at processImmediate (internal/timers.js:439:21)"
     ]
    }
   ],
   "source": [
    "setImmediate(() => { while(1); })"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stops the execution without losing the context.\n",
    "> Note! At the time of writing, there is still a bit of work to be done to fully support this, but we're getting there. \n",
    "\n",
    "This means that this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "will still be `3` provided that you executed the cell that set it\n",
    "```js\n",
    "var c = 3;\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><h1>Happy JSing!</h1></center>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Javascript (Node.js)",
   "language": "javascript",
   "name": "javascript"
  },
  "language_info": {
   "file_extension": ".js",
   "mimetype": "application/javascript",
   "name": "javascript",
   "version": "12.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}