This is a seminal paper where Dijkstra introduces a concept which is almost hard to imagine programming without it: user level recursion implemented via a runtime stack. In other words: 1. Pushing a new element to the stack 2. Performing an arithmetic operation using the selected operator and the other top 2 elements in the stack. What Dijkstra is describing can be hard to imagine given present day programming languages: each subroutine in a program having its private fixed working space. In other words, each procedure you call from the main program has its own fixed region in memory which it can make use of. This immediately renders recursion impossible - since if a procedure calls itself multiple times it will trample over its own reserved memory space. **Edsger Wybe Dijkstra** (1930 - 2002) was one of the most influential computer scientists of the 20th century. He was born in Rotterdam, Netherlands and studied theoretical physics at Leiden University.  He is considered one of the most important members of computer science’s founding generation and influenced the disciplined from both an engineering and theoretical perspective.   The concept of a stack is key for understanding recursion. Dijkstra borrowed the concept of a *stack* from F. L. Bauer and K. Samuelson (two German computer pioneers), who came up with it while working on the fundamentals of mathematical notation and exploring the structure of algebraic expressions. General interest in formulating rules for well-formed algebraic expressions rose significantly with the introduction of parenthesis-free Polish notation by Jan Łukasiewicz in 1929. It's important to understand that this work was done in the context of Dijkstra implementing the first ALGOL 60 compiler. Writing compilers is also an example of a problem where recursion really is a very useful tool. `ALGOL 60` (short for **ALGO**rithmic **L**anguage 1960) was a programming language developed by researchers in the United States and Europe. It was used mostly in research (it lacked for instance native I/O facilities which made industry adoption harder). ALGOL heavily influenced many other languages and introduced a number of innovative concepts such as the ability of routines being able to call themselves recursively. Dijkstra essentially points out that if `C` (from the previous expression: $ A + (B - C) * (D/E + F)$) happened to be an expression - e.g. $C = (P/(Q-R + S \times T ))$ - instead of a numerical value in memory, by the time we are done evaluating `C`, the result will be the same as if `C` was, from the start, a value stored in memory. Heinz Rutishauser (1918 - 1970), was a Swiss mathematician and also a pioneer of early computer science. During part of World War II, Rutishauser was a Ph.D. student at ETH Zurich. From 1948 to 1949, Rutishauser was in the United States and visited computer pioneers Howard Aiken and Von Neumann in order to learn about the state of the art computing at the time. During his stay abroad, his boss Eduard Stiefel had managed to get a Zuse Z4 computer. Consequently, when he came back to ETH he found himself equipped with a powerful computing machine and knowledge of state of the art computing of the time. This led to seminal work by Rutishauser, which would eventually result in him being involved with the development of ALGOL. To illustrate the stack representation of the evaluation of the expression indicated by Dijkstra let's first consider its Reverse Polish Notation (aka Postfix Notation) representation: $$ A, B, C, -, D, E, /, F, +, \times, + $$ For the first few steps of the evaluation of this expression this is what the stack will look like: