What is the CS Analog To Learning One's Multiplication Tables? I apologize; I know this question is sort of open-ended and if I could think of a way to make it more specific, I would.

What would you consider a piece of CS so fundamental that it would be analogous to an elementary student learning his/her multiplication tables?  

I think maybe looping code, maybe data types, and/or conditional statements.  I'm looking for pointers to any scientific literature on this topic and any input anyone cares to share.   

What are the absolute fundamentals that every developer must master regardless of paradigm (OOP, FP etc) or language? 

Feel free to close this if it's too broad but if you do vote to close please suggest how I can narrow the question as well.
"Analogous" could mean different things, depending on which analogy you choose to make. To me, the key thing about learning multiplication tables is that you are memorising the answers to some simple questions which will appear as subproblems to many other things you have to do; so that you don't have to derive the answers again each time those subproblems occur. @Buffy's answer describes some of the fundamental abstract concepts which programmers certainly need a solid understanding of, but I would not count things like "sequence" and "alternation" as problems for which we apply solutions from memory; so I infer that @Buffy sees a different analogy to the one I do.

For the analogy as I see it, there are some commonly-occurring subproblems in imperative programming which we do use memorised solutions to. I would think of @Buffy's fundamental ideas as analogous to the ability to do multiplication, and the understanding of when/why to multiply; they should be learned before it makes sense to memorise the answers to multiplication questions. Likewise, understanding what sequential, conditional and iterative statements are and when/why to use them in a program should precede memorising how to apply them to solve particular problems.

To give some idea of the kind of subproblems and memorised-solutions I mean, the below list is not at all complete, but should help to illustrate by example:


Q: How to iterate over just some elements of a collection? A: Write a loop over the collection, and an if statement inside the loop to "filter" for just the elements you want to iterate over. The code for processing each element should go inside the if statement.
Q: How to find the sum of a collection of numbers? A: Initialise a variable sum = 0, and use a loop to do sum += x for each x from the collection.
Q: How to count the number of occurrences of something in a collection? A: Initialise a variable count = 0, and write count += 1 each time that thing is detected to have occurred.
Q: How to find the "best" (maximum, minimum, etc.) thing in a collection? A: Initialise a variable best to be the first thing from the collection, and write a loop over the remaining elements. Each time a new element x is observed, check if x is "better" than the current best, and if it is, update best = x.


These memorised solutions to commonly-occurring subproblems are closely related to the ideas of "roles of variables" as described by Sajaniemi and "plans" as described by Soloway &amp; Ehrlich; I use the word "plans" to describe them. I'm not aware of any comprehensive list of them; I was able to think of some, which I've written about in Python and used for teaching undergraduate students (with limited success - perhaps we didn't spend long enough for the students to memorise the plans by repeated practice). I have written a similar document for Java which I don't have to hand immediately, but I can post it later if there is interest.