Top down topics

Top down topics

Summary: what is actually the top-down approach ?

* providing an end-user software ?
    * packaging and distributing
    * consolidating the software stack (going the extra mile of engineering)
    * improving user-friendliness
    * improving robustness
    * improving efficiency by consolidating/specializing the stack
* when does it provides most added-value
    * maturity of the technology
    * performance gains
    * demand
* providing a modeling language ?
    * extend Dynare
    * extend DRIMS models (yaml files)
    * create a new language ?
* providing a GUI ?

Providing an end-user software

* For whom ?
    * students
        * learn to model ?
        * learn to program ?
    * researchers without coding skills
        * lower entry cost to modeling
    * researchers with coding skills
        * save time / hack
* Fill

When should one follow the Dynare approach ?

* Are perturbated models suitable candidates ?
    * conceptually relatively easy
    * generic algorithms are fast and robust (industry-grade)
    * quickly painful to write by hand
    * a whole DSGE literature relying on it
    * great learning tool
    * abstracting from the solution details when designing the model is nice

* Are nonlinear models suitable candidates ?
    * very standard theory (told in every graduate schools) but harder to grasp
    * many algorithms in the literature are hardly better than standard ones
    * many optimization tricks are not model-dependent
    * great learning tool
    * abstracting from the solution details when designing the model is nice
    * standard in many academic-level publications (sudden-stops, ZLB, )

* Are heterogeneous agents good candidates ?
    * theory is limited (ok without aggregate uncertainty, heuristics with A.U.),
      recent developments in Mean-Field Games
    * not many existing algorithms to choose from

* Are there other candidates ?
    * continuous time models (easy to add to the DRIMS classification)
    * markov-switching models (extensions to perturbations, included in DTMSCC)
    * perfect markov models (need derivatives in generalized Euler equations)
    * limited information
    * learning models
    * discrete choices

Extend Dynare

* already has a macroprocessor to construct large scale models with many agents
* currently no way to capture nondifferentiabilities
* some models can be reformulated in terms of smoothly fluctuating quantitites
* the language could be extended to describe heterogeneous agents models
  and solved with another algorithm

Sweet DRIMS, a common framework for many of these problems

* DRIMS: Dolo-Recs-International-Model-Standard

* Common description bricks: a specific type of model can be specified by
    * a list of symbols
    * a list of typed equations
    * a calibration
    * special objects
        * discrete markov chains
        * distributions
    * options

* Only a serialization language is required for that, not a full-fledged one
    * YAML, XML, JSON

* Common API bricks:
    * functions
    * dictionary (or vector) of calibration values
    * special classes
    * options structure

* A stable API is nice:
    * write it directly (with a Python class)
    * a model file for it and translate it to the API
    * develop completely new methods on it or use existing ones

* Common programming bricks
    * leverage dynamic programming languages
    * syntaxic checks
    * a compiler equations->functions

* Challenges
    * find the right level of generality
        * track distribution or individuals
        * evolution of population (death, entry/exit, etc.)
    * keep a tractable structure
    * express approximation / bounded rationality condition

Maybe it's a GUI that we really want ?

* Nice way to specify user's set of actions
* Really independent from the underlying code
* Very efficient for specialized applications
* Modular, larger GUIs are harder to design correctly
* Many different ways to design a GUI (editor extension,
    standalone application, widget in Jupyter, webapp)

There is no such thing as a Top Down approach we want seamless transitions !

* powerful language
* + well-designed api at all levels
* + modular design
* + lots of feedback
* -> seamless transitions for everyone !