This public repository contains the training materials, tutorials, and code for the seven-week Boot Camp of the Open Source Macroeconomics Laboratory (OSM Lab) at Becker Friedman Institute of the University of Chicago, June 19 to August 4. The OSM Lab was founded by Dr. Richard W. Evans, Senior Lecturer at the University of Chicago M.A. Program in Computational Social Science and Fellow at the Becker Friedman Institute. The OSM Lab is funded primarily from a 5-year grant from the Charles Koch Foundation. Part of this grant also included the creation of the Dynamic Analysis Center at the Baker Institute at Rice University, which is directed by John Diamond.

This README.md serves as a syllabus and reference for the OSM Lab Boot Camp. This document has 11 sections.

1. OSM Lab leadership
2. Boot Camp schedule
3. Instructions for installing the Anaconda distribution of Python
4. Text editor suggestions
5. PEP 8, docstring commenting, and module structure
6. Using LaTeX
7. Git and GitHub.com tutorial
8. Jupyter notebooks
9. Python tutorials
10. C++ tutorials
11. References

Director: Dr. Richard W. Evans ([email protected]). The Director and Founder of the OSM Lab is Richard W. Evans. Dr. Evans is a Senior Lecturer at the University of Chicago and a Fellow at the Becker Friedman Institute.

Logistics and finances: Grace Hammond, Becker Friedman Institute ([email protected]): Grace Hammond is the Associate Director for Operations, Programs, and Finance at the Becker Friedman Institute. She coordinates the student and instructor travel, housing, and financial matters.

Instructors. The OSM Lab has excellent instructors and presenters from economics, math, and computation. Below is a list of this year's instructors and presenters in alphabetical order by last name. To see what they teach and when, check the respective math, econ, and computation detailed schedule pages.

Senior Instructors and Presenters

• Jorge Barro, Rice University
• Jason DeBacker, University of South Carolina
• Richard Evans, University of Chicago
• Lars Hansen, University of Chicago
• Matthew Jensen, Open Source Policy Center, American Enterprise Institute
• Greg Kaplan, University of Chicago
• Casey Mulligan, University of Chicago
• Kerk Phillips, Brigham Young University
• Thomas Sargent, New York University
• Simon Scheidegger, University of Zurich and Hoover Institution
• Karl Schmedders, University of Zurich
• John Stachurski, Australia National University
• Viktor Tsyrennikov, Promontory Financial Group

Graduate Instructors

• Zachary Boyd, University of California Los Angeles
• Justin Gardiner, Northwestern University
• John Van den Berghe, University of Chicago

The OSM Lab Boot Camp begins on Monday, June 19 and ends on Friday, August 4. Classes will be held Monday through Friday, 8am to noon in Saieh Hall, Room 247 at the University of Chicago. Breakfast will be served every day from 7:15-8:00am. The curriculum consists of equal parts math, economic theory, and computational methods.

Below is a summary schedule of topics. More detailed schedules are on the respective math, econ, and computation detailed schedule pages.

This will be an intensive seven weeks. We expect that your attendance of lectures plus homework time will average 60 hours per week of work.

Have provided 7 areas of tutorials that you benefit from reading before the training. We will, of course, teach these things as we go through the material. But we will be able to proceed at a faster pace if the attendees are already familiar with most of the concepts below.

Pre-course Tutorial Areas

1. Instructions for installing the Anaconda distribution of Python
2. Text editor suggestions (Atom, Sublime Text 3, Vim)
3. PEP8, docstring commenting, and module structure
4. Git and GitHub tutorial
5. Jupyter Notebooks
6. Basic Python tutorials (data structures, logic, functions and modules, pandas, root finders and minimizers)

We will be using the Python programming language and many of its powerful libraries for writing the code that will run most of the computational methods we will use during the Boot Camp. Using an open source language, such as Python, has the advantage of being free and accessible for anyone who wishes to learn these materials or contribute to these projects. Being open source also allows Python users to go into the source code of any function to modify it to suit one's needs.

We recommend that each participant download the Anaconda distribution of Python provided by Continuum Analytics. We recommend the most recent stable version of Python, which is currently Python 3.6. This can be done from the Anaconda download page for Windows, Mac OSX, and Linux machines.

In our recommended Python development workflow, you will write Python scripts and modules (*.py files) in a text editor. Then you will run those scripts from your terminal. You will want a capable text editor for developing your code. Many capable text editors exist, but we recommend three.

1. Atom
2. Sublime Text 3
3. Vim

Atom and Vim are completely free. A trial version of Sublime Text 3 is available for free, but a licensed version is $70 (US dollars). In the following subsections, we give some of the details of each of the above three text editors.

Atom is an open source text editor developed by people at GitHub.com. This editor has all the features of Sublime Text 3, but it also allows users full customizability. Further, it has been a while now that the users of Atom have surpassed the critical mass necessary to keep the editor progressing with the most cutting edge additions.

