reproduce_study.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "import pandas as pd\n",
    "import math\n",
    "df = pd.read_csv(\"csi_failure_dataset_open_source_systems.csv\")\n",
    "df = df.fillna('')\n",
    "df_cloud_incidents = pd.read_csv(\"cloud_incidents_gcp_aws_azure.csv\")\n",
    "df_cloud_incidents = df_cloud_incidents.fillna('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 3:: Finding 1: Among 55 cloud incidents, 11 (20%) were caused by CSI failures, showing their catastrophic consequences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total cloud incidents: 55, number of incidents caused by CSI failures: 11 (20.0%)\n"
     ]
    }
   ],
   "source": [
    "cloud_incidents = list(df_cloud_incidents['Issue Link'])\n",
    "cloud_failure_types = list(df_cloud_incidents['Failure Type'])\n",
    "csi_failures = [failure_type for incident, failure_type in list(zip(cloud_incidents, cloud_failure_types)) if failure_type == \"CSI\"]\n",
    "total_incidents = len(cloud_incidents)\n",
    "print(\"Total cloud incidents: %s, number of incidents \"\\\n",
    "      \"caused by CSI failures: %s (%s%%)\" % (total_incidents, len(csi_failures), \n",
    "                                             len(csi_failures)/total_incidents * 100))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 4:: Table 1: Target systems and the number of corresponding CSI failures studied in this paper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Upstream</th>\n",
       "      <th>Downstream</th>\n",
       "      <th># CSI Failures</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Spark</td>\n",
       "      <td>Hive</td>\n",
       "      <td>26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Spark</td>\n",
       "      <td>YARN</td>\n",
       "      <td>19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Spark</td>\n",
       "      <td>HDFS</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Spark</td>\n",
       "      <td>Kafka</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Flink</td>\n",
       "      <td>Kafka</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Flink</td>\n",
       "      <td>YARN</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Flink</td>\n",
       "      <td>Hive</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Flink</td>\n",
       "      <td>HDFS</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Hive</td>\n",
       "      <td>Spark</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Hive</td>\n",
       "      <td>HBase</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Hive</td>\n",
       "      <td>HDFS</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>Hive</td>\n",
       "      <td>Kafka</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>Hive</td>\n",
       "      <td>YARN</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>HBase</td>\n",
       "      <td>HDFS</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>YARN</td>\n",
       "      <td>HDFS</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>Total</td>\n",
       "      <td></td>\n",
       "      <td>120</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Upstream Downstream # CSI Failures\n",
       "0     Spark       Hive             26\n",
       "1     Spark       YARN             19\n",
       "2     Spark       HDFS              8\n",
       "3     Spark      Kafka              5\n",
       "4     Flink      Kafka             12\n",
       "5     Flink       YARN             14\n",
       "6     Flink       Hive              8\n",
       "7     Flink       HDFS              3\n",
       "8      Hive      Spark              6\n",
       "9      Hive      HBase              3\n",
       "10     Hive       HDFS              6\n",
       "11     Hive      Kafka              1\n",
       "12     Hive       YARN              2\n",
       "13    HBase       HDFS              4\n",
       "14     YARN       HDFS              3\n",
       "15    Total                       120"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "upstream_systems = list(df['Upstream System'])\n",
    "downstream_systems = list(df['Downstream System'])\n",
    "total_issues = len(upstream_systems)\n",
    "dic = defaultdict(int)\n",
    "for systems in list(zip(upstream_systems, downstream_systems)):\n",
    "    dic[systems[0] + \"_\" + systems[1]] += 1\n",
    "system_order = [[\"Spark\", \"Hive\"], [\"Spark\", \"YARN\"], [\"Spark\", \"HDFS\"], [\"Spark\", \"Kafka\"],\n",
    "                [\"Flink\", \"Kafka\"], [\"Flink\", \"YARN\"], [\"Flink\", \"Hive\"], [\"Flink\", \"HDFS\"],\n",
    "               [\"Hive\", \"Spark\"], [\"Hive\", \"HBase\"], [\"Hive\", \"HDFS\"], [\"Hive\", \"Kafka\"], [\"Hive\", \"YARN\"],\n",
    "               [\"HBase\", \"HDFS\"], [\"YARN\", \"HDFS\"]]\n",
    "upstream_sys_col = list()\n",
    "downstream_sys_col = list()\n",
    "freq_col = list()\n",
    "for systems in system_order:\n",
    "    upstream_sys_col.append(systems[0])\n",
    "    downstream_sys_col.append(systems[1])\n",
    "    freq_col.append(dic[systems[0] + \"_\" + systems[1]])\n",
    "table1 = pd.DataFrame([upstream_sys_col + [\"Total\"], downstream_sys_col + [\"\"], freq_col + [total_issues]]).transpose()\n",
    "table1.columns = ['Upstream', 'Downstream','# CSI Failures']\n",
    "table1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Section 5:: Table 2: Categorization by failure planes\n",
    "### Section 5:: Finding 2: Data- and management-plane interactions contribute to significant percentages of CSI failures: 51% of CSI failures in our dataset manifest at the data plane, and 32% of CSI failures manifest at the management plane. Control-plane interactions contribute to 17%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Plane</th>\n",
       "      <th># Failures</th>\n",
       "      <th>Percentage</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Control</td>\n",
       "      <td>20</td>\n",
       "      <td>16.67%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Data</td>\n",
       "      <td>61</td>\n",
       "      <td>50.83%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Management</td>\n",
       "      <td>39</td>\n",
       "      <td>32.5%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Total</td>\n",
       "      <td>120</td>\n",
       "      <td>100%</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        Plane # Failures Percentage\n",
       "0     Control         20     16.67%\n",
       "1        Data         61     50.83%\n",
       "2  Management         39      32.5%\n",
       "3       Total        120       100%"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "issues =  list(df['Failure Plane'])\n",
    "total_issues = len(issues)\n",
    "count = pd.Series(issues).value_counts()\n",
    "planes = [\"Control\", \"Data\", \"Management\"]\n",
    "vals = [count[plane] for plane in planes]\n",
    "percentages = [str(round(count[plane]/total_issues * 100, 2)) + \"%\" for plane in planes]\n",
    "table2 = pd.DataFrame([planes + [\"Total\"], vals + [total_issues], percentages + [\"100%\"]]).transpose()\n",
    "table2.columns = ['Plane', '# Failures','Percentage']\n",
    "table2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 5:: Finding 3: Most (89/120) CSI failures are manifested through crashing behavior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of CSI failures that manifest through crashing behaviour: 89/120\n"
     ]
    }
   ],
   "source": [
    "planes =  list(df['Failure Plane'])\n",
    "consequences = list(df['Failure Consequence'])\n",
    "plane_to_consequences = defaultdict(lambda: defaultdict(int))\n",
    "crashing_consequences = [\"Runtime crash/hang\", \"Startup failure\", \"Job/task failure\", \"Job/task startup failure\", \"Job/task crash/hang\"]\n",
    "num_crashing_consequences = 0\n",
    "for plane, consequence in list(zip(planes, consequences)):\n",
    "    plane_to_consequences[plane][consequence.strip()] += 1\n",
    "    if consequence in crashing_consequences:\n",
    "        num_crashing_consequences += 1\n",
    "print(\"Number of CSI failures that manifest through crashing behaviour: %s/%s\" % (num_crashing_consequences, total_issues))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 5:: Table 3: Failure symptoms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Impact</th>\n",
       "      <th>#</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Runtime crash/hang</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Startup failure</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Performance issue</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Data loss</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Unexpected Behaviour</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 Impact  #\n",
       "0    Runtime crash/hang  8\n",
       "1       Startup failure  4\n",
       "2     Performance issue  3\n",
       "3             Data loss  2\n",
       "4  Unexpected Behaviour  3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "control_plane_rows = [\"Runtime crash/hang\", \"Startup failure\", \"Performance issue\", \"Data loss\", \"Unexpected Behaviour\"]\n",
    "freq = list()\n",
    "for consequence in control_plane_rows:\n",
    "    freq.append(plane_to_consequences[\"Control\"][consequence])\n",
    "control_plane_table = pd.DataFrame([control_plane_rows, freq]).transpose()\n",
    "control_plane_table.columns = ['Impact','#']\n",
    "control_plane_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Impact</th>\n",
       "      <th>#</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Job/task failure</td>\n",
       "      <td>47</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Job/task startup failure</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Wrong results</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Performance issues</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Resource leak</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Usability</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Impact   #\n",
       "0          Job/task failure  47\n",
       "1  Job/task startup failure   6\n",
       "2             Wrong results   3\n",
       "3        Performance issues   2\n",
       "4             Resource leak   2\n",
       "5                 Usability   1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_plane_rows = [\"Job/task failure\", \"Job/task startup failure\", \"Wrong results\", \"Performance issues\", \"Resource leak\", \"Usability\"]\n",
    "freq = list()\n",
    "for consequence in data_plane_rows:\n",
    "    freq.append(plane_to_consequences[\"Data\"][consequence])\n",
    "data_plane_table = pd.DataFrame([data_plane_rows, freq]).transpose()\n",
    "data_plane_table.columns = ['Impact','#']\n",
    "data_plane_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Impact</th>\n",
       "      <th>#</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Job/task crash/hang</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Reduced observability</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Unexpected Behaviour</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Performance issue</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  Impact   #\n",
       "0    Job/task crash/hang  24\n",
       "1  Reduced observability   8\n",
       "2   Unexpected Behaviour   5\n",
       "3      Performance issue   2"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "management_plane_rows = [\"Job/task crash/hang\",\"Reduced observability\", \"Unexpected Behaviour\", \"Performance issue\"]\n",
    "freq = list()\n",
    "for consequence in management_plane_rows:\n",
    "    freq.append(plane_to_consequences[\"Management\"][consequence])\n",
    "management_plane_table = pd.DataFrame([management_plane_rows, freq]).transpose()\n",
    "management_plane_table.columns = ['Impact','#']\n",
    "\n",
    "management_plane_table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 6:: Table 4: Data properties in which discrepancies of data-plane CSI failures are rooted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Data Property</th>\n",
       "      <th>#</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Address</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Schema: Structure</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Schema: Value</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Custom Property</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>API semantics</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Total</td>\n",
       "      <td>61</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       Data Property   #\n",
       "0            Address  10\n",
       "1  Schema: Structure  14\n",
       "2      Schema: Value  18\n",
       "3    Custom Property   8\n",
       "4      API semantics  11\n",
       "5              Total  61"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_plane_abstraction = list(df['Data Plane: Abstraction'])\n",
    "data_plane_properties = list(df['Data Plane: Properties'])\n",
    "total_data_plane = 0\n",
    "property_to_count = defaultdict(int)\n",
    "for prop in data_plane_properties:\n",
    "    if prop:\n",
    "        total_data_plane += 1\n",
    "        property_to_count[prop] += 1\n",
    "\n",
    "property_rows = [\"Address\", \"Schema: Structure\", \"Schema: Value\", \"Custom Property\", \"API semantics\"]\n",
    "freq = list()\n",
    "for prop in property_rows:\n",
    "    freq.append(property_to_count[prop])\n",
    "property_rows.append(\"Total\")\n",
    "freq.append(total_data_plane)\n",
    "table4 = pd.DataFrame([property_rows, freq]).transpose()\n",
    "table4.columns = ['Data Property', '#']\n",
    "table4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 6:: Finding 4: Discrepancies of data-plane CSI failures lie in many different data properties. The majority (50/61) of dataplane CSI failures are caused by metadata, namely typical metadata (42/61) such as addresses/names and data schemas, and custom metadata (8/61). The others (11/61) are caused by custom properties and API semantics. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data-Plane CSI failures caused by typical metadata: 42/61\n",
      "Data-Plane CSI failures caused by custom metadata: 8/61\n",
      "Data-Plane CSI failures caused by metadata (typical metadata & custom metadata): 50/61\n",
      "Data-Plane CSI failures caused by custom properties & API semantics: 11/61\n"
     ]
    }
   ],
   "source": [
    "typical_metadata_props = [\"Address\", \"Schema: Structure\", \"Schema: Value\"]\n",
    "custom_metadata_prop = \"Custom Property\"\n",
    "api_semantics_prop = \"API semantics\"\n",
    "custom_metadata_total = property_to_count[custom_metadata_prop]\n",
    "api_semantics_total = property_to_count[api_semantics_prop]\n",
    "typical_metadata_total = 0\n",
    "for prop in typical_metadata_props:\n",
    "    typical_metadata_total += property_to_count[prop]\n",
    "print(\"Data-Plane CSI failures caused by typical metadata: %s/%s\" % (typical_metadata_total, total_data_plane))\n",
    "print(\"Data-Plane CSI failures caused by custom metadata: %s/%s\" % (custom_metadata_total, total_data_plane))\n",
    "print(\"Data-Plane CSI failures caused by metadata (typical metadata & custom metadata): %s/%s\" % (str(typical_metadata_total + custom_metadata_total), total_data_plane))\n",
    "print(\"Data-Plane CSI failures caused by custom properties & API semantics: %s/%s\" % (api_semantics_total, total_data_plane))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 6:: Table 5: Data abstractions in which discrepancies of data-plane CSI failures are rooted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Data Abstraction</th>\n",
       "      <th>Address</th>\n",
       "      <th>Schema: Structure</th>\n",
       "      <th>Schema: Value</th>\n",
       "      <th>Custom Property</th>\n",
       "      <th>API semantics</th>\n",
       "      <th>Total</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Table</td>\n",
       "      <td>1</td>\n",
       "      <td>13</td>\n",
       "      <td>16</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>File</td>\n",
       "      <td>8</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>8</td>\n",
       "      <td>2</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Stream</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>KV Tuple</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Total</td>\n",
       "      <td>10</td>\n",
       "      <td>14</td>\n",
       "      <td>18</td>\n",
       "      <td>8</td>\n",
       "      <td>11</td>\n",
       "      <td>61</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Data Abstraction Address Schema: Structure Schema: Value Custom Property  \\\n",
       "0            Table       1                13            16               0   \n",
       "1             File       8                 0             0               8   \n",
       "2           Stream       1                 1             2               0   \n",
       "3         KV Tuple       0                 0             0               0   \n",
       "4            Total      10                14            18               8   \n",
       "\n",
       "  API semantics Total  \n",
       "0             5    35  \n",
       "1             2    18  \n",
       "2             4     8  \n",
       "3             0     0  \n",
       "4            11    61  "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "property_rows = [\"Address\", \"Schema: Structure\", \"Schema: Value\", \"Custom Property\", \"API semantics\"]\n",
    "abstraction_to_properties = defaultdict(lambda: defaultdict(int))\n",
    "abstraction_to_count = defaultdict(int)\n",
    "for abstraction, prop in list(zip(data_plane_abstraction, data_plane_properties)):\n",
    "    abstraction_to_properties[abstraction][prop] += 1\n",
    "    abstraction_to_count[abstraction] += 1\n",
    "\n",
    "abstractions = [\"Table\", \"File\", \"Stream\", \"KV Tuple\"]\n",
    "cols = list()\n",
    "cols.append(abstractions)\n",
    "for _prop in property_rows:\n",
    "    col = list()\n",
    "    total = 0\n",
    "    for abstraction in abstractions:\n",
    "        _freq = abstraction_to_properties.get(abstraction, {}).get(_prop, 0)\n",
    "        col.append(_freq)\n",
    "        total += _freq\n",
    "    col.append(total)\n",
    "    cols.append(col)\n",
    "totals_col = list()\n",
    "for abstraction in abstractions:\n",
    "    totals_col.append(abstraction_to_count[abstraction])\n",
    "totals_col.append(total_data_plane)\n",
    "cols.append(totals_col)\n",
    "property_rows.insert(0, \"Data Abstraction\")\n",
    "property_rows.append(\"Total\")\n",
    "cols[0].append(\"Total\")\n",
    "table5 = pd.DataFrame(cols).transpose()\n",
    "table5.columns = property_rows\n",
    "table5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "planes =  list(df['Failure Plane'])\n",
    "discrepancies = list(df['Discrepancy pattern type'])\n",
    "discrepancy_to_count = defaultdict(lambda: defaultdict(int))\n",
    "for plane, discrepancy in list(zip(planes, discrepancies)):\n",
    "    discrepancy_to_count[plane][discrepancy] += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 6:: Finding 5: Complicated data abstractions (e.g., tables) are more error-prone to CSI failures, compared with simple data abstractions Finding 5: 57% (35/61) of data-plane CSI failures are induced by table-related operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data-Plane CSI failures caused by table-related operations: 35/61\n"
     ]
    }
   ],
   "source": [
    "table_related_issues = abstraction_to_count[\"Table\"]\n",
    "print(\"Data-Plane CSI failures caused by table-related operations: %s/%s\" % (table_related_issues, total_data_plane))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 6:: Finding 6: 25% (15/61) data-plane CSI failures are root-caused by data serialization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data-Plane CSI failures caused by data serialization: 24.59% (15/61)\n"
     ]
    }
   ],
   "source": [
    "data_serde =  list(df['Data Plane: Involves Data Serialization'])\n",
    "involves_data_serde_count = 0\n",
    "for involves_data_serde in data_serde:\n",
    "    if involves_data_serde == \"Yes\":\n",
    "        involves_data_serde_count += 1\n",
    "involves_data_serde_percentage = round(involves_data_serde_count/total_data_plane * 100, 2)\n",
    "print(\"Data-Plane CSI failures caused by \" \\\n",
    "      \"data serialization: %s%% (%s/%s)\" % (involves_data_serde_percentage, \n",
    "                                            involves_data_serde_count, total_data_plane))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 6:: Table 6: Data-Plane Discrepancy patterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Discrepancy Pattern</th>\n",
       "      <th>#</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Type Confusion</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Unsupported Operations</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Unspoken Convention</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Undefined Values</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Wrong API Assumptions</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Total</td>\n",
       "      <td>61</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Discrepancy Pattern   #\n",
       "0          Type Confusion  12\n",
       "1  Unsupported Operations  15\n",
       "2     Unspoken Convention   9\n",
       "3        Undefined Values   7\n",
       "4   Wrong API Assumptions  18\n",
       "5                   Total  61"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_plane_discrepancy_rows = [\"Type Confusion\", \"Unsupported Operations\",\"Unspoken Convention\", \"Undefined Values\", \"Wrong API Assumptions\"]\n",
    "freq = list()\n",
    "total_freq = 0\n",
    "for discrepancy in data_plane_discrepancy_rows:\n",
    "    _freq = discrepancy_to_count[\"Data\"][discrepancy]\n",
    "    freq.append(_freq)\n",
    "    total_freq += _freq\n",
    "table6 = pd.DataFrame([data_plane_discrepancy_rows + [\"Total\"], freq + [total_freq]]).transpose()\n",
    "table6.columns = ['Discrepancy Pattern','#']\n",
    "table6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Section 6:: Table 7: Management-Plane Discrepancy patterns\n",
    "### Section 6:: Finding 7: CSI-failure-inducing configuration issues are very different from traditional configuration issues of individual systems. The former is mostly about failures of coherently configuring multiple involved systems, while the latter is mainly on correctness checking of erroneous configuration values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Discrepancy Pattern</th>\n",
       "      <th>#</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Ignorance</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Unexpected Override</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Inconsistent Context</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Mishandling Configuration Value</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Total</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               Discrepancy Pattern   #\n",
       "0                        Ignorance  12\n",
       "1              Unexpected Override   6\n",
       "2             Inconsistent Context  10\n",
       "3  Mishandling Configuration Value   2\n",
       "4                            Total  30"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "management_plane_discrepancy_rows = [\"Ignorance\", \"Unexpected Override\", \"Inconsistent Context\", \"Mishandling Configuration Value\"]\n",
    "freq = list()\n",
    "total_freq = 0\n",
    "for discrepancy in management_plane_discrepancy_rows:\n",
    "    _freq = discrepancy_to_count[\"Management\"][discrepancy]\n",
    "    total_freq += _freq\n",
    "    freq.append(_freq)\n",
    "table8 = pd.DataFrame([management_plane_discrepancy_rows + [\"Total\"], freq + [total_freq]]).transpose()\n",
    "table8.columns = ['Discrepancy Pattern','#']\n",
    "table8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 6:: Finding 8: Parameter-related configuration issues are the majority (21/30) of configuration-induced CSI failures. The rest (9/30) are in configuration components of the involved systems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Configuration-induced CSI failures caused by parameter misconfig: 21/30\n",
      "Configuration-induced CSI failures caused by component misconfig: 9/30\n"
     ]
    }
   ],
   "source": [
    "configuration_categorizations = list(df[\"Management Plane: Configuration Parameter or Component\"])\n",
    "parameter = 0\n",
    "component = 0\n",
    "total_configuration_plane = 0\n",
    "for category in configuration_categorizations:\n",
    "    if category == \"Component\":\n",
    "        component += 1\n",
    "    elif category == \"Parameter\":\n",
    "        parameter += 1     \n",
    "total_config_plane = component + parameter\n",
    "print(\"Configuration-induced CSI failures caused by parameter misconfig: %s/%s\" % (parameter, total_config_plane))\n",
    "print(\"Configuration-induced CSI failures caused by component misconfig: %s/%s\" % (component, total_config_plane))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 6:: Table 8: Control-Plane Discrepancy patterns\n",
    "### Section 6:: Finding 10: Most control-plane CSI failures are rooted in discrepancies of implicit properties, including implicit API semantics and state/resource inconsistencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Discrepancy Pattern</th>\n",
       "      <th>#</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>API Semantics Violation</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>State/Resource Inconsistency</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Feature inconsistency</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Total</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Discrepancy Pattern   #\n",
       "0       API Semantics Violation  13\n",
       "1  State/Resource Inconsistency   5\n",
       "2         Feature inconsistency   2\n",
       "3                         Total  20"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "control_plane_discrepancy_rows = [\"API Semantics Violation\", \"State/Resource Inconsistency\", \"Feature inconsistency\"]\n",
    "freq = list()\n",
    "total_control_plane_freq = 0\n",
    "for discrepancy in control_plane_discrepancy_rows:\n",
    "    _freq = discrepancy_to_count[\"Control\"][discrepancy]\n",
    "    freq.append(_freq)\n",
    "    total_control_plane_freq += _freq\n",
    "table7 = pd.DataFrame([control_plane_discrepancy_rows + [\"Total\"], freq + [total_control_plane_freq]]).transpose()\n",
    "table7.columns = ['Discrepancy Pattern','#']\n",
    "table7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 6:: Finding 11: API misuses, despite being a classic problem, are still common defects and contribute to the majority (13/20) of control-plane CSI failures. The main patterns are implicit semantic violation (8/13) and incorrect invocation context (5/13)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "API-misuse issues in the control plane: 13/20\n",
      "API-misuse issues in the control plane caused by implicit semantic violation: 8/13\n",
      "API-misuse issues in the control plane caused by incorrect invocation context : 5/13\n"
     ]
    }
   ],
   "source": [
    "control_plane_misc_discrepancy_properties = list(df[\"Control Plane: Misc. Dicrepancy Properties\"])\n",
    "semantic_violation = 0\n",
    "incorrect_invocation = 0\n",
    "api_misuse = discrepancy_to_count[\"Control\"][\"API Semantics Violation\"]\n",
    "for prop in control_plane_misc_discrepancy_properties:\n",
    "    if prop.strip() == \"Implicit semantic violation\":\n",
    "        semantic_violation += 1\n",
    "    elif prop.strip() == \"Incorrect invocation context\":\n",
    "        incorrect_invocation += 1  \n",
    "print(\"API-misuse issues in the control plane: %s/%s\" % (api_misuse, total_control_plane_freq))\n",
    "print(\"API-misuse issues in the control plane caused by implicit semantic violation: %s/%s\" % (semantic_violation, api_misuse))\n",
    "print(\"API-misuse issues in the control plane caused by incorrect invocation context : %s/%s\" % (incorrect_invocation, api_misuse))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 7:: Table 9: Fix patterns of the evaluated CSI failures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Fix Pattern</th>\n",
       "      <th>#</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Checking</td>\n",
       "      <td>38</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Error handling</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Interaction</td>\n",
       "      <td>69</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Others</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Total</td>\n",
       "      <td>120</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Fix Pattern    #\n",
       "0        Checking   38\n",
       "1  Error handling    8\n",
       "2     Interaction   69\n",
       "3          Others    5\n",
       "4           Total  120"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fix_patterns = list(df['Fix: Pattern'])\n",
    "table9_rows = [\"Checking\", \"Error handling\", \"Interaction\", \"Others\"]\n",
    "fix_pattern_to_count = defaultdict(int)\n",
    "for pattern in fix_patterns:\n",
    "    fix_pattern_to_count[pattern] += 1\n",
    "\n",
    "freq = list()\n",
    "for pattern in table9_rows:\n",
    "    freq.append(fix_pattern_to_count[pattern])\n",
    "\n",
    "table9 = pd.DataFrame([table9_rows + [\"Total\"], freq + [len(fix_patterns)]]).transpose()\n",
    "table9.columns = ['Fix Pattern','#']\n",
    "table9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finding 12: In 40% (46/115) CSI failures, the merged fixes improve condition checking and error handling instead of repairing the failed interactions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CSI failures fixed by improving condition checking and error handling instead of repairing the failed interactions: 40.0% (46/115)\n"
     ]
    }
   ],
   "source": [
    "no_fix = fix_pattern_to_count[\"Others\"]\n",
    "total_issues_with_fix  = len(fix_patterns) - no_fix\n",
    "error_handling_fixes = fix_pattern_to_count[\"Error handling\"]\n",
    "condition_checking_fixes = fix_pattern_to_count[\"Checking\"]\n",
    "afterthought_fixes = error_handling_fixes + condition_checking_fixes\n",
    "print(\"CSI failures fixed by improving condition checking \"\\\n",
    "      \"and error handling instead of repairing \"\\\n",
    "      \"the failed interactions: %s%% (%s/%s)\" %\n",
    "      (afterthought_fixes/total_issues_with_fix * 100, afterthought_fixes, total_issues_with_fix))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finding 13: In 69% (79/115) CSI failures, fixes were applied to code in the upstream system specific to interaction with a downstream system. Furthermore, among these 79 cases, fixes for 68 (86%) cases resided in dedicated “connector” modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fixes applied to code in the upstream system specific to interaction with a downstream system: 79/115 (68.7%)\n",
      "Fixes applied to code in the upstream system in dedicated 'connector' modules: 68/79 (86.08%)\n"
     ]
    }
   ],
   "source": [
    "fix_locations = list(df['Fix: Location'])\n",
    "fix_location_to_count = defaultdict(int)\n",
    "for location in fix_locations:\n",
    "    fix_location_to_count[location.strip()] += 1\n",
    "code_specific_to_interaction_connector = fix_location_to_count[\"Code specific to downstream interaction: Connector\"]\n",
    "code_specific_to_interaction_scattered = fix_location_to_count[\"Code specific to downstream interaction: Scattered\"]\n",
    "code_specific_to_interaction = code_specific_to_interaction_connector + code_specific_to_interaction_scattered\n",
    "no_fix_or_documentation = fix_location_to_count[\"N.A.\"]\n",
    "total_fixes = len(fix_locations) - no_fix_or_documentation\n",
    "print(\"Fixes applied to code in the upstream system specific to interaction \" \\\n",
    "      \"with a downstream system: %s/%s (%s%%)\" % (code_specific_to_interaction, total_fixes,\n",
    "                                                  round(code_specific_to_interaction/total_fixes * 100, 2)))\n",
    "print(\"Fixes applied to code in the upstream system \" \\\n",
    "      \"in dedicated 'connector' modules: %s/%s (%s%%)\" % (code_specific_to_interaction_connector, code_specific_to_interaction,\n",
    "                                                       round(code_specific_to_interaction_connector/code_specific_to_interaction * 100, 2)))"
   ]
  }
 ],
 "metadata": {
  "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.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}