Interpreter_Vs_Compiler.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Introduction** lecture series by **[Dr. Milaan Parmar](https://www.linkedin.com/in/milaanparmar/)** are available @ **[GitHub](https://github.com/milaan9/01_Python_Introduction)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Interpreter Vs Compiler : Differences Between Interpreter and Compiler\n",
    "\n",
    "In this class, you will learn the differences between interpreters and compilers.\n",
    "\n",
    "We generally write a computer program using a high-level language. A high-level language is one that is understandable by us, humans. This is called **source code**.\n",
    "\n",
    "However, a computer does not understand high-level language. It only understands the program written in **0**'s and **1**'s in binary, called the **machine code**.\n",
    "\n",
    "To convert source code into machine code, we use either a **compiler** or an **interpreter**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Interpreter?\n",
    "\n",
    "An interpreter is a computer program, which coverts each high-level program statement into the machine code. This includes source code, pre-compiled code, and scripts. Both compiler and interpreters do the same job which is converting higher level programming language to machine code. However, a compiler will convert the code into machine code (create an exe) before program run. Interpreters convert code into machine code when the program is run.\n",
    "\n",
    "\n",
    "## What is Compiler?\n",
    "\n",
    "A compiler is a computer program that transforms code written in a high-level programming language into the machine code. It is a program which translates the human-readable code to a language a computer processor understands (binary 1 and 0 bits). The computer processes the machine code to perform the corresponding tasks.\n",
    "\n",
    "A compiler should comply with the syntax rule of that programming language in which it is written. However, the compiler is only a program and cannot fix errors found in that program. So, if you make a mistake, you need to make changes in the syntax of your program. Otherwise, it will not compile.\n",
    "\n",
    "\n",
    "## Programming Steps Comparision:\n",
    "\n",
    "| # | Interpreter | Compiler |\n",
    "|:----:|:----|:-------|\n",
    "|**1.**|Create the Program.|Create the program.|\n",
    "|**2.**|No linking of files or machine code generation.|Compile will parse or analyses all of the language statements for its correctness. If incorrect, throws an error.|\n",
    "|**3.**|Source statements executed line by line DURING Execution.|If no error, the compiler will convert source code to machine code.|\n",
    "|**4.**|-|It links different code files into a runnable program(know as exe).|\n",
    "|**5.**|-|Run the Program|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both compilers and interpreters are used to convert a program written in a high-level language into machine code understood by computers. However, there are differences between how an interpreter and a compiler works.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/IvsC.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interpreter Vs Compiler\n",
    "\n",
    "| Parameters | Interpreter | Compiler |\n",
    "|:-----|:----|:-------|\n",
    "|**Advantage**|Interpreters are easier to use, especially for beginners.|The program code is already translated into machine code. Thus, it code execution time is less.|\n",
    "|**Disadvantage**|Interpreted programs can run on computers that have the corresponding interpreter.|You can't change the program without going back to the source code.|\n",
    "|**Machine code**|Not saving machine code at all.|Store machine language as machine code on the disk.|\n",
    "|**Running time**|Interpreters usually take less amount of time to analyze the source code. However, the overall execution time is comparatively slower than compilers.|Compilers usually take a large amount of time to analyze the source code. However, the overall execution time is comparatively faster than interpreters.|\n",
    "|**Model**|It is based on interpretation method.|It is based on language translation linking-loading model.|\n",
    "|**Program generation**|Do not generate output program. So they evaluate the source program at every time during execution.|Generates output program (in the form of .exe) which can be run independently from the original program.|\n",
    "|**Execution**|It does not convert source code into machine code instead it scans it line by line.|It converts the source code into machine code.|\n",
    "|**Memory requirement**|No Object Code is generated, hence are memory efficient.|Generates Object Code which further requires linking, hence requires more memory.|\n",
    "|**Best suited for**|For web environments, where load times are important. Due to all the exhaustive analysis is done, compiles take relatively larger time to compile even small code that may not be run multiple times. In such cases, interpreters are better.|Bounded to the specific target machine and cannot be ported. C and C++ are a most popular a programming language which uses compilation model.|\n",
    "|**Code Optimization**|Interpreters see code line by line, and thus optimizations are not as robust as compilers.|The compiler sees the entire code upfront. Hence, they perform lots of optimizations that make code run faster.|\n",
    "|**Dynamic Typing**|Interpreted languages support Dynamic Typing|Difficult to implement as compilers cannot predict what happens at turn time.|\n",
    "|**Usage**|It is best suited for the program and development environment.|It is best suited for the production environment.|\n",
    "|**Error execution**|The interpreter reads a single statement and shows the error if any. You must correct the error to interpret next line.|Compiler displays all errors and warning at the compilation time. Therefore, you can't run the program without fixing errors.|\n",
    "|**Input**|It takes a single line of code.|It takes an entire program.|\n",
    "|**Output**|Interpreter never generate any intermediate machine code.|Compliers generates intermediate machine code.|\n",
    "|**Errors**|Considering it scans code one line at a time, errors are shown line by line.|As it scans the code in one go, the errors (if any) are shown at the end together.|\n",
    "|**Programming languages**| JavaScript, MATLAB, Python, Ruby, PHP, Pearl use interpreters. | C, C++, C#, Java use compilers.|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### HIGH-LEVEL LANGUAGES\n",
    "High-level languages, like C, C++, JAVA, etc., are very near to English. It makes programming process easy. However, it must be translated into machine language before execution. This translation process is either conducted by either a compiler or an interpreter. Also known as source code.\n",
    "\n",
    "### MACHINE CODE\n",
    "Machine languages are very close to the hardware. Every computer has its machine language. A machine language programs are made up of series of binary pattern. (eg. 110110) It represents the simple operations which should be performed by the computer. Machine language programs are executable so that they can be run directly.\n",
    "\n",
    "### OBJECT CODE\n",
    "On compilation of source code, the machine code generated for different processors like Intel, AMD, an ARM is different. To make code portable, the source code is first converted to Object Code. It is an intermediary code (similar to machine code) that no processor will understand. At run time, the object code is converted to the machine code of the underlying platform.\n",
    "\n",
    "### Java is both Compiled and Interpreted.\n",
    "To exploit relative advantages of compilers are interpreters some programming language like Java are both compiled and interpreted. The Java code itself is compiled into Object Code. At run time, the JVM interprets the Object code into machine code of the target computer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## KEY DIFFERENCE\n",
    "\n",
    "* Compiler transforms code written in a high-level programming language into the object code, at once, before program runs, whereas an Interpreter coverts each high-level program statement, one by one, into the object code, during program run.\n",
    "* Compiled code runs faster while interpreted code runs slower.\n",
    "* Compiler displays all errors after compilation, on the other hand, the Interpreter displays errors of each line one by one.\n",
    "* Compiler is based on translation linking-loading model, whereas Interpreter is based on interpretation method.\n",
    "* Compiler takes an entire program whereas the Interpreter takes a single line of code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## KEY SIMILARITIES\n",
    "\n",
    "* Both Compiler and Interpreter translate source code for machine understanding so that your device can follow your command.\n",
    "* The Compiler and the Interpreter use memory to store data.\n",
    "* Interpreter and Compiler are the high-level languages.\n",
    "* Java language uses both the Compiler and the Interpreter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Authors ✍️\n",
    "\n",
    "I'm Dr. Milaan Parmar and I have written this tutorial. If you think you can add/correct/edit and enhance this tutorial you are most welcome🙏\n",
    "\n",
    "See **[github's contributors page](https://github.com/milaan9/01_Python_Introduction/graphs/contributors)** for details.\n",
    "\n",
    "If you have trouble with this tutorial please tell me about it by **[Create an issue on GitHub](https://github.com/milaan9/01_Python_Introduction/issues/new)**. and I'll make this tutorial better. This is probably the best choice if you had trouble following the tutorial, and something in it should be explained better. You will be asked to create a GitHub account if you don't already have one.\n",
    "\n",
    "If you like this tutorial, please **[give it a ⭐ star](https://github.com/milaan9/01_Python_Introduction/blob/main/README.md#how-can-i-thank-you-for-writing-and-sharing-this-tutorial)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Licence 📜\n",
    "\n",
    "You may use this tutorial freely at your own risk. See **[LICENSE](https://github.com/milaan9/01_Python_Introduction/blob/main/LICENSE)**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "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": 2
}