There are several packages you'll want to install with Atom. Once Atom is installed, you can add packages by navigating Atom->Preferences->Install and then typing in the name of the package you would like to install.

For work with Python, we recommend the following packages be installed:

• MagicPython
• python-indent
• tabs-to-spaces
• minimap
• open-recent
• linter-python-pep8

For development with GitHub we recommend:

• merge-conflict

If using LaTex in this editor, the following packages are helpful:

• atom-latex
• latextools
• autocomplete-bibtex
• dictionary
• latexer
• pdf-view

In addition, you will also want to download the Skim PDF viewer to aid in displaying PDF files compiled from TeX with Atom.

Sublime Text 3 is the most widely used and versatile private software text editor. It has tremendous flexibility, as well as the polish of a piece of professional software. Sublime Text 3 will cost $70 for a license, although you can use a trial version indefinitely without charge while only having to suffer through frequent reminders to buy the full version.

Vim is free and very powerful. Vim is the hard core developer's text editor of choice. The learning curve for using vim is a little steeper than that of Atom and Sublime Text 3, but it also has some advantages for efficient programming. Vim has navigation that does not use a mouse or trackpad. Eventually, your fingers never leave your keyboard. Further, most terminals have Vim built in so you can use Vim to edit scripts and modules on the fly with your terminal session.

Computer code executes some set of commands in an organized way. In every case, there are often many ways to execute a set of instructions--some ways more efficient than others. However, code has at least three functions.

1. Efficiently execute the task at hand.
2. Be accessible and usable to other programmers.
3. Be scalable and integrable with other projects and procedures.

Bill Gates is credited with the following plea for efficiency and parsimony in code writing.

"Measuring programming progress by lines of code is like measuring aircraft building progress by weight."

Strong support for points (2) and (3) is Eagleson's Law.

"Any code of your own that you haven't looked at for six or more months might as well have been written by someone else."

Because of the latter two characteristics, Python code has developed some conventions and best practices, some of which have been institutionalized in the PEP 8--Style Guide for Python Code ("PEP" stands for Python Enhancement Proposals). Key examples PEP 8 Python coding conventions are the following.

• Indents should be 4 spaces (not tab)
• Limit all lines to a maximum of 79 characters long blocks of text being limited to 72 characters
• Use a space after a comma
• Use a space before and after arithmetic operators

In the text editors Atom, Sublime Text 3, and Vim, you can install Linter packages that highlight areas of your code that break PEP 8 rules and tell you what the violation is.

There are fewer conventions in docstring structure, but we have developed some of our own that are outlined in the PythonFuncs.ipynb Jupyter notebook. See especially Sections 3 and 4 of the Jupyter notebook.

You will turn in all of your assignments by using the LaTeX document preparation platform. LaTeX produces documents with a sophisticated mathematical equation engine. Because LaTeX is standard in mathematical and theoretical document exposition, we will be using it in this class. The LaTeX tutorial PDF chapter in the /Tutorials/LaTeX/ directory is a great reference for installing and running LaTeX. We have also included in that directory a template LaTeX_probset_template.tex as well as the PDf file (LaTeX_probset_template.pdf) generated by compiling that .tex file.

We have included a tutorial on using Git and GitHub.com in the Tutorials directory of this repository. Git is a powerful version control software that comes natively installed on many machines and is widely used. GitHub.com is the most widely used online platform for hosting open source projects and integrating with Git software. Git has a significant learning curve, but it is essential for large collaborations that involve software development.

A more comprehensive Git resource is Pro Git, by Chacon and Straub (2014). This book is open access, and is available online at https://git-scm.com/book/en/v2. But I like having it in my library in hard copy. This book is the difinitive guide with everything Git, and it has as its primary application the interaction between Git and GitHub. However, the workflow described in the tutorial above was hard to find in this Git book.

Jupyter notebooks are files that end with the *.ipynb suffix. These notebooks are opened in a browser environment and are an open source web application that combines instructional text with live executable and modifyable code for many different programming platforms (e.g., Python, R, Julia). Jupyter notebooks are an ideal tool for teaching programming as they provide the code for a user to execute and they also provide the context and explanation for the code. We have provided a number of Jupyter notebooks in the Tutorials folder of this repository.

These notebooks used to be Python-specific, and were therefore called iPython notebooks (hence the *.ipynb suffix). But Jupyter notebooks now support many programming languages, although the name still pays homage to Python with the vestigal "py" in "Jupyter". The notebooks execute code from the kernel of the specific programming language on your local machine.

Jupyter notebooks capability will be automatically installed with your download of the Anaconda distribution of Python. If you did not download the Anaconda distribution of Python, you can download Jupyter notebooks separately by following the instructions on the Jupyter install page.

