Some new features like deferred type errors and type holes are going to really help with this. Especially once editors start taking full advantage of this. I think that this is the future of programming: not writing a program and then debugging it, and not even just working in a repl, but being actively guided by your tools seamlessly as you write your code. Having a dialog with the compiler.
Not to mention the traditional argument for lisp as a teaching language: the extremely simple syntax. For somebody who hasn't seen code before, lisp would look just as weird as any other language, so the unfamiliarity argument doesn't hold much water. Prefix notation isn't at all difficult to learn, (+ 1 2) would be just as weird as dividing using / or multiplying with *, and using % for modulo division. You just tell the students that this is how you write math with a keyboard(a white lie at worst:).
I'm currently working on a "try ruby" like tutorial to interactively teach FP using racket to college students, as my last year project.
Sure. But it is a slower feedback cycle then a good IDE (which tells you what it is expecting as you type it). Also, the same can be said about an interpreter: you can try things, and when they fail, it lets you know what it was expecting.
After a certain point in your progression, you realize that you can make certain type errors deliberately so that the type checker will tell you what types it's expecting. This is when it all clicks! The type checker is a tool that lets you query for information about your program. It's an immense aid to reasoning and a powerful sanity check against your assumptions. This is a capability that less strictly/statically typed languages lack and it can lead to a lot of surprises and guesswork.