There are two issues with svg:

• It requires you to trust a notebook in order to correct display it. Jupyter caches that trust, but otherwise it is a pain
• I think it may create very large figures.

So one solution is to try to use png with plots. To do that, anywhere there is a using Plots change it to

using Plots
gr(fmt=:png)

I think! Check with one of the notebooks that has a large aiyagari.ipynb to see if it helps with the size.

The new arguments for Julia v1.0 include the ability to activate a project when julia starts up.

It isn't documented especially well yet, but I think the options are:

• --project=. to select the current project file
• --project=@. to recursively go up the tree until it finds a project file (or default otherwise)?

These can be set in Juno (by going to the Julia Client settings and setting the Additional Julia Startup Arguments.

The question is: what should the settings be in our setup guides - and is it something we should submit a PR for to the Juno to change the default.

We should ask on slack to see how it is supposed to work test both versions with the following permutations:

• Open up the Juno repl after starting Juno in a particular directory with a project file
• Same, but with a project that doesn't have a project file yet. This shouldn't error, and should default to the standard v1.0 project
• Same but in a sub-directory of something with a project file. It would be nice if it picked up the parent directory project file, but not essential. Again, shouldn't error

We should also make sure that this workflow is the one we want. Finally, what other features for working with Pkg3 would make sense. An instantiate button/command? A test one? Asking to create a new project when starting the REPL in a folder without a project file, etc.

Programming in Julia

• Setting up your Julia Environment
• An Introductory Example
• Julia Essentials
• Vectors, Arrays, and Matrices
• Types, Methods, and Dispatch
• The Need for Speed
• Plotting in Julia
• Useful Libraries

Tools and Techniques

• Linear Algebra (#161)
• Orthogonal Projections and their Applications (#162)
• LLN and CLT
• Linear State-Space Models
• Finite Markov Chains (#173)
• Continuous State Markov Chains
• A First Look at the Kalman Filter (#205)

Dynamic Programming

• Shortest Paths (#221)
• Job Search I: The McCall Search Model (#218)
• Job Search II: Search and Separation
• A Problem that Stumped Milton Friedman (#156)
• Job Search III: Search with Learning
• Job Search IV: Modeling Career Choice
• Job Search V: On-the-Job Search
• Optimal Growth I: The Stochastic Optimal Growth Model (#225)
• Optimal Growth II: Time Iteration (#226)
• Optimal Growth III: The Endogenous Grid Method
• LQ Dynamic Programming Problems
• Optimal Savings I: The Permanent Income Model
• Optimal Savings II: LQ Techniques .
• Consumption and Tax Smoothing with Complete and Incomplete Markets
• Optimal Savings III: Occasionally Binding Constraints
• Robustness
• Discrete State Dynamic Programming * Be aware of Jesse rewrite

Multiple Agent Models

• Schelling's Segregation Model
• A Lake Model of Employment and Unemployment * Be aware of Jesse rewrite
• Rational Expectations Equilibrium
• Markov Perfect Equilibrium
• Asset Pricing I: Finite State Models * Be aware of Jesse rewrite
• Asset Pricing II: The Lucas Asset Pricing Model
• Asset Pricing III: Incomplete Markets
• Uncertainty Traps
• The Aiyagari Model
• Default Risk and Income Fluctuations
• Globalization and Cycles

Time Series Models

• Covariance Stationary Processes
• Estimation of Spectra
• Additive Functionals
• Multiplicative Functionals
• Classical Control with Linear Algebra
• Classical Filtering with Linear Algebra

Dynamic Programming Squared

• Dynamic Stackelberg Problems
• Optimal Taxation in an LQ Economy
• Optimal Taxation with State-Contingent Debt
• Optimal Taxation without State-Contingent Debt

From teaching, students frequently forget to Trust the notebook. The main place this causes issues is that the graphs disappear when they reopen it.

I think the solution is to use the png wherever plots comes up. That is,

using Plots

globally becomes

using Plots
gr(fmt=:png)

Getting Started with Julia

• Setting up your Julia Environment
• An Introductory Example
• Julia Essentials and more material
• Fundamental Types with more material
• Introduction to Types and Generic Programming

More Programming and Software Engineering Principles

• Generic Programming
• The Need for Speed
• Plotting in Julia
• Useful Libraries

Tools and Techniques

• Linear Algebra
• Orthogonal Projections and their Applications
• LLN and CLT
• Linear State-Space Models
• Finite Markov Chains
• Continuous State Markov Chains
• A First Look at the Kalman Filter

Dynamic Programming

• Shortest Paths
• Job Search I: The McCall Search Model
• Job Search II: Search and Separation
• A Problem that Stumped Milton Friedman
• Job Search III: Search with Learning
• Job Search IV: Modeling Career Choice
• Job Search V: On-the-Job Search
• Optimal Growth I: The Stochastic Optimal Growth Model
• Optimal Growth II: Time Iteration
• Optimal Growth III: The Endogenous Grid Method
• LQ Dynamic Programming Problems
• Optimal Savings I: The Permanent Income Model
• Optimal Savings II: LQ Techniques
• Consumption and Tax Smoothing with Complete and Incomplete Markets
• Optimal Savings III: Occasionally Binding Constraints
• Robustness
• Discrete State Dynamic Programming

Multiple Agent Models

• Schelling's Segregation Model
• A Lake Model of Employment and Unemployment
• Rational Expectations Equilibrium
• Markov Perfect Equilibrium
• Asset Pricing I: Finite State Models
• Asset Pricing II: The Lucas Asset Pricing Model
• Asset Pricing III: Incomplete Markets
• Uncertainty Traps
• The Aiyagari Model
• Default Risk and Income Fluctuations
• Globalization and Cycles

Time Series Models

• Covariance Stationary Processes
• Estimation of Spectra
• Additive Functionals
• Multiplicative Functionals
• Classical Control with Linear Algebra
• Classical Filtering with Linear Algebra

Dynamic Programming Squared

• Dynamic Stackelberg Problems
• Optimal Taxation in an LQ Economy
• Optimal Taxation with State-Contingent Debt
• Optimal Taxation without State-Contingent Debt

Go through the lectures and, wherever possible, replace homebrewed expectations (i.e., the dot product of something with a pdf vector) with the E() operator from QuantEcon/Expectations.jl.

Some lectures to check:

• Wald-Friedman
• McCall
• IFP
• Classical Filtering
• Aiyagari

There are two ways to do this:

• First, see if you can add a line to the makefile so that it copies them from the current notebooks directory when make jupyter is run. This is ideal
• If not, then:
  • add the _build/jupyter or whereever the notebooks aree generated to git.
  • ignore all ipynb, etc. files in there
  • Put the toml files there, and make sure they are in git, as they would be the master versions
  • Remove the toml files from git in the notebooks directory, so we only have 1 copy
  • Add a line into the bash script for running notebooks which atuomatically copies the toml files into notebooks, and make sure they are ignored in git.

From https://github.com/ubcecon/computing_and_datascience/tree/master/docker#how-to-get-docker-running-on-your-laptop

• image with the activate_github and the ] add ... precompiled, etc.
• Pointer for instructions to download docker
• Then how to run docker in a local folder, and at least read notebooks, something like

docker run -p 8888:8888 -v "$PWD":/home/jovyan/work quantecon/jupyter-image

Try on windows, osx, and linx

• How to start the docker again.
• How to access the notebooks there, what to copy for the URL string, etc.
• Test that GRL works

Looks like it's carrying out the same computations over and over (but not infinitely). For example, the twelfth code block yields:

Converged in 13 steps
Compute iterate 5 with error 1.9261818620389288
Compute iterate 10 with error 0.00013175562270539842
Converged in 13 steps
Compute iterate 5 with error 1.9261818620389288
Compute iterate 10 with error 0.00013175562270539842
Converged in 13 steps
Compute iterate 5 with error 1.9261818620389288
Compute iterate 10 with error 0.00013175562270539842
Converged in 13 steps
Compute iterate 5 with error 1.9261818620389288
Compute iterate 10 with error 0.00013175562270539842
Converged in 13 steps
Compute iterate 5 with error 1.9261818620389288
Compute iterate 10 with error 0.00013175562270539842
Converged in 13 steps
Compute iterate 5 with error 1.9261818620389288
Compute iterate 10 with error 0.00013175562270539842

When I use the project files, I am missing LaTeXStrings, which breaks current notebooks.
I realize that we will eventually get rid of all latexstrings, but we are not there yet.

• Until then, can you add it to the Project.toml and the Manfiest.toml for the notebooks?
• Also add GR while you are at it, so that it precompile.
• Give the new files to Jasmine to get these built into the syzygy activation, if at all possible.

The default font used in Windows consoles has poor unicode coverage, which is a problem if we want to use unicode heavy examples. Luckily, if fonts are installed it is relatively easy to change it in Windows (and I suspect terminals on other OSs).

My general gut is that for windows it might be DejaVu Sans Mono or Fira Mono which is installed by Atom but I could be wrong...

• Check if DejaVu Sans Mono` is installed on your Windows system by right-clicking on the shortcut, going to properties, choosing the font, etc.
• Check what the default font is for an Atom installation. I can't tell if this is set in the one-dark syntax theme or is chosen separately.. I think it is either one of these two, though it could be different for different OS. Check Windows, Ubuntu, and OSX
• The julia console used within Atom uses whatever is the default font, as far as I can tell. This is helpful since it means if they use the embedded console the experience is very solid.
• Check the default font used in jupyterlab
• Add content to the setup instructions for Windows to set the font.
• It is pretty easy to choose by right-clicking on the link if the font is installed. This could be described in one line
• However, if the font we want to choose doesn't show up in the list, then it may require a registry tweak. Best avoided if possible, but here is https://www.wikihow.com/Customize-the-Font-in-Windows-Command-Prompt

A good test-suite to see if the font is solid is to type into the console (where the <TAB> completes the latex)

\alpha<TAB>
x\hat<TAB>
x\_1<TAB>
x\bar<TAB>
\alpha<TAB>\_1<TAB>
\cdot<TAB>
\otimes<TAB>
\partial<TAB>

And some others I am not sure the latex expansion for

𝒟

As discussed on Slack, code that's not used in multiple lectures should be moved out of the _static/code folder or whatever it's called. Also, per @jlperla, files that are not used at all should be nuked.

As discussed, the workflow on this lecture is a special case. The current plan is to do the minimum required to get this thing running on 1.0/stylistic changes, and then perhaps to have one of the undergrad RAs dig in and build a test suite.

I think I'm in the home stretch on the undeprecation, will push to the server from my home machine on Sunday.

List out all of the unicode characters in a .jl file we might want to use, then we can load it in Jupyter and Atom on various OSs.

• Check u_0, etc.

We are moving to the crediting scheme in https://github.com/jstac/QuantEcon.lectures/issues/1195.

Highlights:

• Standardized format for coauthors at the top of each page. (when applicable)
• Removing all "inline" citations/attributions (e.g., in comments, cells, Markdown, etc.) and moving these to a global credits page. There should be no names in the code.
• Credits page will be in a different repo. Details on where to submit them TBD.

No need to duplicate the whole checklist here. Can just be mindful of this as we proceed with the rewrite, and then do a final pass to make sure we got them all.

cc: @jstac, @jlperla, @Nosferican

A few lectures will make reference or ask for the student to write some code in Python instead of Julia.

What is the basic plan with trust and the jupyter notebooks for QE? One place this comes up is in the plotting, since svg+xml is not a trusted mimetype. If we want the notebooks to load up and have the figures visible without running them, then there are two choices:

1. Put gr(fmt="png") or something like that in front, which chagnes the svg into png - not requiring trust
2. Teach users to go Trust Notebook when they open them.

Part of the quetsion is also whether the rest of the QE output will work with the generated notebooks if they are not trusted? If we have to trust them regardless, then changing to png is not worth it.

With the current branch, the following is not working. We should find out why and patch NLsolve if required

using NLsolve, ForwardDiff
function fp(params)
    β, p = params #unpack vector
    sol = fixedpoint(v -> p .+ β * v, [0.8], inplace = false)
    return sol.zero[1]
end

fp([0.1, 2.0])
ForwardDiff.gradient(x -> fp(x), [0.1, 2.0])

Would be great if we could bring down some of the filesizes (as a benchmark, aiyagari.ipynb, which is 17MB). See #142. Tinkering with Plots resolutions/sizes didn't help much, but maybe we could ] up in a few days. If that doesn't work, post on Slack.

Instead of something like using Pkg; Pkg.activate(@__DIR__), change it to using InstantiateFromURL; activate_github("QuantEcon/QuantEconLecturePackages"). Could either do the last tagged release or master (@jlperla).

It appears that IJulia in the latest version has https://github.com/stevengj/SoftGlobalScope.jl

Built in. We should try it, as I believe this is a tagged release with v1.0 on Windows now. If so, then it means we can avoid the let blocks.

It would still have trouble if that code is copied to a REPL without modification (or embedding in a function or let, but I would bet money that this sort of Soft global thing is built into the REPL before too long

Cc: @arnavs @Nosferican

From earlier discussion with @jlperla. Implementing a set of tools that new RAs/collaborators could use to quickly start working on the lectures. Wishlist could include:

• Notebook testing scripts (individual and all).
• Scripts to grab dependency information (which packages are used, how often and where?)
• Docker image?

cc: @jstac, @natashawatkins, @mmcky, etc.

One thing @Nosferican, @jlperla and I discussed was replacing screenshots like:

with something like:

arnavsood@Arnavs-MacBook-Pro:~/research/lecture-source-jl$ julia
               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.0.0 (2018-08-08)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

julia> 

for compactness and upgradability. Let me know if you concur. If not, we can close this issue.

Move to https://github.com/JuliaMath/Roots.jl instead of the QuantEcon.jl features.

I think the ones to look for in the code are all of the bracketed root functions

• http://quantecon.github.io/QuantEcon.jl/latest/api/QuantEcon.html#QuantEcon.bisect-Union{Tuple{Function,T,T},%20Tuple{T}}%20where%20T%3C:AbstractFloat
• http://quantecon.github.io/QuantEcon.jl/latest/api/QuantEcon.html#QuantEcon.brent-Union{Tuple{Function,T,T},%20Tuple{T}}%20where%20T%3C:AbstractFloat
• http://quantecon.github.io/QuantEcon.jl/latest/api/QuantEcon.html#QuantEcon.brenth-Union{Tuple{Function,T,T},%20Tuple{T}}%20where%20T%3C:AbstractFloat

To be clear, though, I am not sure that Roots.jl is always better, just that it is where we should add in new code and be able to swap out algorithms easily. It will also be much easier to tweak find_zero to support BigFloat, etc.

In fact, porting over some of those QuantEcon.jl routines to Roots.jl might be a good project for a student. Or maybe implementing "TOMS Algorithm 748" or something similar to see if it works well.

My current output:

jlperla@jlperla-surface:~/Documents/lecture-source-jl$ make jupyter
Running Sphinx v1.7.4
making output directory...
loading pickled environment... not yet created
building [mo]: targets for 0 po files that are out of date
building [jupyter]: targets for 71 source files that are out of date
updating environment: 71 added, 0 changed, 0 removed
checking for /mnt/c/Users/jlperla/Documents/GitHub/lecture-source-jl/rst_files/_static/quant-econ.bib in bibtex cache... not found
parsing bibtex file /mnt/c/Users/jlperla/Documents/GitHub/lecture-source-jl/rst_files/_static/quant-econ.bib... parsed 149 entries

/mnt/c/Users/jlperla/Documents/GitHub/lecture-source-jl/rst_files/lu_tricks.rst:879: WARNING: Include file '/mnt/c/Users/jlperla/Documents/GitHub/lecture-source-jl/rst_files/_static/code/lu_tricks/control_and_filter.jl' not found or reading it failed
looking for now-outdated files... none found
pickling environment... done
checking consistency... /mnt/c/Users/jlperla/Documents/GitHub/lecture-source-jl/rst_files/hist_dep_policies.rst: WARNING: document isn't included in any toctree
/mnt/c/Users/jlperla/Documents/GitHub/lecture-source-jl/rst_files/zreferences.rst: WARNING: Citation [Shiryaev1995] is not referenced.
done
preparing documents... done
writing output... [100%] zreferences
/mnt/c/Users/jlperla/Documents/GitHub/lecture-source-jl/rst_files/arma.rst:502: WARNING: undefined label: ar1_acov (if the link has no caption the label must precede a section header)
/mnt/c/Users/jlperla/Documents/GitHub/lecture-source-jl/rst_files/career.rst:277: WARNING: undefined label: beta-binom (if the link has no caption the label must precede a section header)
/mnt/c/Users/jlperla/Documents/GitHub/lecture-source-jl/rst_files/index.rst:: WARNING: Invalid jupyter kernels. jupyter_kernels: {'python3': {'kernelspec': {'display_name': 'Python', 'language': 'python3', 'name': 'python3'}, 'file_extension': '.py'}, 'julia': {'kernelspec': {'display_name': 'Julia 1.0.0', 'language': 'julia', 'name': 'julia-1.0'}, 'file_extension': '.jl'}}, lang: julia
/mnt/c/Users/jlperla/Documents/GitHub/lecture-source-jl/rst_files/index_postgrad.rst:: WARNING: Invalid jupyter kernels. jupyter_kernels: {'python3': {'kernelspec': {'display_name': 'Python', 'language': 'python3', 'name': 'python3'}, 'file_extension': '.py'}, 'julia': {'kernelspec': {'display_name': 'Julia 1.0.0', 'language': 'julia', 'name': 'julia-1.0'}, 'file_extension': '.jl'}}, lang: julia
/mnt/c/Users/jlperla/Documents/GitHub/lecture-source-jl/rst_files/index_undergrad.rst:: WARNING: Invalid jupyter kernels. jupyter_kernels: {'python3': {'kernelspec': {'display_name': 'Python', 'language': 'python3', 'name': 'python3'}, 'file_extension': '.py'}, 'julia': {'kernelspec': {'display_name': 'Julia 1.0.0', 'language': 'julia', 'name': 'julia-1.0'}, 'file_extension': '.jl'}}, lang: julia
/mnt/c/Users/jlperla/Documents/GitHub/lecture-source-jl/rst_files/linear_algebra.rst:488: WARNING: undefined label: la_3dvec (if the link has no caption the label must precede a section header)
/mnt/c/Users/jlperla/Documents/GitHub/lecture-source-jl/rst_files/linear_algebra.rst:988: WARNING: undefined label: la_3dvec (if the link has no caption the label must precede a section header)
/mnt/c/Users/jlperla/Documents/GitHub/lecture-source-jl/rst_files/odu.rst:601: WARNING: undefined label: odu_pol_vfi (if the link has no caption the label must precede a section header)
copying static files... done
build succeeded, 11 warnings.
bash -c "cp notebooks/*.toml _build/jupyter"

We want to make sure that each plot (and code block in general) has a corresponding test, of some arbitrary intermediate point. This is done in a lot of cases, but I don't think we have had a strict policy of doing it, so there are almost certainly some missing cases.

As discussed, this is another issue for one of the undergrad RAs. So Kaan Yolsever (@yolsever) will be handling this, and I'll be the go-between as in #67. For ease of maintenance, we can group this by section, and check off when each one is verified.

• Tools and Techniques
• Dynamic Programming
• Multiple-Agent Models
• Time Series Models
• Dynamic Programming Squared

cc: @jlperla, @Nosferican

Bug report from a student!

It appears that Distributions is now "broadcast friendly". We should look for uses of Ref with broadcasting with it (e.g. pdf.(Ref(d), [1.0, 3.0]) no longer requires the Ref) and remove it. This might be a good time to review all uses of Ref( in the notes, since others might have changed.

• Can we put our Manifest.toml and Project.toml into a package and easily instantiate and download it?
• Can this handle versioning well?
• What folder do we instantiate in?

@Nosferican : Can you tell us what you tried for the unicode in plotting labels, etc.? or directly add a test to https://github.com/QuantEcon/lecture-source-jl/blob/master/unicode.jl

Then we can run it in different OSs to see if they are in fact valid. The GR maintainer told me that unicode support is very spotty due to the all the backends.
cc: @arnavs

See https://github.com/QuantEcon/lecture-source-jl/blob/master/style.md#naming-conventions-comments-etc

In particular, getting rid of the following pattern

 # == Some comment == #

Active template for checklists:

Getting Started with Julia

• Setting up your Julia Environment
• An Introductory Example
• Julia Essentials and more material
• Fundamental Types with more material
• Introduction to Types and Generic Programming

More Programming and Software Engineering Principles

• Generic Programming
• The Need for Speed
• Plotting in Julia
• Useful Libraries

Tools and Techniques

• Linear Algebra
• Orthogonal Projections and their Applications
• LLN and CLT
• Linear State-Space Models
• Finite Markov Chains
• Continuous State Markov Chains
• A First Look at the Kalman Filter

Dynamic Programming

• Shortest Paths
• Job Search I: The McCall Search Model
• Job Search II: Search and Separation
• A Problem that Stumped Milton Friedman
• Job Search III: Search with Learning
• Job Search IV: Modeling Career Choice
• Job Search V: On-the-Job Search
• Optimal Growth I: The Stochastic Optimal Growth Model
• Optimal Growth II: Time Iteration
• Optimal Growth III: The Endogenous Grid Method
• LQ Dynamic Programming Problems
• Optimal Savings I: The Permanent Income Model
• Optimal Savings II: LQ Techniques
• Consumption and Tax Smoothing with Complete and Incomplete Markets
• Optimal Savings III: Occasionally Binding Constraints
• Robustness
• Discrete State Dynamic Programming

Multiple Agent Models

• Schelling's Segregation Model
• A Lake Model of Employment and Unemployment
• Rational Expectations Equilibrium
• Markov Perfect Equilibrium
• Asset Pricing I: Finite State Models
• Asset Pricing II: The Lucas Asset Pricing Model
• Asset Pricing III: Incomplete Markets
• Uncertainty Traps
• The Aiyagari Model
• Default Risk and Income Fluctuations
• Globalization and Cycles

Time Series Models

• Covariance Stationary Processes
• Estimation of Spectra
• Additive Functionals
• Multiplicative Functionals
• Classical Control with Linear Algebra
• Classical Filtering with Linear Algebra

Dynamic Programming Squared

• Dynamic Stackelberg Problems
• Optimal Taxation in an LQ Economy
• Optimal Taxation with State-Contingent Debt
• Optimal Taxation without State-Contingent Debt

We want the ability to generate the executed notebooks. This can be run as a separate step after Jupinx.

First, lets add in a notebooks directory right under the lecture-source-jl root, and add in a .gitignore with .ipynb_checkpoints to be skipped. This is where we will add in the Project.toml and Manifest.toml at some point as well.

First, lets have it as taking a given filename and it would just copy the file to the correct location. e.g.
executenotebook mynotebook.ipynb, which would be done inside of where you run the make jupyter command. It could then do something like

cp ./_build/jupyter/mynotebook.ipynb    ./notebooks/mynotebook.ipynb
jupyter nbconvert --ExecutePreprocessor.timeout=600 --to notebook --execute ./notebooks/mynotebook.ipynb

Play around with the settings to make sure it knows it can replace the existing one.

We can then get into the habit of calling executenotebook mynotebook.ipynb whenever we modify things.

Currently, we have a few issues with the Jupinx build on the source reStructured Text:

• A few files are referring to nonexistent code blocks.
• There is some (stochastic) issue with the use of the * symbol inside code. I couldn't replicate it, but @Nosferican and @jlperla could.
• \Span \col \RR and other improperly parsed issues (see orth_proj.ipynb).

And likely a few others. We can close this when we're satisfied with the output Jupyter.

Look through all files globally.

Similar to the lecture_howto_jl.raw, the set up is repeated across each lecture. I think it would be a good candidate for a static file.

This goal is to get all the lectures to a state where they run in Julia 1.0. This is distinct from making the code more "Julian," clean, suitable for teaching, etc.

Deprecation Tracker

We can check off each lecture when complete. Currently, @Nosferican and I have our notes in this Google doc.

Programming in Julia

• Setting up your Julia Environment
• An Introductory Example (#26)
• Julia Essentials (#27)
• Vectors, Arrays, and Matrices (#28)
• Types, Methods, and Dispatch (#29)
• The Need for Speed (#30)
• Plotting in Julia
• Useful Libraries (#31)

Tools and Techniques

• Linear Algebra (#32)
• Orthogonal Projections and their Applications (#33)
• LLN and CLT (#34)
• Linear State-Space Models (#35)
• Finite Markov Chains (#36)
• Continuous State Markov Chains (#37)
• A First Look at the Kalman Filter (#38)

Dynamic Programming

• Shortest Paths
• Job Search I: The McCall Search Model (#58)
• Job Search II: Search and Separation (#59)
• A Problem that Stumped Milton Friedman (#60)
• Job Search III: Search with Learning (#61)
• Job Search IV: Modeling Career Choice (#63)
• Job Search V: On-the-Job Search (#64)
• Optimal Growth I: The Stochastic Optimal Growth Model (#65)
• Optimal Growth II: Time Iteration (#66)
• Optimal Growth III: The Endogenous Grid Method (#68)
• LQ Dynamic Programming Problems (#69)
• Optimal Savings I: The Permanent Income Model (#71)
• Optimal Savings II: LQ Techniques . (#72)
• Consumption and Tax Smoothing with Complete and Incomplete Markets (#73)
• Optimal Savings III: Occasionally Binding Constraints (#75)
• Robustness (#77)
• Discrete State Dynamic Programming (#74)

Multiple Agent Models

• Schelling's Segregation Model (#78)
• A Lake Model of Employment and Unemployment (#79)
• Rational Expectations Equilibrium (#80)
• Markov Perfect Equilibrium (#81)
• Asset Pricing I: Finite State Models (#42)
• Asset Pricing II: The Lucas Asset Pricing Model (#43)
• Asset Pricing III: Incomplete Markets (#44)
• Uncertainty Traps (#53)
• The Aiyagari Model (#83)
• Default Risk and Income Fluctuations (#85)
• Globalization and Cycles (#86)

Time Series Models

• Covariance Stationary Processes (#87)
• Estimation of Spectra (#88)
• Additive Functionals (#89)
• Multiplicative Functionals (#90)
• Classical Control with Linear Algebra (#91)
• Classical Filtering with Linear Algebra (#92)

Dynamic Programming Squared

• Dynamic Stackelberg Problems (#93)
• Optimal Taxation in an LQ Economy (#94)
• Optimal Taxation with State-Contingent Debt (#96)
• Optimal Taxation without State-Contingent Debt (#159)

This is a meta-issue focused on enumerating the global stylistic changes to the lectures. As before, we can check off each seciton when we are complete.

• Remove docstrings
• Convert to using Parameters and unpack throughout and all default constructors to @with_kw #135
• Replacing homebrewed quadrature with Expectations.jl #133
• Replacing homebrewed iteration and EQ ones with with fixedpoint() #134
• Eliminating repeatedly nested loops (like in the career and job choice lecture).
• Using Plots/GR globally #67
• Convert to Maximize and simplify sign flips #158
• Convert to using Parameters and unpack throughout #135
• Use interpolations #146
• Global removal of virtually all type signatures

For all of

• Getting Started
• Julia Essentials
• Funamental types

and, maybe,

• Julia By Example

Look for the section of the julia doc which covers each topic and link to it.

After @Nosferican finishes JuliaLang/Compat.jl#631 we can search for all ranges and use the newer syntax

Wherever possible, replace homebrewed fixed-point iteration with the fixedpoint() routine from NLsolve.jl. Need to make sure the math checks out. This could cause tests of exact equality to fail; will need to be updated.

I'm finding some issue with specialized types in the LinearAlgebra module. See below for a MWE. The issue is that, because these don't subtype Matrix as some external libraries (like PyPlot) expect, methods defined on matrices don't seem to work.

Let me know how we should proceed.

julia> x = [0 1; 1 0]
2×2 Array{Int64,2}:
 0  1
 1  0

julia> transpose(x)
2×2 Transpose{Int64,Array{Int64,2}}:
 0  1
 1  0

julia> transpose(x) isa Matrix
false

julia> typeof(x')
Adjoint{Int64,Array{Int64,2}}

julia> x' isa Matrix
false

julia> versioninfo()
Julia Version 1.0.0
Commit 5d4eaca0c9 (2018-08-08 20:58 UTC)
Platform Info:
  OS: macOS (x86_64-apple-darwin14.5.0)
  CPU: Intel(R) Core(TM) i7-6700HQ CPU @ 2.60GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-6.0.0 (ORCJIT, skylake)

We should make sure that (a) code that's directly implementing math is commented with an equation number and (b) as a corollary, all significant equations are numbered. Example of a lecture with non-numbered equations is Wald-Friedman.

Lets modify the current file https://github.com/QuantEcon/lecture-source-jl/blob/master/execute-notebooks.sh

Or perhaps rename it to execute-notebook.sh and have a new one execute-notebooks.sh which will call it.

The basic goal of this is to run all of the notebooks in the _build/jupyter directory and put them in the /notebooks directory. But we only really need to run the nbconvert if the _build/jupyter/MYFILE.ipynb has been modified since the last time the script was executed.

A suggested approach:

• Consider modifying the https://github.com/QuantEcon/lecture-source-jl/blob/master/execute-notebooks.sh script so that it takes a relative path to the file instead of putting in the /_build/jupyter on its own. Test to see if it is better, but, for example, changing the line to:

\cp $1 ./notebooks/$1 # Move first argument to the right folder. Will overwrite. 

• At the beginning of running the script, if there is a ./notebooks/timestamp.txt or whatever file, then load the timestamp.
• If no timestamp is there, then the assumption will be that things have never been run... maybe set the timestamp to 0 or something so that filtering is easy.
• Get a list of all ./_build/jupyter/*.ipynb with the timestamp
• Filter out from that list of files anything where the timestamp is < the stored timestamp... and if there is no timestamp loaded, then don't filter.
• Replace or save the current timestamp in ./notebooks/timestamp.txt
• Run the modified https://github.com/QuantEcon/lecture-source-jl/blob/master/execute-notebook.sh script on each of the filtered list of files.

Then when you put this in git, make sure to ignore the timestamp files and any intermediate files you create in the process.

Optim.jl now supports the univariate maximize function instead of just optimize

We should find all of the places that use optimize and convert to maximize if that is the math implementation. Of course, since this si a move from minimize to maximize, this means swapping the sign of the objective that is passed in as well not swapping the sign of the output

Also, look for http://quantecon.github.io/QuantEcon.jl/latest/api/QuantEcon.html#QuantEcon.golden_method-Tuple{Function,Real,Real} and swap that out as well.

Every plot should use the Plots.jl API with the GR backend. In case of a plot not being able to be generated with the Plots API (bring the special case to attention for discussion).

• Job Search IV: Modeling Career Choice
• Optimal Growth I: The Stochastic Optimal Growth Model (#84)
• Optimal Growth III: The Endogenous Grid Method (#95)
• Optimal Savings II: LQ Techniques (#104)
• Consumption and Tax Smoothing with Complete and Incomplete Markets (#97)
• A Lake Model of Employment and Unemployment (#103)
• Rational Expectations Equilibrium
• Markov Perfect Equilibrium (#102)
• Uncertainty Traps
• Default Risk and Income Fluctuations (Gadfly|priority)
• Globalization and Cycles
• Covariance Stationary Processes (#126)
• Estimation of Spectra
• Additive Functionals
• Multiplicative Functionals
• Classical Control with Linear Algebra (#122)
• Optimal Taxation in an LQ Economy (#120)
• Optimal Taxation with State-Contingent Debt
• [Lucas Model] #163
• [Optimal Growth II: Time Iteration]

Add the following at the top of every lecture with code, in a separate cell right above the first set of code.

using Pkg
Pkg.activate(@__DIR__);

Change everything to use Interpolations.jl and remove references to the QuantEcon

Right now a lot of the plots are along the lines of

plot(x, color = "blue")

Is the color = "blue" really necessary, and is there a better way to make a global setting change right below where the using Plots; gr(...) is used? If so, lets get rid of them globally.

Wherever possible, replace structs that we're using as parameter containers with NamedTuples (and the related constructors) from Parameters.jl. This issue binds to a large number of lectures, and involves a significant refactoring.

Active template for checklists:

Getting Started with Julia

• Setting up your Julia Environment
• An Introductory Example
• Julia Essentials and more material
• Fundamental Types with more material
• Introduction to Types and Generic Programming

More Programming and Software Engineering Principles

• Generic Programming
• The Need for Speed
• Plotting in Julia
• Useful Libraries

Tools and Techniques

• Linear Algebra
• Orthogonal Projections and their Applications
• LLN and CLT
• Linear State-Space Models
• Finite Markov Chains
• Continuous State Markov Chains
• A First Look at the Kalman Filter

Dynamic Programming

• Shortest Paths
• Job Search I: The McCall Search Model
• Job Search II: Search and Separation
• A Problem that Stumped Milton Friedman
• Job Search III: Search with Learning
• Job Search IV: Modeling Career Choice
• Job Search V: On-the-Job Search
• Optimal Growth I: The Stochastic Optimal Growth Model
• Optimal Growth II: Time Iteration
• Optimal Growth III: The Endogenous Grid Method
• LQ Dynamic Programming Problems
• Optimal Savings I: The Permanent Income Model
• Optimal Savings II: LQ Techniques
• Consumption and Tax Smoothing with Complete and Incomplete Markets
• Optimal Savings III: Occasionally Binding Constraints
• Robustness
• Discrete State Dynamic Programming

Multiple Agent Models

• Schelling's Segregation Model
• A Lake Model of Employment and Unemployment
• Rational Expectations Equilibrium
• Markov Perfect Equilibrium
• Asset Pricing I: Finite State Models
• Asset Pricing II: The Lucas Asset Pricing Model
• Asset Pricing III: Incomplete Markets
• Uncertainty Traps
• The Aiyagari Model
• Default Risk and Income Fluctuations
• Globalization and Cycles

Time Series Models

• Covariance Stationary Processes
• Estimation of Spectra
• Additive Functionals
• Multiplicative Functionals
• Classical Control with Linear Algebra
• Classical Filtering with Linear Algebra

Dynamic Programming Squared

• Dynamic Stackelberg Problems
• Optimal Taxation in an LQ Economy
• Optimal Taxation with State-Contingent Debt
• Optimal Taxation without State-Contingent Debt

For a given lecture, in between the undeprecation and the rewriting/refactoring, we want to insert regression tests to ensure that the output does not change.

Guidelines

Some thoughts, based on discussions with @jlperla:

• When testing arrays, try not to test the bounds, but rather some arbitrary interior value.
• In general, try to test values that depend on many other values, since it's unlikely that errors in those components will exactly cancel. Something like a checksum.
• We should put these tests in their own blocks with a special comment (# jl-test, I believe), so that we can later efficiently delete all blocks that contain that comment. See README for this now.
• For plots, the testing procedure is still TBD. Perhaps we can eyeball it, or maybe serialize the plot object and save it. Not sure what a good approach is here. See Jesse's comment below for how to handle this.

Tracker

Programming in Julia

• Setting up your Julia Environment
• An Introductory Example
• Julia Essentials
• Vectors, Arrays, and Matrices
• Types, Methods, and Dispatch
• The Need for Speed
• Plotting in Julia
• Useful Libraries

Tools and Techniques

• Linear Algebra
• Orthogonal Projections and their Applications (#46)
• LLN and CLT (#47)
• Linear State-Space Models (#48)
• Finite Markov Chains (#49)
• Continuous State Markov Chains (#50)
• A First Look at the Kalman Filter (#51)

Dynamic Programming

• Shortest Paths
• Job Search I: The McCall Search Model (#55)
• Job Search II: Search and Separation (#56)
• A Problem that Stumped Milton Friedman (#57)
• Job Search III: Search with Learning (#61)
• Job Search IV: Modeling Career Choice (#63)
• Job Search V: On-the-Job Search (#64)
• Optimal Growth I: The Stochastic Optimal Growth Model (#65)
• Optimal Growth II: Time Iteration (#66)
• Optimal Growth III: The Endogenous Grid Method (#68)
• LQ Dynamic Programming Problems (#69)
• Optimal Savings I: The Permanent Income Model (#71)
• Optimal Savings II: LQ Techniques (#72)
• Consumption and Tax Smoothing with Complete and Incomplete Markets (#73)
• Optimal Savings III: Occasionally Binding Constraints (#75)
• Robustness
• Discrete State Dynamic Programming

Multiple Agent Models

• Schelling's Segregation Model
• A Lake Model of Employment and Unemployment (#79)
• Rational Expectations Equilibrium
• Markov Perfect Equilibrium (#105)
• Asset Pricing I: Finite State Models (#106)
• Asset Pricing II: The Lucas Asset Pricing Model (#107)
• Asset Pricing III: Incomplete Markets (#108)
• Uncertainty Traps (#82)
• The Aiyagari Model (#83)
• Default Risk and Income Fluctuations (#109)
• Globalization and Cycles (#110)

Time Series Models

• Covariance Stationary Processes (#101)
• Estimation of Spectra (#111)
• Additive Functionals (#112)
• Multiplicative Functionals (#113)
• Classical Control with Linear Algebra (#114)
• Classical Filtering with Linear Algebra (#115)

Dynamic Programming Squared

• Dynamic Stackelberg Problems (#116)
• Optimal Taxation in an LQ Economy (#117)
• Optimal Taxation with State-Contingent Debt (#118)
• Optimal Taxation without State-Contingent Debt

Generate the notebooks, execute them all with the script, and then look for repetive images.

Some of the static assets could really be reorganized and removed, where executed figures are preferred.