Once Jupyter is installed--whether through Anaconda or through the Jupyter website--you can open a Jupyter notebook by the following steps.

1. Navigate in your terminal to the folder in which the Jupyter notebook files reside. In the case of the Jupyter notebook tutorials in this repository, you would navigate to the ~/OG-JRC/Tutorials/ directory.
2. Type jupyter notebook at the terminal prompt.
3. A Jupyter notebook session will open in your browser, showing the available *.ipynb files in that directory.
4. Double click on the Jupyter notebook you would like to open.

It is worth noting that you can also simply navigate to the URL of the Jupyter notebook file in the GitHub repository on the web (e.g., https://github.com/OpenSourceMacro/BootCamp2017/blob/master/Tutorials/PythonReadIn.ipynb). You can read the Jupyter notebook on GitHub.com, but you cannot execute any of the cells. You can only execute the cells in the Jupyter notebook when you follow the steps above and open the file from your terminal.

Once you have opened a Jupyter notebook, you will find the notebook has two main types of cells: Markdown cells and Code cells. Markdown cells have formatted Jupyter notebook markdown text, and serve primarily to present context for the coding cells. A reference for the markdown options in Jupyter notebooks is found in the Jupyter markdown documentation page.

You can edit a Markdown cell in a Jupyter notebook by double clicking on the cell and then making your changes. Make sure the cell-type box in the middle of the top menu bar is set to Markdown. To implement your changes in the Markdown cell, type Shift-Enter.

A Code cell will have a In [ ]: immediately to the left of the cell for input. The code in that cell can be executed by typing Shift-Enter. For a Code cell, the cell-type box in the middle of the top menu bar says Code.

When you are done with a Jupyter notebook, you first save any changes that you want to remain with the notebook. Then you close the browser windows associated with that Jupyter notebook session. You must then close the local server that was opened to run the Jupyter notebook in your terminal window. On a Mac or Windows, this is done by going to your terminal window and typing Ctrl-C and then selecting y for yes and hitting Enter.

For this training, we have included in this repository six basic Python tutorials in the Tutorials directory.

1. PythonReadIn.ipynb. This Jupyter notebook provides instruction on basic Python I/O, reading data into Python, and saving data to disk.
2. PythonNumpyPandas.ipynb. This Jupyter notebook provides instruction on working with data using NumPy as well as Python's powerful data library pandas.
3. PythonDescribe.ipynb. This Jupyter notebook provides instruction on describing, slicing, and manipulating data in Python.
4. PythonFuncs.ipynb. This Jupyter notebook provides instruction on working with and writing Python functions.
5. PythonVisualize.ipynb. This Jupyter notebook provides instruction on creating visualizations in Python.
6. PythonRootMin.ipynb. This Jupyter notebook provides instruction on implementing univariate and multivariate root finders and unconstrained and constrained minimizers using functions in the scipy.optimize sub-library.

To further one's Python programming skills, a number of other great resources exist.

• The official Python 3 tutorial site
• QuantEcon.net is a site run by Thomas Sargent (NYU Stern) and John Stachurski (Australia National University). QuantEcon has a very large number of high-quality economics focused computational tutorials in Python.
• Python computational labs of the Applied and Computational Mathematics Emphasis at Brigham Young University
• Code Academy's Python learning module

In addition, a number of excellent textbooks and reference manuals are very helpful and may be available in your local library. Or you may just want to have these in your own library. Lutz (2013) is a giant 1,500-page reference manual that has an expansive collection of materials targeted at beginners. Beazley (2009) is a more concise reference but is targeted at readers with some experience using Python. Despite its focus on a particular set of tools in the Python programming language, McKinney (2013) has a great introductory section that can serve as a good starting tutorial. Further, its focus on Python's data analysis capabilities is truly one of the important features of Python. Rounding out the list is Langtangen (2010). This book's focus on scientists and engineers makes it a unique reference for optimization, wrapping C and Fortran and other scientific computing topics using Python.

Although we will be using Python for most of the Boot Camp, we will use C++ for the computational labs taught by Simon Scheidegger on July, 20, 25, 27,, August 1,and 3. These computational labs treat high performance computing, parallel computing, and high dimensional approximation. Using supercomputing resources is much more accessible with C++.

[TODO: Include tutorial materials here.]

• Beazley, David M., Python Essential Reference, 4th edition, Addison-Wesley (2009).
• Chacon, Scott and Ben Straub, Pro Git: Everything You Need To Know About Git, 2nd edition, Apress (2014).
• Langtangen, Hans Petter, Python Scripting for Computational Science, Texts in Computational Science and Engineering, 3rd edition, Springer (2010).
• Lutz, Mark, Learning Python, 5th edition, O'Reilly Media, Inc. (2013)
• McKinney, Wes, Python for Data Analysis, O'Reilly Media, Inc. (2013)