Project_The GitHub History of the Scala Language.ipynb

{"metadata":{"language_info":{"file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"nbconvert_exporter":"python","mimetype":"text/x-python","pygments_lexer":"ipython3","name":"python","version":"3.5.2"},"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"}},"nbformat":4,"nbformat_minor":2,"cells":[{"metadata":{"run_control":{"frozen":true},"dc":{"key":"5"},"deletable":false,"tags":["context"],"editable":false},"cell_type":"markdown","source":"## 1. Scala's real-world project repository data\n<p>With almost 30k commits and a history spanning over ten years, Scala is a mature programming language. It is a general-purpose programming language that has recently become another prominent language for data scientists.</p>\n<p>Scala is also an open source project. Open source projects have the advantage that their entire development histories -- who made changes, what was changed, code reviews, etc. -- are publicly available. </p>\n<p>We're going to read in, clean up, and visualize the real world project repository of Scala that spans data from a version control system (Git) as well as a project hosting site (GitHub). We will find out who has had the most influence on its development and who are the experts.</p>\n<p>The dataset we will use, which has been previously mined and extracted from GitHub, is comprised of three files:</p>\n<ol>\n<li><code>pulls_2011-2013.csv</code> contains the basic information about the pull requests, and spans from the end of 2011 up to (but not including) 2014.</li>\n<li><code>pulls_2014-2018.csv</code> contains identical information, and spans from 2014 up to 2018.</li>\n<li><code>pull_files.csv</code> contains the files that were modified by each pull request.</li>\n</ol>"},{"metadata":{"dc":{"key":"5"},"tags":["sample_code"],"trusted":true},"execution_count":4,"outputs":[],"cell_type":"code","source":"# Importing pandas\nimport pandas as pd\n\n# Loading in the data\npulls_one = pd.read_csv('datasets/pulls_2011-2013.csv')\npulls_two = pd.read_csv('datasets/pulls_2014-2018.csv')\npull_files = pd.read_csv('datasets/pull_files.csv')"},{"metadata":{"run_control":{"frozen":true},"dc":{"key":"12"},"deletable":false,"tags":["context"],"editable":false},"cell_type":"markdown","source":"## 2. Preparing and cleaning the data\n<p>First, we will need to combine the data from the two separate pull DataFrames. </p>\n<p>Next, the raw data extracted from GitHub contains dates in the ISO8601 format. However, <code>pandas</code> imports them as regular strings. To make our analysis easier, we need to convert the strings into Python's <code>DateTime</code> objects. <code>DateTime</code> objects have the important property that they can be compared and sorted.</p>\n<p>The pull request times are all in UTC (also known as Coordinated Universal Time). The commit times, however, are in the local time of the author with time zone information (number of hours difference from UTC). To make comparisons easy, we should convert all times to UTC.</p>"},{"metadata":{"dc":{"key":"12"},"collapsed":true,"tags":["sample_code"],"trusted":true},"execution_count":6,"outputs":[],"cell_type":"code","source":"# Append pulls_one to pulls_two\npulls = pulls_two.append(pulls_one, ignore_index=True)\n\n# Convert the date for the pulls object\npulls['date'] = pd.to_datetime(pulls['date'], utc=True)"},{"metadata":{"run_control":{"frozen":true},"dc":{"key":"19"},"deletable":false,"tags":["context"],"editable":false},"cell_type":"markdown","source":"## 3. Merging the DataFrames\n<p>The data extracted comes in two separate files. Merging the two DataFrames will make it easier for us to analyze the data in the future tasks.</p>"},{"metadata":{"dc":{"key":"19"},"collapsed":true,"tags":["sample_code"],"trusted":true},"execution_count":8,"outputs":[],"cell_type":"code","source":"# Merge the two DataFrames\ndata = pulls.merge(pull_files, on='pid')"},{"metadata":{"run_control":{"frozen":true},"dc":{"key":"26"},"deletable":false,"tags":["context"],"editable":false},"cell_type":"markdown","source":"## 4. Is the project still actively maintained?\n<p>The activity in an open source project is not very consistent. Some projects might be active for many years after the initial release, while others can slowly taper out into oblivion. Before committing to contributing to a project, it is important to understand the state of the project. Is development going steadily, or is there a drop? Has the project been abandoned altogether?</p>\n<p>The data used in this project was collected in January of 2018. We are interested in the evolution of the number of contributions up to that date.</p>\n<p>For Scala, we will do this by plotting a chart of the project's activity. We will calculate the number of pull requests submitted each (calendar) month during the project's lifetime. We will then plot these numbers to see the trend of contributions.</p>\n<ul>\n<li><p>A helpful reminder of how to access various components of a date can be found in <a href=\"https://campus.datacamp.com/courses/data-manipulation-with-pandas/slicing-and-indexing?ex=12\">this exercise of Data Manipulation with pandas</a></p></li>\n<li><p>Additionally, recall that you can group by multiple variables by passing a list to <code>groupby()</code>. This video from <a href=\"https://campus.datacamp.com/courses/data-manipulation-with-pandas/aggregating-data-ad6d4643-0e95-470c-8299-f69cc4c83de8?ex=9\">Data Manipulation with pandas</a> should help!</p></li>\n</ul>"},{"metadata":{"dc":{"key":"26"},"tags":["sample_code"],"trusted":true},"execution_count":10,"outputs":[{"metadata":{},"output_type":"execute_result","execution_count":10,"data":{"text/plain":"<matplotlib.axes._subplots.AxesSubplot at 0x7f73ed12ff60>"}},{"metadata":{},"output_type":"display_data","data":{"text/plain":"<Figure size 864x288 with 1 Axes>","image/png":"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\n"}}],"cell_type":"code","source":"%matplotlib inline\n\n# Create a column that will store the month\ndata['month'] = data['date'].dt.month\n\n# Create a column that will store the year\ndata['year'] = data['date'].dt.year\n\n# Group by month_year and count the pull requests\ncounts = data.groupby(['year', 'month'])['pid'].count()\n\n# Plot the results\ncounts.plot(kind='bar', figsize = (12,4))"},{"metadata":{"run_control":{"frozen":true},"dc":{"key":"33"},"deletable":false,"tags":["context"],"editable":false},"cell_type":"markdown","source":"## 5. Is there camaraderie in the project?\n<p>The organizational structure varies from one project to another, and it can influence your success as a contributor. A project that has a very small community might not be the best one to start working on. The small community might indicate a high barrier of entry. This can be caused by several factors, including a community that is reluctant to accept pull requests from \"outsiders,\" that the code base is hard to work with, etc. However, a large community can serve as an indicator that the project is regularly accepting pull requests from new contributors. Such a project would be a good place to start.</p>\n<p>In order to evaluate the dynamics of the community, we will plot a histogram of the number of pull requests submitted by each user. A distribution that shows that there are few people that only contribute a small number of pull requests can be used as in indicator that the project is not welcoming of new contributors. </p>"},{"metadata":{"dc":{"key":"33"},"tags":["sample_code"],"trusted":true},"execution_count":12,"outputs":[{"metadata":{},"output_type":"execute_result","execution_count":12,"data":{"text/plain":"array([[<matplotlib.axes._subplots.AxesSubplot object at 0x7f73d2784cc0>]],\n      dtype=object)"}},{"metadata":{},"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"}}],"cell_type":"code","source":"# Required for matplotlib\n%matplotlib inline\n\n# Group by the submitter\nby_user = data.groupby('user').agg({'pid': 'count'})\n\n# Plot the histogram\nby_user.hist()"},{"metadata":{"run_control":{"frozen":true},"dc":{"key":"40"},"deletable":false,"tags":["context"],"editable":false},"cell_type":"markdown","source":"## 6. What files were changed in the last ten pull requests?\n<p>Choosing the right place to make a contribution is as important as choosing the project to contribute to. Some parts of the code might be stable, some might be dead. Contributing there might not have the most impact. Therefore it is important to understand the parts of the system that have been recently changed. This allows us to pinpoint the \"hot\" areas of the code where most of the activity is happening. Focusing on those parts might not the most effective use of our times.</p>"},{"metadata":{"dc":{"key":"40"},"tags":["sample_code"],"trusted":true},"execution_count":14,"outputs":[{"metadata":{},"output_type":"execute_result","execution_count":14,"data":{"text/plain":"{'LICENSE',\n 'doc/LICENSE.md',\n 'doc/License.rtf',\n 'project/VersionUtil.scala',\n 'src/compiler/scala/reflect/reify/phases/Calculate.scala',\n 'src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala',\n 'src/compiler/scala/tools/nsc/backend/jvm/PostProcessor.scala',\n 'src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala',\n 'src/compiler/scala/tools/nsc/profile/AsyncHelper.scala',\n 'src/compiler/scala/tools/nsc/profile/Profiler.scala',\n 'src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala',\n 'src/compiler/scala/tools/nsc/typechecker/Contexts.scala',\n 'src/library/scala/Predef.scala',\n 'src/library/scala/concurrent/Lock.scala',\n 'src/library/scala/util/Properties.scala',\n 'src/reflect/scala/reflect/internal/pickling/ByteCodecs.scala',\n 'src/reflect/scala/reflect/internal/tpe/GlbLubs.scala',\n 'src/scaladoc/scala/tools/nsc/doc/html/page/Entity.scala',\n 'src/scalap/decoder.properties',\n 'test/files/neg/leibniz-liskov.check',\n 'test/files/neg/leibniz-liskov.scala',\n 'test/files/pos/leibniz-liskov.scala',\n 'test/files/pos/leibniz_liskov.scala',\n 'test/files/pos/parallel-classloader.scala',\n 'test/files/pos/t10568/Converter.java',\n 'test/files/pos/t10568/Impl.scala',\n 'test/files/pos/t10686.scala',\n 'test/files/pos/t5638/Among.java',\n 'test/files/pos/t5638/Usage.scala',\n 'test/files/pos/t9291.scala',\n 'test/files/run/t8348.check',\n 'test/files/run/t8348/TableColumn.java',\n 'test/files/run/t8348/TableColumnImpl.java',\n 'test/files/run/t8348/Test.scala'}"}}],"cell_type":"code","source":"# Identify the last 10 pull requests\nlast_10 = pulls.sort_values(by = 'date').tail(10)\nlast_10\n\n# Join the two data sets\njoined_pr = pull_files.merge(last_10, on='pid')\n\n# Identify the unique files\nfiles = set(joined_pr['file'])\n\n# Print the results\nfiles"},{"metadata":{"run_control":{"frozen":true},"dc":{"key":"47"},"deletable":false,"tags":["context"],"editable":false},"cell_type":"markdown","source":"## 7. Who made the most pull requests to a given file?\n<p>When contributing to a project, we might need some guidance. We might find ourselves needing some information regarding the codebase. It is important direct any questions to the right person. Contributors to open source projects generally have other day jobs, so their time is limited. It is important to address our questions to the right people. One way to identify the right target for our inquiries is by using their contribution history.</p>\n<p>We identified <code>src/compiler/scala/reflect/reify/phases/Calculate.scala</code> as being recently changed. We are interested in the top 3 developers who changed that file. Those developers are the ones most likely to have the best understanding of the code.</p>"},{"metadata":{"dc":{"key":"47"},"tags":["sample_code"],"trusted":true},"execution_count":16,"outputs":[{"metadata":{},"output_type":"execute_result","execution_count":16,"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>pid</th>\n      <th>date</th>\n      <th>file</th>\n      <th>month</th>\n      <th>year</th>\n    </tr>\n    <tr>\n      <th>user</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>xeno-by</th>\n      <td>11</td>\n      <td>11</td>\n      <td>11</td>\n      <td>11</td>\n      <td>11</td>\n    </tr>\n    <tr>\n      <th>retronym</th>\n      <td>5</td>\n      <td>5</td>\n      <td>5</td>\n      <td>5</td>\n      <td>5</td>\n    </tr>\n    <tr>\n      <th>soc</th>\n      <td>4</td>\n      <td>4</td>\n      <td>4</td>\n      <td>4</td>\n      <td>4</td>\n    </tr>\n  </tbody>\n</table>\n</div>","text/plain":"          pid  date  file  month  year\nuser                                  \nxeno-by    11    11    11     11    11\nretronym    5     5     5      5     5\nsoc         4     4     4      4     4"}}],"cell_type":"code","source":"# This is the file we are interested in:\nfile = 'src/compiler/scala/reflect/reify/phases/Calculate.scala'\n\n# Identify the pull requests that changed the file\nfile_pr = data[data['file'] == file]\n\n# Count the number of changes made by each developer\nauthor_counts = file_pr.groupby('user').count()\n\n# Print the top 3 developers\nauthor_counts.nlargest(3, 'file')"},{"metadata":{"run_control":{"frozen":true},"dc":{"key":"54"},"deletable":false,"tags":["context"],"editable":false},"cell_type":"markdown","source":"## 8. Who made the last ten pull requests on a given file?\n<p>Open source projects suffer from fluctuating membership. This makes the problem of finding the right person more challenging: the person has to be knowledgeable <em>and</em> still be involved in the project. A person that contributed a lot in the past might no longer be available (or willing) to help. To get a better understanding, we need to investigate the more recent history of that particular part of the system. </p>\n<p>Like in the previous task, we will look at the history of  <code>src/compiler/scala/reflect/reify/phases/Calculate.scala</code>.</p>"},{"metadata":{"dc":{"key":"54"},"tags":["sample_code"],"trusted":true},"execution_count":18,"outputs":[{"metadata":{},"output_type":"execute_result","execution_count":18,"data":{"text/plain":"{'bjornregnell', 'retronym', 'soc', 'starblood', 'xeno-by', 'zuvizudar'}"}}],"cell_type":"code","source":"file = 'src/compiler/scala/reflect/reify/phases/Calculate.scala'\n\n# Select the pull requests that changed the target file\nfile_pr = pull_files[pull_files['file'] == file]\n\n# Merge the obtained results with the pulls DataFrame\njoined_pr = pulls.merge(file_pr, on='pid')\n\n# Find the users of the last 10 most recent pull requests\nusers_last_10 = set(joined_pr.nlargest(10, 'date')['user'])\n\n# Printing the results\nusers_last_10"},{"metadata":{"run_control":{"frozen":true},"dc":{"key":"61"},"deletable":false,"tags":["context"],"editable":false},"cell_type":"markdown","source":"## 9. The pull requests of two special developers\n<p>Now that we have identified two potential contacts in the projects, we need to find the person who was most involved in the project in recent times. That person is most likely to answer our questions. For each calendar year, we are interested in understanding the number of pull requests the authors submitted. This will give us a high-level image of their contribution trend to the project.</p>"},{"metadata":{"dc":{"key":"61"},"tags":["sample_code"],"trusted":true},"execution_count":20,"outputs":[{"metadata":{},"output_type":"execute_result","execution_count":20,"data":{"text/plain":"<matplotlib.axes._subplots.AxesSubplot at 0x7f73d266e6d8>"}},{"metadata":{},"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"}}],"cell_type":"code","source":"%matplotlib inline\n\n# The developers we are interested in\nauthors = ['xeno-by', 'soc']\n\n# Get all the developers' pull requests\nby_author = pulls[pulls['user'].isin(authors)]\n\n# Count the number of pull requests submitted each year\ncounts = by_author.groupby([by_author['user'], by_author['date'].dt.year]).agg({'pid': 'count'}).reset_index()\n\n# Convert the table to a wide format\ncounts_wide = counts.pivot_table(index='date', columns='user', values='pid', fill_value=0)\n\n# Plot the results\ncounts_wide.plot(kind='bar')"},{"metadata":{"run_control":{"frozen":true},"dc":{"key":"68"},"deletable":false,"tags":["context"],"editable":false},"cell_type":"markdown","source":"## 10. Visualizing the contributions of each developer\n<p>As mentioned before, it is important to make a distinction between the global expertise and contribution levels and the contribution levels at a more granular level (file, submodule, etc.) In our case, we want to see which of our two developers of interest have the most experience with the code in a given file. We will measure experience by the number of pull requests submitted that affect that file and how recent those pull requests were submitted.</p>"},{"metadata":{"dc":{"key":"68"},"tags":["sample_code"],"trusted":true},"execution_count":22,"outputs":[{"metadata":{},"output_type":"execute_result","execution_count":22,"data":{"text/plain":"<matplotlib.axes._subplots.AxesSubplot at 0x7f73d0bbb400>"}},{"metadata":{},"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"}}],"cell_type":"code","source":"authors = ['xeno-by', 'soc']\nfile = 'src/compiler/scala/reflect/reify/phases/Calculate.scala'\n\n# Merge DataFrames and select the pull requests by the author\nby_author = data[data['user'].isin(authors)]\n\n# Select the pull requests that affect the file\nby_file = by_author[by_author['file'] == file]\n\n# Group and count the number of PRs done by each user each year\ngrouped = by_file.groupby(['user', by_file['date'].dt.year]).count()['pid'].reset_index()\n\n# Transform the data into a wide format\nby_file_wide = grouped.pivot_table(index='date', columns='user', values='pid', fill_value=0)\n\n# Plot the results\nby_file_wide.plot(kind='bar')"}]}