I agree in that easy parsing is a good quality of languages. But i also think a language can have a rather rich (i.e. big) syntax that&#x27;s also straightforward to parse. That is, that the dichotomy of either having a very lean syntax like Scheme or a bloated and complicated syntax like Ruby is not so clear-cut.<p>The difficulty of parsing Ruby&#x27;s syntax (both for machines and for humans) comes from some unfortunate design decisions, not so much from its vastness. For example, using the same symbols, {}, to denote hash literals and blocks makes parsing&#x2F;understanding the syntax of method calls more difficult:<p><pre><code>  def foo(*args)
    puts &quot;args: #{args}, block_given?: #{block_given?}&quot;
  end
  # Parentheses can be omitted when calling methods:
  foo           # args: [], block_given?: false
  foo 42        # args: [42], block_given?: false
  foo 42, &quot;bar&quot; # args: [42, &quot;bar&quot;], block_given?: false
  # *Except* when the first argument is a hash. This:
  foo({})       # args: [{}], block_given?: false
  # Means something completely different than this:
  foo {}        # args: [], block_given?: true
  # But if the hash is not the first argument then it&#x27;s OK, you can omit parens
  # again :3
  foo 42, {}    # args: [42, {}], block_given?: false
</code></pre>
This is not a problem of having dedicated syntax for blocks and hash literals. It&#x27;s a problem of having chosen conflicting syntactic forms for them. If blocks could only be denoted with do&#x2F;end, or with a different set of symbols than hash literals, this would not be a problem.<p>And this is just one example of conflicting syntactic forms. In Ruby, sadly, there many cases of this. E.g., using * both for multiplication and for argument &quot;splatting&quot; means that<p><pre><code>  a * b
</code></pre>
is not the same as<p><pre><code>  a *b
</code></pre>
when `a` is a method, but actually <i>is</i> the same when `a` is a local variable; or `foo &quot;bar&quot;` and `foo&quot;bar&quot;` being two perfectly valid ways of calling foo with &quot;bar&quot; as an argument, but `foo [42]` and `foo[42]` <i>not</i> being two perfectly valid ways of calling foo with [42] as an argument; and probably more.<p>So, as long as syntactic forms are carefully chosen so that they don&#x27;t have weird and conflicting edge cases between each other, i think a language can have a rather big syntax without it being difficult to parse&#x2F;understand.<p>Disclaimer: i love Ruby; it&#x27;s my bread-and-butter language. But i wish it didn&#x27;t have as many syntax quirks as it does :)