Am I misunderstanding you, somehow?

But to only understand 10% of a programming language's syntax seems a very limited understanding.

To only know 10% of the standard library or whatever is one thing... but 10% of syntax?

Either you don't know the language well at all, or else it must have a very complex syntax, with a lot of edge cases.

That's one of the nice things about (say) scheme, or lua, say. There's very little syntax to learn. Go, JS, Ruby and Python, more... but still, not that much syntax, really.

Even Ruby doesn't really have that much syntax to learn. Ruby, Python and Go all have pretty huge std libs, but not that much syntax.

Ruby presents a very simple, understandable surface, but trust me, as you go deeper it gets very, very strange. I've used the thing for fifteen years and there still things that make me go "Huh, I didn't know that" but they're obscure quirks that you can go an entire career without encountering.

Any non-trivial language will have an ugly layer that the language designers couldn't quite get rid of.

Plus, unless your language is dead, it will continue to evolve and add new features that you will have no knowledge of unless you make an effort to absorb them.

Really? Do you really need to know what the comma operator does in C?

Do you really need to know the difference between `void foobar(void)` and `void foobar()`?

There are a lot of things in a language even as simple as C that's useless syntactic trivia. I imagine someone could think of really evil things in C++

Hm. Maybe I made myself unclear - I was meaning to be specifically in response to the parent post, who said that only knowing 10% made him feel empowered.

I was meaning, in a sense, that it's better to have a language which doesn't have such a complex history, undefined behaviour, and weird syntactic trivia.

The simpler the language, the less unexpectedness occurs, and the more you can concentrate on the actual logic and meaning.

For instance, in English, "homosexual" = attracted sexually to those who are the same ("homo") gender as yourself. But "homophobic" does not mean hating/fearing those the same gender as yourself. The rules are complex, with history, weirdness, and are confusing.

The same with programming languages, I feel. Take JS, for instance.

    >>> (0 == [])
    true
    
    >>> typeof (0 + 0)
    "number"

    >>> typeof ([] + [])
    "string"

There is no reason on earth I want to know that stuff or operator precedence rules. I can never remember those if I need to do a `x * y + 2 z --` and so always write in brackets explicitly. But the language can accept such things, and make an order from them.

Going back to C (sorry for jumping around), yes, it's simple compared to C++, or many other languages, but it does have a lot of history, undefined behaviour, and stuff you simply need to be aware of. And it's that stuff that makes life complex for C beginners (and allows bugs for C of all experience levels). There's a reason I didn't list C as a simple language. :-)

If our languages didn't have such quirks, and we didn't have to cope with working around them, a lot less mistakes would be made. http://separatedbyacommonlanguage.blogspot.co.uk/2007/10/to-... for instance, in English.

English - the Javascript of the human languages.