Lecture 2 - Basics of PCs and Data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border:5px outset; width:75%; margin:auto\">\n",
    "<h1 style=\"text-align:center\">Contents Overview</h1>\n",
    "    <ul>\n",
    "        <li><h5><a href=\"#c0\">0: Preface</a></h5></li>\n",
    "        <li><h5><a href=\"#c1\">1: Introduction</a></h5></li>\n",
    "        <li><h5><a href=\"#c2\">2: Computer Hardware</a></h5></li>\n",
    "        <li><h5><a href=\"#c3\">3: Computer Software</a></h5></li>\n",
    "        <li><h5><a href=\"#c4\">4: Data & Storage</a></h5></li>\n",
    "        <li><h5><a href=\"#c5\">5: Summary</a></h5></li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border: 5px ridge; padding:5%\"> \n",
    "<h1 style=\"text-align:right\">Contents Breakdown</h1>\n",
    "<hr style=\"border:2px solid black\" />\n",
    "<hr style=\"border:1px solid gray\" />\n",
    "\n",
    "<h3><a href=\"#c0\">Preface</a></h3>\n",
    "\n",
    "<hr style=\"border:1px solid #F0F0F0\" />\n",
    "\n",
    "<h3><a href=\"#c1\">Chapter 1: Introduction</a></h3>\n",
    "\n",
    "<ul>\n",
    "    <li><h4><a href=\"#s1.1\">&sect;1.1 Brief History of Computers</a></h4></li>\n",
    "    <li><h4><a href=\"#s1.2\">&sect;1.2 How Computers Work</a></h4></li>\n",
    "    <li><h4><a href=\"#s1.3\">&sect;1.3 Levels of Design</a></h4></li>\n",
    "    <li><h4><a href=\"#s1.4\">&sect;1.4 Strengths & Weaknesses of Computers</a></h4></li>\n",
    "</ul>\n",
    "    \n",
    "<hr style=\"border:1px solid #F0F0F0\" />\n",
    "\n",
    "<h3><a href=\"#c2\">Chapter 2: Computer Hardware</a></h3>\n",
    "\n",
    "<ul>\n",
    "    <li><h4><a href=\"#s2.1\">&sect;2.1 Transistors</a></h4></li>\n",
    "    <li><h4><a href=\"#s2.2\">&sect;2.2 Circuits</a></h4></li>\n",
    "    <ul>\n",
    "        <li><h5><a href=\"#2.2.1\">&sect;2.2.1 AND Gate</a></h5></li>\n",
    "        <li><h5><a href=\"#2.2.2\">&sect;2.2.2 OR Gate</a></h5></li>\n",
    "        <li><h5><a href=\"#2.2.3\">&sect;2.2.3 XOR Gate</a></h5></li>\n",
    "        <li><h5><a href=\"#2.2.4\">&sect;2.2.4 NOT Gate</a></h5></li>\n",
    "        <li><h5><a href=\"#2.2.5\">&sect;2.2.5 NAND Gate</a></h5></li>\n",
    "        <li><h5><a href=\"#2.2.6\">&sect;2.2.6 NOR Gate</a></h5></li>\n",
    "    </ul>\n",
    "    <li><h4><a href=\"#s2.3\">&sect;2.3 Computer Components</a></h4></li>\n",
    "    <ul>\n",
    "        <li><h5><a href=\"#2.3.1\">&sect;2.3.1 CPU</a></h5>\n",
    "        <li><h5><a href=\"#2.3.2\">&sect;2.3.2 Memory: RAM</a></h5>\n",
    "        <li><h5><a href=\"#2.3.3\">&sect;2.3.3 Storage: HDD</a></h5>\n",
    "        <li><h5><a href=\"#2.3.4\">&sect;2.3.4 Storage: Flash Storage</a></h5>\n",
    "        <li><h5><a href=\"#2.3.5\">&sect;2.3.5 GPU</a></h5>\n",
    "        <li><h5><a href=\"#2.3.6\">&sect;2.3.6 Inputs & Outputs</a></h5>\n",
    "    </ul>\n",
    "</ul>\n",
    "    \n",
    "<hr style=\"border:1px solid #F0F0F0\" />\n",
    "\n",
    "<h3><a href=\"#c3\">Chapter 3: Computer Software</a></h3>\n",
    "\n",
    "<ul>\n",
    "    <li><h4><a href=\"#s3.1\">&sect;3.1 Architecture</a></h4><li>\n",
    "    <ul>\n",
    "        <li><h5><a href=\"#s3.1.1\">&sect;3.1.1 Machine Code</a></h5></li>\n",
    "        <li><h5><a href=\"#s3.1.2\">&sect;3.1.2 Assembly</a></h5></li>\n",
    "    </ul>\n",
    "    <li><h4><a href=\"#s3.2\">&sect;3.2 Operating Systems</a></h4></li>\n",
    "    <ul>\n",
    "        <li><h5><a href=\"#s3.2.1\">&sect;3.2.1 Running Programs</a></h5></li>\n",
    "        <li><h5><a href=\"#s3.2.2\">&sect;3.2.2 Abnormal Exits</a></h5></li>\n",
    "        <li><h5><a href=\"#s3.2.3\">&sect;3.2.3 Running out of Memory</a></h5></li>\n",
    "        <li><h5><a href=\"#s3.2.4\">&sect;3.2.4 Reboot</a></h5></li>\n",
    "    </ul>\n",
    "    <li><h4><a href=\"#s3.3\">&sect;3.3 Programming Languages & APIs</a></h4></li>\n",
    "    <ul>\n",
    "        <li><h5><a href=\"#s3.3.1\">&sect;3.3.1 Types of Programming Languages</a></h5></li>\n",
    "        <li><h5><a href=\"#s3.3.2\">&sect;3.3.2 Open Source</a></h5></li>\n",
    "    </ul>\n",
    "    <li><h4><a href=\"#s3.4\">&sect;3.4 Applications</a></h4></li>\n",
    "</ul>\n",
    "\n",
    "<hr style=\"border:1px solid #F0F0F0\" />\n",
    "\n",
    "<h3><a href=\"#c4\">Chapter 4: Data & Storage</a></h3>\n",
    "\n",
    "<ul>\n",
    "    <li><h4><a href=\"#s4.1\">&sect;4.1 Bits</a></h4></li>\n",
    "    <li><h4><a href=\"#s4.2\">&sect;4.2 Bytes & Words</a></h4></li>\n",
    "    <ul>\n",
    "        <li><h5><a href=\"#s4.2.1\">&sect;4.2.1 Scales of Bytes</a></h5></li>\n",
    "        <li><h5><a href=\"#s4.2.2\">&sect;4.2.2 Megabyte vs. Mebibyte</a></h5></li>\n",
    "    </ul>\n",
    "    <li><h4><a href=\"#s4.3\">&sect;4.3 Encodings</a></h4></li>\n",
    "    <ul>\n",
    "        <li><h5><a href=\"#s4.3.1\">&sect;4.3.1 Representing Characters</a></h5></li>\n",
    "        <li><h5><a href=\"#s4.3.2\">&sect;4.3.2 Representing Integers</a></h5></li>\n",
    "        <li><h5><a href=\"#s4.3.3\">&sect;4.3.3 Representing Real Numbers</a></h5></li>\n",
    "        <li><h5><a href=\"#s4.3.4\">&sect;4.3.4 ASCII Encoding</a></h5></li>\n",
    "        <li><h5><a href=\"#s4.3.5\">&sect;4.3.5 Unicode Encoding</a></h5></li>\n",
    "        <li><h5><a href=\"#s4.3.6\">&sect;4.3.6 Other Encodings</a></h5></li>\n",
    "    </ul>\n",
    "    <li><h4><a href=\"#s4.4\">&sect;4.4 Data Compression</a></h4></li>\n",
    "    <ul>\n",
    "        <li><h5><a href=\"#s4.4.1\">&sect;4.4.1 Huffman Compression</a></h5></li>\n",
    "        <li><h5><a href=\"#s4.4.2\">&sect;4.4.2 Other Compression Schemes</a></h5></li>\n",
    "    </ul>\n",
    "</ul>\n",
    "\n",
    "<hr style=\"border:1px solid #F0F0F0\" />\n",
    "\n",
    "<h3><a href=\"#c5\">Chapter 5: Summary</a></h3>\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid black\" />\n",
    "<h1><a id=\"c0\">Preface</a></h1>\n",
    "<div style=\"padding: 5% 5% 5% 5%\">\n",
    "    <p>This lecture is intended as a beginner's guide to understanding the underlying complexities of modern PCs. The main topics areas covered are computer hardware, software, and data with the goal of demystifying technology and increasing technical literacy.</p>\n",
    "    <p>This lecture is not required for Lantern's fundamental courses but it may help deepen your understanding and/or provide contexts for certain topics you will encounter later on.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid black\" />\n",
    "<h1><a id=\"c1\">Chapter 1: Introduction</a></h1>\n",
    "<div style=\"padding: 5% 5% 5% 5%\">\n",
    "    <img src=\"images/2.1_desktop_computer.svg\" width=450 />\n",
    "    <p>Computers are very powerful but very literal machines. They are capable of performing billions of operations per second and processing large amounts of data very quickly. However, each individual operation on its own is extremely simple such as adding two numbers or comparing them. Furthermore, the operations that a computer performs must be curated by humans through particular sets of instructions. This means more powerful computers are not smarter, just faster.</p>\n",
    "    <p>Given the complexity of computers and many concepts surrounding their implementation and use, it can sometimes prove useful to think of the concepts in terms of analogies of more familiar situations. Students are encouraged to think of analogies that they understand to help build connects and better intuitive understanding.</p>\n",
    "    <p>For this lecture I will present some analogies to try and simplify the concepts to your benefit. Whenever I include an analogy it will be italicized and the computer equivalent terms/items will be placed in square brackets following their analogical counterpart. For example, the concept that computer are very powerful machine but can only perform simple operations dictated by humans, is analogous to <em>electric beaters [computers] are much faster and more powerful than a whisk [simple calculator] but both are used to mix and cannot make a cake without a chef [programmer/mathematician] handling the device and providing proper ingredients [inputs].</em>.\n",
    "    <p>In essence, computers can be though of as complex (but still stupid) calculators and through this lecture we'll take a look at some of the complexities and abstractions of computers.</p>\n",
    "    <h3><a id=\"s1.1\">&sect;1.1 Brief History of Computers</a></h3><!--##################################################-->\n",
    "    <div style=\"padding: 1% 5% 0% 5%\">\n",
    "        <img src=\"images/2.1_eniac.jpg\" />\n",
    "        <figcaption style=\"text-align:center\">ENIAC, the first programmable electronic & general-purpose computer to up an entire university room.</figcaption>\n",
    "        <p>Modern PCs are purely electronic devices (apart from the HDD) that are programmable for a wide array of purposes. In contrast, the first \"computers\" were mechanical devices that had a singular function. The <a href=\"https://en.wikipedia.org/wiki/History_of_computing_hardware\">abacus</a>, dating back to 2500 BCE, was such a device that allowed the user to quickly perform addition, subtraction, division, multiplication, and store a numerical value. Since such mechanical devices were more efficient at specialized tasks they gained traction and advancements over the millenia until 1822 when Charles Babbage designed the <a href=\"https://en.wikipedia.org/wiki/Analytical_Engine\">first programmable mechanical computer</a> that could utilize punch cards to run a \"program\".</p>\n",
    "        <p>In the past two centuries since, computers have evolved from room-sized mechanical devices to small electronic smartphones that fit into our pockets. The world wars were big proponents for computer developments with particular uses of calculating firing tables and <a href=\"https://en.wikipedia.org/wiki/Colossus_computer\">cracking message encryptions</a>. Post-WWII the discovery of <a href=\"https://en.wikipedia.org/wiki/Transistor_computer\">smaller viable electrical components</a> help propel the production of consumer computers which have made incremental advancements since.</p>\n",
    "    </div>\n",
    "    <h3><a id=\"s1.2\">&sect;1.2 How Computers Work</a></h3><!--##################################################-->\n",
    "    <div style=\"padding: 1% 5% 0% 5%\">\n",
    "        <img src=\"images/2.1_computer_processing.svg\" width=750 />\n",
    "        <figcaption style=\"text-align:center\">Computing hardware is a platform for information processing.</figcaption>\n",
    "        <p>Computers effectively have two functions: store data, and process data. The various hardware components that they're composed of <em>allow</em> them to perform these task, and the programs written by programmers tell them <em>how</em> to perform the tasks. Data is provided as input, either from stored data or from a user, and then the computer follows a series of \"code\" instructions for tasks to perform with the data. Each instruction is a simple mathematics calculation that changes the currently held data and at the end the resulting data is either returned to the user (such as an image or text) or placed into storage for future usage.</p>\n",
    "    </div>\n",
    "    <h3><a id=\"s1.3\">&sect;1.3 Levels of Design</a></h3><!--##################################################-->\n",
    "    <div style=\"padding: 1% 5% 0% 5%\">\n",
    "        <img src=\"https://github.com/pzindel/lantern-prep-course/blob/main/images/2.1_levels_of_design.svg?raw=true\" width=\"100%\">\n",
    "        <p>Given that computers are quite complex machines, they can be broken down into a series of levels ranging from the most basic hardware to the advanced software and data. With each increasing level the abstraction increases meaning we get further and further away from the basic building blocks that allow PCs to function. Luckily, to create programs and work with data we don't require a full understaning of the hardware and architecture.</p>\n",
    "        <p>In the remainder of the lecture we will begin at level 1 and work our way to level 8, covering the key concepts of each level.</p>\n",
    "    </div>\n",
    "    <h3><a id=\"s1.4\">&sect;1.4 Strengths & Weaknesses of Computers</a></h3><!--###############################################-->\n",
    "    <div style=\"padding: 1% 5% 0% 5%\">\n",
    "        <p>Strengths:</p>\n",
    "        <ul>\n",
    "            <li>Very fast</li>\n",
    "            <li>Very accurate</li>\n",
    "            <li>Automatic</li>\n",
    "            <li>Diligent & reliable</li>\n",
    "        </ul>\n",
    "        <p>Weaknesses</p>\n",
    "        <ul>\n",
    "            <li>Literal</li>\n",
    "            <li>Only simple operations</li>\n",
    "            <li>No insight or ability to make decisions</li>\n",
    "            <li>Requires human oversight & instruction</li>\n",
    "        </ul>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid black\" />\n",
    "<h1><a id=\"c2\">Chapter 2: Computer Hardware</a></h1>\n",
    "<div style=\"padding: 5% 5% 5% 5%\">\n",
    "    <p>Computer \"hardware\" refers to the physical parts of the computer, and \"software\" refers to the codes that runs on the computer. While a computer's components and their strengths will vary, they all principally work the same and are composed of the same fundamental blocks that allow them to work.</p>\n",
    "    <p>There are several fundamental electronic bulding blocks that go into computer components and circuits but the most important to understand computer logic is the transistor.</p>\n",
    "    <h3><a id=\"s2.1\">&sect;2.1 Transistors</a></h3><!--##################################################-->\n",
    "    <div style=\"padding:1% 5% 0% 5%\">\n",
    "        <img src=\"images/2.2_transistors.jpg\" width=750 />\n",
    "        <figcaption style=\"text-align:center\">Assorted discrete transistors.</figcaption>\n",
    "        <p>Starting on the first level of design we begin with transistors, one of the important inventions in history and without which most of our modern technology would not be possible. They can be maufactured in various forms that can be as small as 10 nanometers and require miniscule power to function. That allows manufacturers to pack billions of tiny transistors into Central Processing Units (CPUs) that are used by computers.</p>\n",
    "        <p>Transistors are effectively tiny switches that are trigger by electrical signals. The state of the switch determines if electricity is conducted or not. This is analogous to a light switch [transistors] that can be flipped by humans [electrical signals] to change the flow of electricity that turns on a light bulb.</p>\n",
    "        <img src=\"images/2.2_transistor_diagram.png\" width=550 />\n",
    "        <figcaption style=\"text-align:center\">Triggering a transistor using a small electronic signal allows electricity to flow.</figcaption>\n",
    "        <p>This switch like property allow transistors to store two states, on and off, depending on the current flow. As we will see later, this simple two state system can be built up to create more complex systems by combing millions of transistors together. Furthermore transistors can be used to control other electronics and combined to form more complex circuits and components.</p>\n",
    "    </div>\n",
    "    <h3><a id=\"s2.2\">&sect;2.2 Circuits</a></h3><!--##################################################-->\n",
    "    <div style=\"padding:1% 5% 0% 5%\">\n",
    "        <p>On level two of system design we have these circuits that are composed of transistors and other basic electrical components. These circuits vary for different applications ranging from power regulation circuits to signal filters and amplifiers. The ones of interest with respect to computers are <em>logic gates</em>.</p>\n",
    "        <p>Digital logic gates are circuits that can take multiple inputs signals, combine them in a particular way (i.e. perform some calculation), and provide one output signal. This is similar to how regular calculators [logic gates] can take multiple numbers [input signals], combine them through some operation, and provide a final resulting number [output signal]. In fact, the calculator, just like all computers, is built with logic gates to perform these computations.</p>\n",
    "        <img src=\"images/2.2_and_gate.gif\" width=350 />\n",
    "        <img src=\"images/2.2_or_gate.gif\" width=350 />\n",
    "        <figcaption style=\"text-align:center; margin: 1% 10% 0% 10%\">Light switch analogy for logic gates. (Top) Both A <b>and</b> B must be closed for the current to flow. (Bottom) Either A <b>or</b> B must be closed for the current to flow.</figcaption>\n",
    "        <p>Similar to how transistors can be thought of as switches, logic gates can be thought of as systems for combing those switches in specific ways to achieve a final output signal. In the images above we can see that analogy using light bulbs and regular circuit switches. The top image represent an <b>AND</b> gate where the light only turns if both A and B are closed (or triggered in the case of transistors). The bottom image represents an <b>OR</b> gate where the light turns on if either A or B are closed. This system creates a basis for combing input signals to perform simple logic operation.</p>\n",
    "        <p>These logic gates come in several different types and can be used in yet more complex circuits for corresponding situations. They are the backbone of arithmetic in calculators and computers, allowing for operations such as addition, multiplication, subtraction, and division.</p>\n",
    "        <p>For digital logic gates, the input signals are typically considered as 0s (off) or 1s (on). Each type of logic gate has a corresponding truth table which dictates what the state of the output signal is given the input signals. The following are the fundamental gate types and their respective truth tables.</p>\n",
    "        <h5><a id=\"2.2.1\">&sect;2.2.1 AND Gate</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>Takes 2 inputs, of which each are either 0 or 1, and outputs a 1 only if both inputs are 1. I.e. A <b>and</b> B are 1 (on).</p>\n",
    "            <img src=\"https://github.com/pzindel/lantern-prep-course/blob/main/images/2.2_AND_ANSI_Labelled.svg?raw=true\" width=60%>\n",
    "            <table style=\"text-align: center\">\n",
    "                <tbody><tr bgcolor=\"#ddeeff\">\n",
    "                <th colspan=\"2\">INPUT</th>\n",
    "                <th>OUTPUT\n",
    "                </th></tr>\n",
    "                <tr bgcolor=\"#ddeeff\">\n",
    "                <td>A</td>\n",
    "                <td>B</td>\n",
    "                <td>Q\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>0</td>\n",
    "                <td>0</td>\n",
    "                <td>0\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>0</td>\n",
    "                <td>1</td>\n",
    "                <td>0\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>1</td>\n",
    "                <td>0</td>\n",
    "                <td>0\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>1</td>\n",
    "                <td>1</td>\n",
    "                <td>1\n",
    "                </td></tr></tbody>\n",
    "            </table>\n",
    "        </div>\n",
    "        <h5><a id=\"2.2.2\">&sect;2.2.2 OR Gate</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>Takes 2 inputs, of which each are either 0 or 1, and outputs a 1 only if at least on input is 1. I.e. A <b>or</b> B are 1.</p>\n",
    "            <img src=\"https://github.com/pzindel/lantern-prep-course/blob/main/images/2.2_OR_ANSI_Labelled.svg?raw=true\" width=60%>\n",
    "            <table  style=\"text-align: center\">\n",
    "                <tbody><tr bgcolor=\"#ddeeff\">\n",
    "                <th colspan=\"2\">INPUT</th>\n",
    "                <th>OUTPUT\n",
    "                </th></tr>\n",
    "                <tr bgcolor=\"#ddeeff\">\n",
    "                <td>A</td>\n",
    "                <td>B</td>\n",
    "                <td>Q\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>0</td>\n",
    "                <td>0</td>\n",
    "                <td>0\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>0</td>\n",
    "                <td>1</td>\n",
    "                <td>1\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>1</td>\n",
    "                <td>0</td>\n",
    "                <td>1\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>1</td>\n",
    "                <td>1</td>\n",
    "                <td>1\n",
    "                </td></tr></tbody>\n",
    "            </table>\n",
    "        </div>\n",
    "        <h5><a id=\"2.2.3\">&sect;2.2.3 XOR Gate (Exlcusive OR)</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>Takes 2 inputs, of which each are either 0 or 1, and outputs a 1 only if both inputs are different. I.e. A is 1 and B is 0 <b>or</b> A is 0 and B is 1.</p>\n",
    "            <img src=\"https://github.com/pzindel/lantern-prep-course/blob/main/images/2.2_XOR_ANSI_Labelled.svg?raw=true\" width=60%>\n",
    "            <table  style=\"text-align: center\">\n",
    "                <tbody><tr bgcolor=\"#ddeeff\">\n",
    "                <th colspan=\"2\">INPUT</th>\n",
    "                <th>OUTPUT\n",
    "                </th></tr>\n",
    "                <tr bgcolor=\"#ddeeff\">\n",
    "                <td>A</td>\n",
    "                <td>B</td>\n",
    "                <td>Q\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>0</td>\n",
    "                <td>0</td>\n",
    "                <td>0\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>0</td>\n",
    "                <td>1</td>\n",
    "                <td>1\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>1</td>\n",
    "                <td>0</td>\n",
    "                <td>1\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>1</td>\n",
    "                <td>1</td>\n",
    "                <td>0\n",
    "                </td></tr></tbody>\n",
    "            </table>\n",
    "        </div>\n",
    "        <h5><a id=\"2.2.4\">&sect;2.2.4 NOT Gate</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>Takes 1 input, which is either 0 or 1, and outputs the opposite of the input. I.e. If A is 1 then <b>not</b> A is 0, and vice versa.</p>\n",
    "            <img src=\"https://github.com/pzindel/lantern-prep-course/blob/main/images/2.2_NOT_ANSI_Labelled.svg?raw=true\" width=60%>\n",
    "            <table  style=\"text-align: center\">\n",
    "                <tbody><tr bgcolor=\"#ddeeff\">\n",
    "                <th>INPUT</th>\n",
    "                <th>OUTPUT\n",
    "                </th></tr>\n",
    "                <tr bgcolor=\"#ddeeff\">\n",
    "                <td>A</td>\n",
    "                <td>Q\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>0</td>\n",
    "                <td>1\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>1</td>\n",
    "                <td>0\n",
    "                </td></tr></tbody>\n",
    "            </table>\n",
    "        </div>\n",
    "        <h5><a id=\"2.2.5\">&sect;2.2.5 NAND Gate (NOT AND)</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>Takes 2 inputs, of which each are either 0 or 1, and outputs a 1 only if both inputs are not 1. I.e. A <b>and</b> B are <b>not</b>1.</p>\n",
    "            <p>Note: the output is the opposite of an AND Gate.</p>\n",
    "            <img src=\"https://github.com/pzindel/lantern-prep-course/blob/main/images/2.2_NAND_ANSI_Labelled.svg?raw=true\" width=60%>\n",
    "            <table  style=\"text-align: center\">\n",
    "                <tbody><tr bgcolor=\"#ddeeff\">\n",
    "                <th colspan=\"2\">INPUT</th>\n",
    "                <th>OUTPUT\n",
    "                </th></tr>\n",
    "                <tr bgcolor=\"#ddeeff\">\n",
    "                <td>A</td>\n",
    "                <td>B</td>\n",
    "                <td>Q\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>0</td>\n",
    "                <td>0</td>\n",
    "                <td>1\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>0</td>\n",
    "                <td>1</td>\n",
    "                <td>1\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>1</td>\n",
    "                <td>0</td>\n",
    "                <td>1\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>1</td>\n",
    "                <td>1</td>\n",
    "                <td>0\n",
    "                </td></tr></tbody>\n",
    "            </table>\n",
    "        </div>\n",
    "        <h5><a id=\"2.2.6\">&sect;2.2.6 NOR Gate (NOT OR)</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>Takes 2 inputs, of which each are either 0 or 1, and outputs a 1 only if both inputs are 0. I.e. The opposite of A <b>or</b> B are 1.</p>\n",
    "            <img src=\"https://github.com/pzindel/lantern-prep-course/blob/main/images/2.2_NOR_ANSI_Labelled.svg?raw=true\" width=60%>\n",
    "            <table  style=\"text-align: center\">\n",
    "                <tbody><tr bgcolor=\"#ddeeff\">\n",
    "                <th colspan=\"2\">INPUT</th>\n",
    "                <th>OUTPUT\n",
    "                </th></tr>\n",
    "                <tr bgcolor=\"#ddeeff\">\n",
    "                <td>A</td>\n",
    "                <td>B</td>\n",
    "                <td>Q\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>0</td>\n",
    "                <td>0</td>\n",
    "                <td>1\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>0</td>\n",
    "                <td>1</td>\n",
    "                <td>0\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>1</td>\n",
    "                <td>0</td>\n",
    "                <td>0\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>1</td>\n",
    "                <td>1</td>\n",
    "                <td>0\n",
    "                </td></tr></tbody>\n",
    "            </table>\n",
    "        </div>\n",
    "    </div>\n",
    "    <h3><a id=\"s2.3\">&sect;2.3 Computer Components</a></h3><!--##################################################-->\n",
    "    <div style=\"padding:1% 5% 0% 5%\">\n",
    "        <img src=\"images/2.3_pc_components.jpg\" width=750 />\n",
    "        <p>Moving up another level of abstraction we get to the computer components. Again, these components are built using a series of lower level circuits and each computer component is designed to handle a specific task. There are a handful of components that computers require to run: CPU, RAM, HDD, Motherboard, and PSU.</p>\n",
    "        <h5><a id=\"2.3.1\">&sect;2.3.1 CPU</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>The central processing unit (CPU) is the \"brain\" of the computer. It's composed of billions of transistors and handles the crucial operations and calculations. The CPU receives input data and performs binary operations (via logic gates) based on the binary instructions provided to it.</p>\n",
    "            <p>A computers CPU is also responsible for handling communication with I/O (input-ouput) devices such as keyboards, mice, and monitors.</p>\n",
    "        </div>\n",
    "        <h5><a id=\"2.3.2\">&sect;2.3.2 Memory: RAM</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>The instructions and data that a CPU uses to function must come from somewhere. The memory and storage are the PC components that handle these functions and store data.</p>\n",
    "            <p>Memory, or more specifically RAM (random access memory), is the component that handles the computers immediate and short term data storage. The CPU receives data directly from RAM and any time a program is running on a computer, its instruction set and data is kept in RAM.</p>\n",
    "            <p>RAM has the benefit of being very easily accessible and fast which means the CPU doesn't have to wait to retrieve crucial information. The drawback is that RAM is only for short-term memory that is forgotten when the computer turns off or a program is stopped. For this reason the size of RAM on PCs is typically quite limited.\n",
    "        </div>\n",
    "        <h5><a id=\"2.3.3\">&sect;2.3.3 Storage: HDD</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>Given that we may want to store data for longer periods of time, lasting several on-off cycles of a computer, PCs also have long term storage from HDDs (hard disk drives). These HDDs physically store information on magnetic platters that is retained even when the computer is turned off for long periods of time.</p>\n",
    "            <p>Since HDDs provide more permanent storage, they have an order of magnitude more space than RAM (about 100-1000 times as much). The tradeoff is that HDDs are much slower to process and retrieve data so when it comes time to work with data in the CPU, the data is first loaded from the HDD into RAM where it can be easily accessed.\n",
    "        </div>\n",
    "        <h5><a id=\"2.3.4\">&sect;2.3.4 Storage: Flash Storage</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>Flash storage (Solid State Drives & thumb drives) is an alternative to HDDs that stores information using tiny pockets of electricity instead of magnetic disks. It utilizes many of the same basic circuitry that RAM uses but in a way that allows information to be retained when the power is turned off. As a result, flash storage is much faster than traditional HDDs.</p>\n",
    "            <p>The drawbacks of flash storage are the price of the component and the degrading of its internal parts. Storing vast amounts of data on flash storage is much more expensive than doing so on HDDs making it less suitable for bulk storage. Additionally, flash storage has rewrite limitations and more strict wear on the physical components than HDDs. This means if the data stored on the drive is being continuously overwritten or a drive is being used for long term storage (disconnected from power for years or decades) than HDDs are the better choice for their higher reliability.</p>\n",
    "        </div>\n",
    "        <h5><a id=\"2.3.5\">&sect;2.3.5 GPU</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>With the rise of modern graphical applications such as gaming, video editing, and photo processing, computers have gotten a new component to help the CPU with data processing. GPUs (graphical processing units) are effectively secondary CPUs that are designed specifically to handle graphical computations. This makes them particulary desired for AI (artifical intelligence) and ML (machine learning) applications where grahpics, such as images and video, are utilized.</p>\n",
    "            <p>While GPUs are note strictly necessary for a computer to function, most modern PCs require GPU to provide graphical outputs for the user to interact with.</p>\n",
    "        </div>\n",
    "        <h5><a id=\"2.3.6\">&sect;2.3.6 Inputs & Outputs</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>All remaining components of PCs fall under the category of I/O (inputs and outputs). These components are the ones that allow a user to provide input to the computer and receive an output of the computers calcualtions. This includes components like keyboards, mice, webcams, microphones, speakers, and monitors.</p>\n",
    "        </div>\n",
    "        <p>The PSU (power supply unit) and motherboard are also essential components. The PSU is the simplest component with the sole purpose of supplying the system with regulated power to function, and the motherboard is the vessel that holds all components together, allowing them to communicate with each other.</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid black\" />\n",
    "<h1><a id=\"c3\">Chapter 3: Computer Software</a></h1>\n",
    "<div style=\"padding: 5% 5% 5% 5%\">\n",
    "    <img src=\"images/2.3_software.png\" width=750 />\n",
    "    <p>Proceeding onto the second tier of the systems design hierarchy we have all of the levels that fall under software. Having covered the basic construction of computers and their purpose of processing input data to provide outputs, we turn to how instructions are provided to computers and how programmers and end-users interact with them.</p>\n",
    "    <p>In essence, computer code is a series of instructions, each performing a single operation towards a desired final output calcualtions or goal. The code is created by programmers and provided to the computer to process one after another.</p>\n",
    "    <p>There are a series of levels and abstractions involved with computer software that allow for more and more complex tasks to be done without having to worry about the exact details of how a computer will handle that task.</p>\n",
    "    <h3><a id=\"s3.1\">&sect;3.1 Architecture</a></h3><!--##################################################-->\n",
    "    <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>On level 4 we have the computer architecture. This level includes the most primative software interaction with the physical hardware. The architecture refers to the instructions sent by software the can be understood by hardware. The computer's architecture is designed by the hardware manufacturer to allow something called machine code to instruct the I/O and calculation behaviour of the entire machine.</p>\n",
    "        <img src=\"images/2.3_machine_code_assembly.jpg\" width=750 />\n",
    "        <h5><a id=\"s3.1.1\">&sect;3.1.1 Machine Code</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>The machine code is machine-specific instruction language that is written in binary (using 1s and 0s) which allows computers to operate.</p>\n",
    "        </div>\n",
    "        <h5><a id=\"s3.1.2\">&sect;3.1.2 Assembly</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>Assembly language is a step up from machine code (though still on the architecture level) using symbolic language for the machine code components (addresses and instructions. This allows for slightly more human read-able code and machine interaction.</p>\n",
    "            <p>Some low-level programming languages (see below) can be on nearly the same level as assembly given their close proximity with machine instructions. However, most programming languages and the programmers using them are doing so in more abstract ways layered on operating systems.</p>\n",
    "        </div>\n",
    "    </div>\n",
    "    <h3><a id=\"s3.2\">&sect;3.2 Operating Systems</a></h3><!--##################################################-->\n",
    "    <div style=\"padding:1% 5% 0% 5%\">\n",
    "        <img src=\"images/2.3_os.png\" width=750 />\n",
    "        <p>An OS (operating system) is effectively a program written in assembly that provides more high-level usability and user interaction. OS is capable of running multiple (even higher-level) programs at once (called sandboxing) and manages the shared resources of the machine. For example, if two programs are run at once the OS will manage the RAM allocated to each and the CPU time based on their priority.</p>\n",
    "        <p>OS is also responsible for mantaining the file system and managing the grapical windows that users interact with.</p>\n",
    "        <h5><a id=\"s3.2.1\">&sect;3.2.1 Running Programs</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>Under normal running codnditions, a program and its related data is stored in the file system on a HDD. The OS loads the program file (in machine code) and required data (e.g. text file to alter) into free RAM. The CPU then iterates over a \"fetch/execute cycle\" where instructions in the program are fetched and executed, one at a time, in the order that they appear. Once the program finished, or the user quits the program, the OS reclaims the shared resources.</p>\n",
    "        </div>\n",
    "        <h5><a id=\"s3.2.2\">&sect;3.2.2 Abnormal Exits</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>When a program stop responding due to some error or bug the program is forcefully quit, either by the system or by the user through the task manager. The OS then reclaims the shared resources and any data that was being calculated or stored in RAM is lost.</p>\n",
    "        </div>\n",
    "        <h5><a id=\"s3.2.3\">&sect;3.2.3 Running out of Memory</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>It's possible for a system to have insufficient RAM when running a program. This mainly occurs for two reasons: the program is processing data that is too large to fit into RAM, or there is a memory leak. Since RAM is a limited and shared resource it is quite common to run into the first reason. The system RAM is divided among running programs and if a program is trying to request more RAM than available the system will refuse the request. Similarly, a program may continuously load new data into RAM and if there's a memory leak the unsed RAM is not being properly released back to the system for reallocation. This means the program continues to use more and more RAM until there is none left and the request is refused.</p>\n",
    "            <p>When a RAM request is refused due to insufficient resources, the OS and the program typically give the user an error to report the mistake. However since RAM is required for the system and programs to function, when the RAM is at 100% usage the system or program may just stop responding and crash.</p>\n",
    "            <p>The correct management of RAM is of particular interest to software developers and data scientist. When developing a user application, a software developer should strive to make the program as RAM efficient as possible to ensure that users can utilize the application on a wider range of devices without any resource issues. Data scientists should also be wary of high RAM usage that occurs when they wish to work with large amounts of data. Whenever the data scientist is working with the data directly is needs to be loaded into RAM which can be limiting. There are methods to help combat such issues such as loading data in more managable batches and then unloading before processing the next batch.</p>\n",
    "        </div>\n",
    "        <h5><a id=\"s3.2.4\">&sect;3.2.4 Reboot</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>Rebooting a PC is a tried and true method of fixing temporary running errors of a system. Often times these errors are a result of bugs in the operating systems or glitches in the hardware that causes programs to function improperly. By rebooting the PC the RAM is wiped and the OS can start fresh.</p>\n",
    "            <p>While rebooting a PC should theoretically never by necessary, in practice systems and programs are prone to these kinds of errors.</p>\n",
    "        </div>\n",
    "    </div>\n",
    "    <h3><a id=\"s3.3\">&sect;3.3 Programming Languages & APIs</a></h3><!--##################################################-->\n",
    "    <div style=\"padding:1% 5% 0% 5%\">\n",
    "        <img src=\"images/2.3_programming_languages.png\" width=750 />\n",
    "        <p>Moving up to level 6 of the system design we have programming languages and APIs. This is just one level down from where most end-users work from. On this level, software developers work to design applications and data scientists create programs to efficiently process data.</p>\n",
    "        <p>The programs can be written using a variety of different programming languages and interfacing with various OS-level APIs and internet-accessed APIs. The programming languages themselves have different levels of abstraction depending on the language syntax and how much control a programmer has over the system resource allocation. From a higher-level point of view, it doesn't matter which programming language is used to control the program and PC since all programs need to be translated into assembly and machine code for a computer to run it.</p>\n",
    "        <h5><a id=\"s3.3.1\">&sect;3.3.1 Types of Programming Languages</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <img src=\"images/2.3_types_of_languages.png\" width=750 />\n",
    "            <p>Programming languages are typically split into two categories: interpreted languages, and compiled languages. High-level languages such as Python and Javascript fall under the former and low-level languages like C and C++ fall under the latter.</p>\n",
    "            <p>Interpreted languages are languages whose instructions can be run as their are being read by the system. In other words the system translates a line of the program into machine code and executes the instruction before translating the next line. This method of running a program makes it easier to develop and test while also increase the programs cross-platform capability. However, if we wish to run the program multiple times, the code needs to be translated each time. This also means interpreted languages are often slower to run.</p>\n",
    "            <p>Compiled languages on the other hand, are translated into machine code all at once and packaged into a new program file (e.g. .exe file) that is ready to run. That means when the program (source code) is compiled you can quickly run it multiple times with having to translate and compile the program each time. The drawback of this method is that the program needs to be recompiled with modified instructions if we wish to execute it on a different machine. Only the source code can be edited, not the .exe file.</p>\n",
    "            <p>The primary tradeoff between high-level and low-level languages is the amount of control over the system's hardware. High-level languages offer syntax that is closer to human languages making it easy for programmers to understand. Additionally, they often provide built-in functions and libraries to programmers that handle many basic, and some complex, tasks that programmer may wish to do. Low-level languages may be harder to understand and offer more limited ready-to-use functionality but at the great benefit of giving programmer control over hardware resources which allow programs to be more efficient and faster.</p> \n",
    "        </div>\n",
    "        <h5><a id=\"s3.3.2\">&sect;3.3.2 Open Source</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>Open source is a practice that makes a software's source code openly available to everyone. The source code is typically released under a open-source license that makes that software free to use but dictates how users are allowed to use, modify, and distribute the software. The licenses are generally quite liberal for non-commerical use.</p>\n",
    "            <p>Some examples of software that typically use open-source licenses are:</p>\n",
    "            <ul>\n",
    "                <li>Programming languages</li>\n",
    "                <li>Internet browsers<li>\n",
    "                <li>Operating systems (Linux)</li>\n",
    "                <li>Program compilers</li>\n",
    "            </ul>\n",
    "            <p>Open-source software is typically hosted on large code repository sites such as GitHub or GitLab. The adoption of these sites makes sharing software very simple and provides users with incentives to participate and contribute their changes to the source code.</p>\n",
    "            <p>Open-source practices come with the benefit of producing higher quality and reliable software. This is because open-source code can be audited by an entire community of developers who highlight any bugs and security flaws. The auditing process also ensures that software is not taking advantage of its users through unethical practices. One drawsback of the practice is that your market competitors can audit your source code which will potentially put you at a disadvantage if you are commercializing your software.</p>\n",
    "        </div>\n",
    "    </div>\n",
    "    <h3><a id=\"s3.4\">&sect;3.4 Applications</a></h3><!--##################################################-->\n",
    "    <div style=\"padding:1% 5% 0% 5%\">\n",
    "        <p>We have now reach the upper levels of the system design with application at level 7. Applications include any user-ready program that you can run on your computer usually through an .exe (Windows) or .app (Mac) file. This includes programs like Microsoft Word, Google Chrome, or Notepad++ and many more.</p>\n",
    "        <p>Appplications provide yet another layer of abstraction from the previous level. The end-user of a program doesn't typically need to know how the application works behind the scenes. Nor is it necessary to know how the computer hardware, architecture, or OS work to utilize an application.</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid black\" />\n",
    "<h1><a id=\"c4\">Chapter 4: Data & Storage</a></h1>\n",
    "<div style=\"padding:5% 5% 5% 5%\">  \n",
    "    <img src=\"images/2.4_file_formats.jpg\" width=550 />\n",
    "    <p>At the final level of our system design diagram we come to the data level. In truth, data is really a part of all previous software levels, especially for operating systems and programming, however applications are generally designed with the intention of creating and manipulating user data thus I have chosen to present it as a dedicated level of design. As a data scientist or software developer you will encounter a variety of data file type/formats such as .txt, .csv, .json, etc. While I won't delve into those high-level formats here, it is a good idea to review some of the common types (such as what differentiates them) and read-up on new formats as you encounter them in your studies and work.</p>\n",
    "    <p>For this part of the lecture we are focusing primarly on the low-level aspects of data and how data is represented and stored by the computer. This should give you some insight to data manipulation that you can/need to perform when writing programs. Additionally I have included a bonus section on data compression which is something interesting to keep in mind when you are working with large data files or storing data on a computer in high-level formats.</p>\n",
    "    <h3><a id=\"s4.1\">&sect;4.1 Bits</a></h3><!--##################################################-->\n",
    "    <div style=\"padding:1% 5% 0% 5%\">\n",
    "        <p>Recall that transistors, which are at the heart of computers, have two states: on or off. Any dual-state system can be described as being <b>binary</b> and can be represented using a binary number. These binary number are from the base-2 numeral system that only uses digits 0 and 1 (recall that I used 0s and 1s to represent input states for logic gates; this is why). A base-2 numeral system is no different from the regular base-10 (decimal) system we normally use, it just uses fewer digits to represent the same numbers.</p>\n",
    "        <p>When it comes to computers and data, these binary numbers are call <b>bits</b>. I.e. a single bit can have two states, 0 or 1. These bits can be chained together to form larger numbers, similar to the digits of the decimal system when we exceed a value of 9.</p> \n",
    "    </div>\n",
    "    <h3><a id=\"s4.2\">&sect;4.2 Bytes & Words</a></h3><!--##################################################-->\n",
    "    <div style=\"padding:1% 5% 0% 5%\">\n",
    "        <img src=\"images/2.4_bits_bytes_words.gif\" width=550 />\n",
    "        <p>Given that bits on their own are not very useful for representing data, computers group 8 bits together to form <b>bytes</b>. This means a byte has $2^8 = 256$ possible states. Note that in practice programmers and computers often use hexadecimal (base-16) to represent a byte since two full hexadecimal digits can represent all possible values.</p>\n",
    "        <p>Modern computers combine bytes into groups of 4 (32-bits) or 8 (64-bits) to form what called a <b>word</b>. These words are more useful for computers to use than single bytes since the data they process usually requires more than just 256 possible states. A 64-bit word has over 18 billion billion ($18x10^18$) possible values. The way these words are processed is part of the hardware and architecture design which is why OS like Windows as 32-bit and 64-bit versions. The CPU read full words from RAM at a time rather than just single bits or bytes.\n",
    "        <h5><a id=\"s4.2.1\">&sect;4.2.1 Scales of Bytes</a></h5>\n",
    "            <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>There are naming conventions used for large data based on the number of bytes that the data requires to represent or store. Each prefix implies 1000 times larger than the previous prefix.</p>\n",
    "            <ul>\n",
    "                <li>1 kilobyte (KB) = 1000 B (1000 bytes): used for measuring text documents</li>\n",
    "                <li>1 megabyte (MB) = 1000 KB (1 million bytes): used for measuring audio & image files</li>\n",
    "                <li>1 gigabyte (GB) = 1000 MB (1 billion bytes): used for measuring video files & PC storage space</li>\n",
    "                <li>1 terabyte (TB) = 1000 GB (1 trillion bytes): used for measuring PC storage space & \"big data\"</li>\n",
    "                <li>1 petabyte (PB) = 1000 TB (1 quadrillion bytes)</li>\n",
    "            </ul>\n",
    "            </div>\n",
    "        <h5><a id=\"s4.2.2\">&sect;4.2.2 Megabyte vs. Mebibyte</a></h5>\n",
    "            <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>Since bits and bytes are based on the binary system larger scales of data are preferably also measured in powers of 2. As a result it's common to scale up by a factor of $2^10=1024$ (using the IEC prefixes) rather than 1000 (which uses the SI prefixes). Given the two different scaling methods there are two different prefix naming conventions as well.</p>\n",
    "            <ul>\n",
    "                <li>1 kibibyte (KiB) = 1024 B (1024 bytes)</li>\n",
    "                <li>1 mebibyte (MiB) = 1024 KiB ($1024^2$ bytes)</li>\n",
    "                <li>1 gibibyte (GiB) = 1024 MiB ($1024^3$ bytes)</li>\n",
    "                <li>1 tebibyte (TiB) = 1024 GiB ($1024^4$ bytes)</li>\n",
    "                <li>1 pebibyte (PiB) = 1024 TiB ($1024^5$ bytes)</li>\n",
    "            </ul>\n",
    "            <p>Note that SI prefixes are sometimes used interchangably with either 1000 or 1024 scales. Many programs (e.g. Windows) and older IT professionals use KB to mean 1024 bytes, whereas PC part manufacturers and marketers use KB to mean 1000 bytes (to make the product seem larger).</p>\n",
    "            </div>\n",
    "    </div>\n",
    "    <h3><a id=\"s4.3\">&sect;4.3 Encodings</a></h3><!--##################################################-->\n",
    "    <div style=\"padding:1% 5% 0% 5%\">\n",
    "        <img src=\"images/2.4_encoding.png\" width=750 />\n",
    "        <p>We've seen how binary data is stored on the computer but what about working with more complex characters such as letters or emojis? That's where encodings come in.</p>\n",
    "        <p>Encodings are systems for representing data, and in this case, representing characters using binary numbers. These encoding serve as ways for computers and humans to interact more easily since humans don't intuitively understand binary and computers only understand binary. There's are many ways that characters can be represented in binary which is why a few universal standards have been developed over the years to allow computer systems world wide to be more compatible.</p>\n",
    "        <h5><a id=\"s4.3.1\">&sect;4.3.1 Representing Characters</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>There are two main encoding types that are typically used for representing characters: ASCII and Unicode. ASCII is an older standard based each character being represented by a single byte (8 bits). That means according to ASCII, a maximum of 256 character could be encoded. Unicode is a newer standard that defines several encoding formats, most notablely UTF-8 and UTF-16. The UTF-8 is the most common encoding format which uses a variable 1 to 4 bytes to represent characters. It's defined in such as way that the old ASCII encoding are preserved for maximum compatibility.</p>\n",
    "        <p>Unicode encodings are controlled by The Unicode Consortium which controls which characters get added to the encoding format including emojis.</p>\n",
    "        </div>\n",
    "        <h5><a id=\"s4.3.2\">&sect;4.3.2 Representing Integers</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>When working with numbers there are also two way that they can be represented. The first method is using the character encodings mentioned in the previous section. Since numbers and mathematical notation is part of the ASCII and Unicode standards, we could represent them similar to letters. However, that format would be inefficient for large numbers and it would slow don't mathematical caluclations. The second method is to just use a few bytes and their regular binary representation.</p>\n",
    "            <p>Integers are stored using one computer word (32 or 64 bits) with larger numbers using several computer words to avoid overflow issues. The values are stored directly in binary form (e.g. the value 7 is stored as 0111) which can be manipulated easily (e.g. $7+5=12$ is $0111+0101=1100$).</p>\n",
    "        </div>\n",
    "        <h5><a id=\"s4.3.3\">&sect;4.3.3 Representing Real Numbers</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>Real numbers (non-whole numbers) are stored similar to integers but with one main difference: the number is store as an exponential number. The exponential number has three parts: the sign, the exponent, and the fractional value. This method allows computers to decompose any number, no matter how large, and easily store its value. The drawback of this method is that the number of bytes used is limited which means the stored number is not perfectly precise (though precise enough for most applications).</p>\n",
    "            <p>For example, the number 7.5 could be converted and stored as $1.875 x 2^2$. However if the computer is limited to 3 significant digits in the fractional portion (normally the number of significant digits is much higher) then 7.5 is stored as $1.88 x 2^2$ and if we convert the number back to a regular decimal we get 7.52 instead of 7.5 because of the precision tradeoff.</p>\n",
    "        </div>\n",
    "        <h5><a id=\"s4.3.4\">&sect;4.3.4 ASCII Encoding</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <img src=\"images/2.4_ascii_table.svg\" width=750 />\n",
    "        </div>\n",
    "        <h5><a id=\"s4.3.5\">&sect;4.3.5 Unicode Encoding</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p><a href=\"https://unicode-table.com/en/\">https://unicode-table.com/en/</a></p>\n",
    "        </div>\n",
    "        <h5><a id=\"s4.3.6\">&sect;4.3.6 Other Encodings</a></h5>   \n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <p>In addition to the ASCII and Unicode standards, there are other encodings as well (e.g. ISO/IEC 8859) which may deviate or be incompatible with other standards. If you are working with a variety of different data you will eventually come across encoding errors that will require you to research the type of encoding used in a file and how to convert to a more usable format.</p>\n",
    "        </div>\n",
    "    </div>\n",
    "    <h3><a id=\"s4.4\">&sect;4.4 Data Compression</a></h3><!--##################################################-->\n",
    "    <div style=\"padding:1% 5% 0% 5%\">\n",
    "        <p>Whenever working with potentially large amounts of data it is always a good idea to keep data compression in mind. Compression involves storing information using fewer bytes through more efficient techniques. This can come in the form of two types: lossless and lossy.</p>\n",
    "        <p>Lossless compression is any method that stores data in alternate, more space efficient, forms without removing any data. These methods rely on being more efficient at storing specific types of data.</p>\n",
    "        <p>Lossy compression is any method that compresses data by removing less important data. Lossy compression methods may also implement lossless compression techniques to further increase the compression ratios.</p>\n",
    "        <p>Here's an example: suppose we have the data values 12000, 12002, 12006, 12007, 12010, 12006, 12005.</p>\n",
    "        <ul>\n",
    "            <li>A lossless compression scheme may improve on storage space by storing the differences from one value to the next rather than storing the values themself, i.e. 12000, +2, +4, +1, +3, -4, -1. If we then wish to recreate the original data we will get back the all of the original information.</li>\n",
    "            <li>A lossy compression scheme may improve on space by only storing every other value, i.e. 12000, (xxx), 12006, (xxx), 12010, (xxx), 12005. If we then wish to recreate the original data we might just fill the gaps with the average of the surrounding values, i.e. 12000, (12003), 12006, (12008), 12010, (12007), 12005.\n",
    "        </ul>\n",
    "        <h5><a id=\"s4.4.1\">&sect;4.4.1 Huffman Compression</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <table  style=\"text-align: center\">\n",
    "                <tbody><tr bgcolor=\"#ddffdd\">\n",
    "                <th>Char</th>\n",
    "                <th>ASCII value</th>\n",
    "                <th>ASCII (binary)</th>\n",
    "                <th>Huffman (binary)\n",
    "                </th></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>' '</td>\n",
    "                <td>32</td>\n",
    "                <td>00100000</td>\n",
    "                <td>10\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>'a'</td>\n",
    "                <td>97</td>\n",
    "                <td>01100001</td>\n",
    "                <td>0001\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>'b'</td>\n",
    "                <td>98</td>\n",
    "                <td>01100010</td>\n",
    "                <td>0111010\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>'c'</td>\n",
    "                <td>99</td>\n",
    "                <td>01100011</td>\n",
    "                <td>001100\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>'e'</td>\n",
    "                <td>101</td>\n",
    "                <td>01100101</td>\n",
    "                <td>1100\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>'z'</td>\n",
    "                <td>122</td>\n",
    "                <td>01111010</td>\n",
    "                <td>00100011010\n",
    "                </td></tr></tbody>\n",
    "            </table>\n",
    "        </div>\n",
    "        <h5><a id=\"s4.4.2\">&sect;4.4.2 Other Compression Schemes</a></h5>\n",
    "        <div style=\"padding:1% 5% 0% 5%\">\n",
    "            <table  style=\"text-align: center\">\n",
    "                <tbody><tr bgcolor=\"#ddffdd\">\n",
    "                <th>Scheme</th>\n",
    "                <th>Lossless vs. Lossy</th>\n",
    "                <th>Medium</th>\n",
    "                <th>Notes\n",
    "                </th></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>MP3</td>\n",
    "                <td>Lossy</td>\n",
    "                <td>Audio</td>\n",
    "                <td>10 times less space but still sounds good\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>JPEG</td>\n",
    "                <td>Lossy</td>\n",
    "                <td>Images</td>\n",
    "                <td>Free and open source; widely used and supported\n",
    "                </td></tr>\n",
    "                <tr bgcolor=\"#ddffdd\">\n",
    "                <td>GIF & PNG</td>\n",
    "                <td>Lossless</td>\n",
    "                <td>Images</td>\n",
    "                <td>PNG is a bit better; mostly used for non-photographs\n",
    "                </td></tr></tbody>\n",
    "            </table>\n",
    "    </div>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid black\" />\n",
    "<h1><a id=\"c5\">Chapter 5: Summary</a></h1>\n",
    "<div style=\"padding:5% 5% 5% 5%\">\n",
    "    <img src=\"https://github.com/pzindel/lantern-prep-course/blob/main/images/2.1_levels_of_design.svg?raw=true\" width=\"100%\">\n",
    "    <p>There are many levels that factor into the design of computers and the data that they operate on. As the level increases so does the abstraction which allows uses to treat the lower levels as a black block and primarily focus on their domain. However, when designing applications and working with data it can be quite helpful at times to have an understanding of the underlying designs.</p>\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}