The point is that the later courses in CS curriculum depend much more on a good understanding of the imperative model and the issues that first arose in programming early Von Neumann computers, than they depend on understanding functional programming. Undergraduate algorithm classes are exclusively concerned with developing imperative algorithms. Large part of understanding operating systems is understanding how they handle memory management and that there is a need for it in the first place. Computer architecture and compiler courses are concerned with speeding up imperative programs. Even theory of computation courses spend more time exploring Von Neumann - like models than lambda calculus. You could redesign the whole curriculum of course, but then we don't happen to have computers that could more directly and efficiently execute functional programs, so I doubt this is a good idea.
That may be true, but it will not be until you descend the stack you start to code like someone who understands what they are doing. For instance I started off with PHP in high school and was using arrays with each entry as a string with a colin in it to split a key and value apart. So essentially I created the worlds worst hashmap and each lookup was O(N) - not to mention the actual string splitting I was doing on each element which would've most likely caused several memory copies.
Why not at least start with some basics at the bottom of the stack and ascend quickly? As Dijkstra mentions he believes a lot of people have had at least small exposure to programming prior to their tertiary education - hence they probably already started at some point in the stack anyhow.
What's the bottom? You clearly have something in mind, but why not starting with logic gates and work up to assembly? That is also a valid approach, and it works up to what you consider the bottom of the stack.
I do computer systems research. I am a big proponent of knowing how computer systems work. But I think people have an unhealthy fetish for how we start learning. You start once. You learn the rest of your life. Where you start is not the most important thing.
Bah. The bottom of the stack is quantum mechanics and solid state physics. From there, you learn how individual transistors work. From that, you build up to logic gates.
I actually know something about those levels. But in 25 years as a professional programmer, the lowest level I've ever actually needed to use was at the gate level (PAL equations to generate chip selects by decoding addresses - if it wasn't in a PAL, it would be just equations).
But many don't do this. Only true artisans due. I did not have this opportunity in college to be taught other way.
I stayed a language major. In hindsight, I would have changed majors, at least double-majored with this kind of curriculum and a few years later with my flirting with Linux. It would have shifted my curiosity in the right direction.
I can do basic Python and Perl programming (not to mention the terrible days of PHP and ColdFusion days in my student jobs), but even as an IT guy I routinely feel I never know enough.
And I am the only IT guy I know, not to program but just to understand, by the Sysinternals Windows Internals 900-pager to even try to get there. And that is just for Windows, which is not even worth it IMHO.
Pick a place in the stack. Start learning. Over time you should go up and down the stack, building understanding as you go.
This can be done from many places in the stack.