Chris Smith

I think you might be thinking of https://cdsmith.wordpress.com/2011/01/09/an-old-article-i-wrote/ It says: > I give the following general definitions for strong and weak typing, at least when used as absolutes: > Strong typing: A type system that I like and feel comfortable with > Weak typing: A type system that worries me, or makes me feel uncomfortable

Somewhat related: Chris Smith is teaching kids programming using a tiny subset of Haskell, the Gloss graphics library, and a web framework that he built around Gloss, using the SafeHaskell extension. His experiences can be followed through his blog. Previous posts: http://cdsmith.wordpress.com/2011/08/16/haskell-for-kids-week-1/ http://cdsmith.wordpress.com/2011/08/23/haskell-for-kids-week-2/ http://cdsmith.wordpress.com/2011/09/03/haskell-for-kids-week-3/ http://cdsmith.wordpress.com/2011/09/10/haskell-for-kids-week-4/ Well worth the read, and a good example of how programming can be taught to children.

Your point about class definitions being frozen is apt — but much of the nomenclature you're using to describe languages is meaningless. Please read the classic What To Know Before Debating Type Systems: http://cdsmith.wordpress.com/2011/01/09/an-old-article-i-wrote/

I'm not sure the fact that kids can "learn" language X proves much, because generally we're teaching kids language X so they can take some kid-friendly subset of the language and do kid projects in it. This is great on its own, but showing that kids can learn Scala or Haskell doesn't necessarily mean that they're going to be able to program in it. Here's a group using Haskell: http://cdsmith.wordpress.com/2011/09/03/haskell-for-kids-week-3/ Are they choking and dying because Haskell is just too magically difficult for children to learn? Goodness, no. On the other hand, does this prove that Haskell is never confusing when you're three layers deep in monad transformers trying to use a parsing library and you get a twenty-line error message about a failure to unify types with type signatures bigger than Twitter will let you post full of "a" and "t1" and "t2" and "t3"s? I mean, let's be honest, that just doesn't happen when you're using Python or Perl. (It can in Java, but still a lot of times it's just verbose, vs. Haskell's actual complexity.)

Lame article, read this instead: https://cdsmith.wordpress.com/2011/01/09/an-old-article-i-wrote/

Those interested in this subject might also enjoy What To Know Before Debating Type Systems: https://cdsmith.wordpress.com/2011/01/09/an-old-article-i-wrote/ It’s one of those older articles where not everyone will agree with everything, but there’s still a lot of insight and food for thought.

https://cdsmith.wordpress.com/2011/08/16/haskell-for-kids-week-1/ Books like The Haskell School of Expression have been teaching functional programming using simple graphics in Haskell for a long time. Need I remind you that the entire concept of a Turtle comes from Logo, which is Lisp minus parentheses?

"Having tried both, I've found that the ML-derived languages tend to have a stronger type system that's more rigorously enforced at compile time. I personally find this much more valuable in practice than some of the dynamic magic that you can do with lisp." You probably meant to contrast ML's static typing (not strong typing) with Lisps's dynamic typing. See "What To Know Before Debating Type Systems": https://cdsmith.wordpress.com/2011/01/09/an-old-article-i-wrote/

> Some people like more restrictive languages, because they don’t trust others or themselves to reliably use good discretion in the use of powerful features For me, it's not even that. It's that I've discovered that, even when used with discretion, the simple presence of powerful features still makes it harder to reason about how things work. Discretion around powerful features isn't a one-and-done thing; it's an ongoing process of double-checking and verifying for yourself whether that feature is being used properly every time you touch or interact with code that uses it. A common thread in many seminal papers and essays in the history of programming languages ("Can Programming be Liberated from the Von Neumann Style", "GOTO Statement considered harmful", "Lambda: The Ultimate GOTO", to name a few.) is that, ironically enough, when you take a bird's eye look at things, reducing the power of the tools tends to increase the power of the programmer. I should say, I'm not meaning that to be a statement in favor of static or dynamic typing; I try to stay out of that debate.[1] To me, the real problem with JSON is that, at least under typical usage, it tends to be weakly typed. (Which is a powerful feature; strong typing is a way of restricting what you can do.) JSON's type system is less expressive than that of basically any well-known programming language, including JavaScript itself, and, out of necessity, people tend to deal with that by overloading its types in ways that…