notebooks/quality_attributes_in_sw.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Modifiability\n"
      ],
      "metadata": {
        "id": "SrPMMom7dDws"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Readibility"
      ],
      "metadata": {
        "id": "ZuwduqBYdvSY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import this"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SZC6JC4GhEvM",
        "outputId": "0a249b2e-7a29-4b30-8b02-53c90174102e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The Zen of Python, by Tim Peters\n",
            "\n",
            "Beautiful is better than ugly.\n",
            "Explicit is better than implicit.\n",
            "Simple is better than complex.\n",
            "Complex is better than complicated.\n",
            "Flat is better than nested.\n",
            "Sparse is better than dense.\n",
            "Readability counts.\n",
            "Special cases aren't special enough to break the rules.\n",
            "Although practicality beats purity.\n",
            "Errors should never pass silently.\n",
            "Unless explicitly silenced.\n",
            "In the face of ambiguity, refuse the temptation to guess.\n",
            "There should be one-- and preferably only one --obvious way to do it.\n",
            "Although that way may not be obvious at first unless you're Dutch.\n",
            "Now is better than never.\n",
            "Although never is often better than *right* now.\n",
            "If the implementation is hard to explain, it's a bad idea.\n",
            "If the implementation is easy to explain, it may be a good idea.\n",
            "Namespaces are one honking great idea -- let's do more of those!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**The Zen of Python**\n",
        "\n",
        "* There should be one—and preferably only one—obvious way to do it.\n"
      ],
      "metadata": {
        "id": "qi6ppbPSg414"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FaU-Kiccc50U",
        "outputId": "d9e03797-3f5f-46e8-8366-e1d038feff38"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 => Mario\n",
            "1 => Oscar\n",
            "2 => Emiliano\n"
          ]
        }
      ],
      "source": [
        "seq = ['Mario', 'Oscar', 'Emiliano']\n",
        "\n",
        "for idx in range(len(seq)):\n",
        "  item = seq[idx]\n",
        "  print(idx, '=>', item)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for idx,item in enumerate(seq):\n",
        "  print(idx, '=>', item)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YphLJLR8h3zn",
        "outputId": "afa7094b-5147-41fc-b5fc-9f1526449826"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 => Mario\n",
            "1 => Oscar\n",
            "2 => Emiliano\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Readability – antipatterns"
      ],
      "metadata": {
        "id": "tu5beCwodtU9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Spaghetti code\n",
        "* Copy-Paste programming\n",
        "* Mixed indentation\n",
        "* Mixing string literal types\n",
        "* Overuse of functional constructs"
      ],
      "metadata": {
        "id": "LCfOMCakip98"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Example of functional paradigm\n",
        "\n",
        "list(filter( lambda x: x[0] == \"O\",seq))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9S4BpUWaihrV",
        "outputId": "6ef7a967-def7-4af4-b1c3-0903b75bdece"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Oscar']"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Documentation improve Readability"
      ],
      "metadata": {
        "id": "PCqD5b0H8zQJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Inline documentation\n",
        "* External documentation\n",
        "* User manuals"
      ],
      "metadata": {
        "id": "OQkLiZRS9G45"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Inline Docs"
      ],
      "metadata": {
        "id": "eXOSILW19WKt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Code comments"
      ],
      "metadata": {
        "id": "VhpLGkiU9fhZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize your variables\n",
        "\n",
        "x, alpha = 0, .3"
      ],
      "metadata": {
        "id": "cs3OQ5C85RTl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Class and function Docstring"
      ],
      "metadata": {
        "id": "JiHV8qoa-Q8u"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "class GenericProcedures(object):\n",
        "  \"\"\" Implements generic procedures for the API.\n",
        "                Main methods:\n",
        "                fetch - Fetches the URL.\n",
        "                createDirectory - create directory.\n",
        "  \"\"\"\n",
        "\n",
        "  @staticmethod\n",
        "  def createDirectory( dir: list = '',\n",
        "                        base: str = ''\n",
        "                      ) -> None:\n",
        "\n",
        "      \"\"\"\n",
        "      create a directory\n",
        "      @params:\n",
        "          base ([mixed]): str or list base path\n",
        "          dir ([mixed]): str or list path to create in base path\n",
        "      @returns:\n",
        "          [None]: None\n",
        "      \"\"\"\n",
        "      #construct path and clean it\n",
        "      base = '.'\n",
        "      dir = dir\n",
        "      try:\n",
        "          os.makedirs(base + dir)\n",
        "      except FileExistsError:\n",
        "          # directory already exists\n",
        "          pass\n",
        "      #bye\n",
        "      return base + dir + '/'"
      ],
      "metadata": {
        "id": "GgpHMDqM-YsL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Measuring cohesion and coupling"
      ],
      "metadata": {
        "id": "EkRou17oGrLw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\" Module A (a.py) – Provides functions that operate on series of\n",
        "   numbers\n",
        "\"\"\"\n",
        "def squares(narray):\n",
        "    \"\"\" Return array of squares of numbers \"\"\"\n",
        "    return pow_n(narray, 2)\n",
        "def cubes(narray):\n",
        "    \"\"\" Return array of cubes of numbers \"\"\"\n",
        "    return pow_n(narray, 3)\n",
        "def pow_n(narray, n):\n",
        "    \"\"\" Return array of numbers raised to arbitrary power n each \"\"\"\n",
        "    return [pow(x, n) for x in narray]\n",
        "def frequency(string, word):\n",
        "    \"\"\" Find the frequency of occurrences of word in string\n",
        "    as percentage \"\"\"\n",
        "    word_l = word.lower()\n",
        "    string_l = string.lower()\n",
        "    # Words in string\n",
        "    words = string_l.split()\n",
        "    count = w.count(word_l)\n",
        "    # Return frequency as percentage\n",
        "    return 100.0*count/len(words)"
      ],
      "metadata": {
        "id": "-FYGRhSKBCok"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\" Module B (b.py) – Provides functions implementing some statistical\n",
        "   methods \"\"\"\n",
        "import a\n",
        "\n",
        "def rms(narray):\n",
        "    \"\"\" Return root mean square of array of numbers\"\"\"\n",
        "    return pow(sum(a.squares(narray)), 0.5)\n",
        "def mean(array):\n",
        "    \"\"\" Return mean of an array of numbers \"\"\"\n",
        "    return 1.0*sum(array)/len(array)\n",
        "def variance(array):\n",
        "    \"\"\" Return variance of an array of numbers \"\"\"\n",
        "    # Square of variation from mean\n",
        "    avg = mean(array)\n",
        "    array_d = [(x – avg) for x in array]\n",
        "    variance = sum(a.squares(array_d))\n",
        "    return variance\n",
        "def standard_deviation(array):\n",
        "    \"\"\" Return standard deviation of an array of numbers \"\"\"\n",
        "    # S.D is square root of variance\n",
        "    return pow(variance(array), 0.5)\n"
      ],
      "metadata": {
        "id": "yuXCYVtFG4la"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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\n",
        ")"
      ],
      "metadata": {
        "id": "597hylxLHKYa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* **Abstract common services for other modules, dependent code is all available in one place without duplication**\n"
      ],
      "metadata": {
        "id": "LHqY1-NEJbXQ"
      }
    }
  ]
}