text: This paper extends an existing thread of neural computation research focused on learning resuable subprocedures (or options in RL-speak).   Instead of simply input and output examples, as in most of the work in neural computation, they follow in the vein of the Neural Programmer-Interpreter (Reed and de Freitas, 2016) and Li et. al., 2017,  where the supervision contains the full sequence of elementary actions in the domain for all samples, and some samples also contain the hierarchy of subprocedure calls. The main focus of their work is learning from fewer fully annotated samples than prior work.   They introduce two new ideas in order to enable this: 1.  They limit the memory state of each level in the program heirarchy to simply a counter indicating the number of elementary actions/subprocedure calls taken so far (rather than a full RNN embedded hidden/cell state as in prior work).   They also limit the subprocedures such that they do not accept any arguments. 2.  By considering this very limited set of possible hidden states, they can compute the gradients using a dynamic program that seems to be more accurate than the approximate dynamic program used in Li et. al., 2017.   The main limitation of the work is this extremely limited memory state, and the lack of arguments.   Without arguments, everything that parameterizes the subprocedures must be in the visible world state.   In both of their domains, this is true,  but this places a significant limitation on the algorithms which can be modeled with this technique.   Furthermore, the limited memory state means that the only way a subprocedure can remember anything about the current observation is to call a different subprocedure.   Again, their two evalation tasks fit into this paradigm,  but this places very significant limitations on the set of applicable domains.   I would have like to see more discussion on how constraining these limitations would be in practice.   For example, it seems it would be impossible for this architecture to perform the Nanocraft task if the parameters of the task (width, height, etc.) were only provided in the first observation, rather than every observation.   None-the-less I think this work is an important step in our understanding of the learning dynamics for neural programs.   In particular, while the RNN hidden state memory used by the prior work enables the learning of more complicted programs *in theory*, this has not been shown in practice.  So, it's possible that all the prior work is doing is learning to approixmate a much simpler architecture of this form.   Specifically, I think this work can act as a great base-line by forcing future work to focus on domains which cannot be easily solved by a simpler architecture of this form.   This limitation will also force the community to think about which tasks require a more complicated form of memory, and which can be solved with a very simple memory of this form. I also have the following additional concerns about the paper: 1.  I found the current explanation of the algorithm to be very difficult to understand.   It's extremely difficult to understand the core method without reading the appendix,  and even with the appendix I found the explanation of the level-by-level decomposition to be too terse. 2.  It's not clear how their gradient approximation compares to the technique used by Li et. al.   They obviously get better results on the addition and Nanocraft domains,  but I would have liked a more clear explanation and/or some experiments providing insights into what enables these improvements (or at least an admission by the authors that they don't really understand what enabled the performance improvements).