The SWYM programming language

I like that he's going to introduce quantifiers into his language (e.g. some(X) > every(Y)). What I'm concerned about tho is that this will have some very peculiar "errors" for some people. It seems like he's using what we linguists would call de re scope, which is to say the first quantifier has higher scope than the second one.

For example, using English, and translating into first order logic with restricted quantifiers, as well as Ruby:

  Some dog chased every cat
  ∃x:dog(x)[ ∀y:cat(y) [chased(x,y) ]]
  dogs.some? { |x| cats.all? { |y| chased x, y }}

Unfortunately, the English sentence is known to have another reading, one where each cat is chased by some or other dog, maybe not the same one for each cat:

  ∀y:cat(y)[ ∃x:dog(x)[ chased(x,y) ]]
  cats.all? { |y| dogs.some? { |x| chased x, y }}

Which means some poor coder might end up typing some(dog).chased(every(cat)) in his language, thinking he's getting the ∀ > ∃ reading (the second one above) and bamph, weird behavior. Even if you're familiar with how quantifiers work in this language, the similarity to english in this regard might easily lead someone to absentmindedly make this error.

That's not to say that he shouldn't have quantifiers -- I think we need some interesting natural-language like things like quantifiers in experimental languages -- but it's definitely something he should watch out for.

I always liked the fact that in Knuth's MMIX, the antipodal opcode to SYNC is SWYM.

This is the coolest looking new language I've heard about in a long time. So many new things that I don't even know how I would start programming in it. I love seeing that. The focus on readability is also awesome. This will definitely be a source of inspiration for the language I'm working on.