Hell, I'm curious why Pascal
I fully understand that it raises eyebrows. Hell, I myself would ridicule that statement ~17 yrs ago, when I was becoming a C++ neophyte after migrating from Pascal. For a few years I even believed that the Python was the way to teach programming, but the experience with teaching college students disabused me of this idea. Not to dickwag, but after having hundreds (maybe more than a thousand?) of hours in instruction experience on various levels of proficiency and various demographics I came to realization that it's either Pascal or C. I'll also try to address why I think LISP-like languages are not suitable.
First of all, I need to touch on the weaknesses of Python for the task at hand. Incidentally, these weaknesses are often praised as features that would
actually help develop good practices: low visibility of control flow. To elaborate: separating statements by newline instead of a clear marker like a semicolon; blocking of code via indentation (*); no dedicated entry function like
main() in C-like languages; dynamic typing on which I've already written a few screeds. Probably a few more, but these are the ones I got on top of my head.
Now let's compare some contenders with very visible flow control: C, C++, Java, Pascal. I throw away Java in an instant due to not liking teaching by handwaving away
public static void main extends fuckery implements wtf keyword fiesta. Obviously with every language I need to introduce some keywords, but Java is so over the top and I need to handwave classes and so much stuff till unspecified "later" that I'd rather just devolve into C or "simplified" C++ (I'll elaborate on that). So there's no real point in Java.
Now let's look at Pascal vs C. I think the first one is slightly easier to grasp due to verbose keywords like
begin and
end to enclose code blocks, explicit declarations of
procedure and
function, explicit
var declaration blocks and so on. These faculties are highly irritating due to verbosity if one already grasps the terseness of syntax in C, I literally cannot stand reading these keywords. It actually slows down my reading and understanding of the code! But at the same time, I consider it useful for the purpose of learning. I think seeing these words over and over again will burn out the lingo in the brain, which is in many levels useful - you recognize the wording in books, you know how to ask google for help etc.
On top of that, Pascal is a lot stricter with basic numeric types and, in my opinion, has better arithmetic operators. You have `div` for integer division and `/` for real number division. As far as I remember, Pascal's compiler won't allow you to use `/` if the values being divided aren't real numbers! For modulo arithmetic you have `mod` instead of the ugly C-like `%`. For assignments you have `:=` instead of `=` (this one is used for comparisons, like
God Dijkstra intended). There's kind of a big deal here, because in mathematics `=` describes a property, a constant, an equation, not a change. I've seen people having some mental block with that part of C. There's no `++` and `--`.
Pascal is a lot more strongly-typed than C. The compiler won't allow you to do many of the stupid things which are perfectly valid syntactically and semantically in C, but are not "what programmer meant" and sometimes outright undefined.
For this reason, if it's up to me to actually teach someone programming, I do a C/C++ hybrid. I basically take C++ compiler and write C code in it, with the exception of using iostream instead of stdio and sometimes using strings instead of const char*. Now don't get me wrong here, iostream is cancer, but at least in remission, yet stdio will cause brain damage and then also cancer upon the programmer and his whole family. C++ is much more strongly-typed than C and has very ugly casting operators, which should actually discourage (ab)using them.
TL;DR - if you were to go on a remote island without internet and wanted to teach yourself programming, bring a Pascal book. If you have a competent mentor, go for very basic C++, bordering on C for much of the time.
Why not LISP-like lang? For the same reason I would not advise starting with assembly. I mean, it's very educating to touch assembly and LISP in one's life to see the underlying atomic structure of the universe, I'd just advise against starting with it.
People keep saying Python is a meme or a cult or brain damage.
Oh yeah, I haven't even got started on the cultish aspects of the crowd, where a bunch of jerkoffs go around telling everyone that you have to use "list comprehensions" and lambdas for everything, because that's "pythonic".
And then there are smug idiots who proclaim python's superiority to anything else because there exists a module that allows you to, I dunno, download a picture and run face detection on it in a few lines of code. Just because there are "modules" (libraries) means python is superior, duh obviously. It isn't quite fair to compare python's standard lib to, let's say, C++'s standard lib. You'd have to give the C++ side of the argument at least the Qt framework to make the comparison's even in the realm of possibility of being in the same ballpark.
(*) Indentation should be made with tabs, space-crowd can go fuck themselves and their backward ways and yes, I can prove that tabs are superior. (**)
(**) May not apply to LISP-like languages. I have too little experience to comment on that, but I expect I'd be right too.