One of the big problems is that there is such a huge range of ability for people who are otherwise, say, in the entering freshman class. A quarter of a century ago (that makes me feel old!) one of the ways which MIT solved the problem was by using Scheme in the intro to CS class. The first lecture was all about abstractions and lambda's, and nothing about Lisp/Scheme syntax --- and the first problem set asked you to code in Scheme. You were expected to figure it all out from the language reference manual.
That was a pretty big leveler back then, because most students, even those who had used a lot of computers in grade school and elementary school, were mostly exposed to Apple II's and TRS-80's and Microsoft Basic. Lisp would have been new to most students. (I had learned PDP-8 assembler around age 7 or 8, and FOCAL a few years earlier, and later some Pascal and C code, and Z80 assembler, but Lisp was pretty new to me.)
These days, it's a lot harder. I suppose the rough equivalent would be handing freshmen a problem set using ML. But I'm not sure Universities could get away with that today. Back then, we had too many people trying to get into computer science, so handing out a problem set w/o any prior instruction and expecting you to learn a new language from the reference manual was part of the filtering process so we wouldn't have too many people trying to become CS majors....
The idea of having a levelling language as the first thing you do in computer science really attracts me.
One of the big turnoffs is the know-it-alls in early CS courses. Having a language like Scheme or ML or Haskell whack them on their butt - just like everyone else would provide a certain democracy to the pain.
I'm pretty sure I was one of those jackasses back then. ML would have handed me back my head on a copper platter, and I would have really learned higher level computer science a lot earlier.
Having taken the classic MIT 6.001 scheme course, the choice of language didn't really level things out. There was still a big difference between people who came in with years of exposure to code and people who didn't.
Even though many of the topics were new to everybody, the experienced people had a better context to understand why each topic was interesting and useful. That kind of intrinsic motivation makes any kind of learning easier.
I had written lots of terrible programs already, so for me the course was a series of Aha! moments. People without that experience seemed to have a harder time with "What's the point of this?".
It makes me wonder if one couldn't design a curriculum that's deliberately designed to get people writing terrible programs first, in order to motivate the techniques for avoiding those problems.
Haha! Well, at Penn one of our intro courses is in OCaml, which is a fantastic leveling language. I felt like I was programming for the firs time... which, actually, was awesome! I know a lot of my classmates felt like they could skip the course, but I really enjoyed it and I really enjoyed learning to think in a new way.
I can assure you that scheme or haskell isn't a leveler :-), there'll still be folks who taught themselves scheme and haskell and a dash of pl theory / general cs during high school self directed. That is all :-)
(personally know a number of such folks, and they're some of the most amazingly nice & open folks I know)
I experienced both sides of that filtering by major. I took 6.001 and 18.001 freshman year. Scheme was great. However the first problem set for 18.001 convinced me being a math major was dumb. Why do rote proofs like A*0=0 for all A? I am always grateful I later took Arthur Mattuck's 18.100 which gave access to that mindset for people who didn't have it naturally. I am also grateful that I quickly learned what I truly enjoyed rather than having a long drawn out process to realize it.
Penn's second intro class is indeed in OCaml, mostly due to the effect it has of leveling the playing field. It really turned out quite well, and most of the students enjoy it.
Well, most students these days still would not have been exposed to lambda calculus in high school: I'd wager that most students who played with Lisp/Scheme in high school wrote imperative code (taking advantage of mutable cons cells and loop/do macros). Indeed, the very website we're conversing on is written in imperative-style Lisp.
So no, I don't think that students with prior programming experience are significantly better prepared for tail recursion, Y-combinators, and purely functional data structures upon entering a CS program.
My theory is that it no longer levels the playing as other effects have crept up: the "technically entitled" student today mostly visible has an edge over a highly talented but (not _yet_) experienced student stemming from a strong knowledge of UNIX (thanks to Linux and OS X) and other development tools. In the 1980s/early 90s, learning a new environment (UNIX, VMS, TOPS-20, ITS) and new tools (vi, emacs, make) would have leveled the field for all students.
While an anecdote doesn't prove this theory, a friend told me how she took $AnotherPrestigiousUniversity's[1] equivalent of 6.001. She had no prior programming experience (at all) and got an A (not easy, as the average GPA in that university's CS department was significantly below 3.0). Nonetheless she did not consider switching to a CS major. The environment played a role: she specifically called out the attitude students with prior UNIX experience had towards those without it. She also felt that much of the knowledge gained in that class wasn't applicable to real-world software development or to her natural sciences major.
Personally if I don't think switching to ML or even Haskell would mean students dropping out of CS: CMU uses SML for CS majors, my alma mater (a good, but not a top-15 CS/Engineering school) used Haskell once and now uses SML, as do many other schools. However, I don't think teaching typed lambda calculus would ameliorate technical entitlement any more than teaching untyped lambda calculus does.
A greater equalizer would be to require students to use more of their EE, Math, and hard sciences knowledge in their programming courses: I've noted that EECS/CSE majors tend to be more diverse than the CS majors due to "a fancy .vimrc won't help you pass diff-eqs" effect. However, it may have the adverse effects of also repelling less mathematically inclined CS majors (whether technically entitled or not).
I started out as an incredibly technically entitled student. I was able to use that to convince a university to admit me despite modest high school grades (by attending a community college college for a year and writing a personal statement about a programming internship I had in HS as part of the transfer application). What humbled me were upper division CS courses and realizing that I could learn a tremendous deal from people who (oh, the horror!) used pine instead of mutt. It turns out knowing UNIX minutia was not in itself terribly relevant for long term career success...
I still think I benefited greatly from pre-university hacking, but when I took a graduate machine learning course, I couldn't help but think "what if I spent the time to grok integration by parts in my HS calculus class instead of day dreaming about how I'll reconfigure my X11 window manager?" Perhaps that's why there's far less technical arrogance in the industry vs. academia: may be the students who retain that arrogance convince themselves that there's nothing they can learn from others and graduate with less qualifications that their peers?
[1] Obscuring details as not to discourage any students from applying to this university. Today's situation may be radically different from ~2002-2004 timeframe.
That was a pretty big leveler back then, because most students, even those who had used a lot of computers in grade school and elementary school, were mostly exposed to Apple II's and TRS-80's and Microsoft Basic. Lisp would have been new to most students. (I had learned PDP-8 assembler around age 7 or 8, and FOCAL a few years earlier, and later some Pascal and C code, and Z80 assembler, but Lisp was pretty new to me.)
These days, it's a lot harder. I suppose the rough equivalent would be handing freshmen a problem set using ML. But I'm not sure Universities could get away with that today. Back then, we had too many people trying to get into computer science, so handing out a problem set w/o any prior instruction and expecting you to learn a new language from the reference manual was part of the filtering process so we wouldn't have too many people trying to become CS majors....