Chris Smith

> 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…

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.)

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.

"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/

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