The benefit of S-expressions (lisp syntax) is that they make it easy to work with "code as data" instead of "code as text". This in turn makes it easy enough to generate code and define new forms of expression that people can actually do it without blowing the complexity budget.
Instead of using hacks like c's function pointers, lisp lets you pass code around as easily as any other variable type (1st class functions) instead of just pointers to the code. You can then exploit this ability to make code that will generate code on the fly and then execute it (macros). The homoiconicity of the language itself makes it much easier to make useful macros as opposed to just toy examples.
Since lisp and c are both turing complete, anything you can do in one language you can do in the other, but lisp's macros, 1st class functions, and homoiconicity make it possible to actually write something that would be almost impossible in c due to complexity issues. For example, in Cal's old intro cs course which used a lisp dialect, the last project of the course was writing a meta-compiler for the entire language. In contrast, Cal's compiler course uses c++ to compile only a small subset of python2 over an entire semester, and is considered one of the hardest classes due to the project's complexity.
In lisp you can create sh, python, and C, and mix between them freely within a program/function/block with almost zero friction.
By having a simple universal syntax for all your sub-languages, syntax becomes a non-issue. What in unix may be separate language is just a library in lisp.
This is not a water-tight analogy but I hope it illustrates the point. If you want to really understand I recommend actually digging into a language in the lisp family such as Common Lisp, Racket or Clojure.