Much like when you complain about parenthesis in Lisp, if you complain about windows in Smalltalk (or key combinations on Emacs) you are probably focusing your attention on the wrong thing. Stop fighting the environment. Let it flow around you.

I don't think this type of argument carries much weight. Just because one can get used to something, doesn't really make it a clear choice.

All of these environments are good choices for many reasons. However, they aren't without major flaws.

Smalltalk environments do tend to be a bear when following the code around window after window, emacs keychords are not very human friendly or composable and can give you RSI, and lisp parentheses are mainly for the convenience of the language parser, not for the programmer (contrary to the famous quote).

While I don't disagree on your other points, lisp's parentheses aren't just for the convenience of the parser, they're also for the convenience of the programmer who uses macros. Homoiconicity is a huge boon there.

Try using another language which allows macros and you'll see what I mean. For example, Haxe allows macros, and while it's syntax for them has recently improved, it still has a ways to go. Here's an example macro which checks if its argument is a constant string, and if it is, reads the file it represents. http://haxe.org/manual/macros/#manipulating-expressions

edit: The equivalent in clojure would be something like

    (defmacro get-file-contents [s]
      (if-not (string? s)
        (throw (Exception. "Expected string"))
        (slurp s)))

Which happens to look very similar to a function that does the same thing, but at runtime instead of at compile time.

The haxe macro reads the file at runtime. Your clojure macro reads the file at compile-time. The proper version would be :

    (defmacro get-file-contents [s]
      (if-not (string? s)
        (throw (Exception. "Expected string"))
        `(slurp ~s)))

Nope, the Haxe program reads and includes the file at compile time, but only if it's a string literal. If it's an expression that evaluates to a string (which only works if you have static typing, as Haxe does), it reads it at runtime. If its neither it fails.

The convenience for the language parser at least translates into convenience for structured editing in the case of Lisp.

I always miss the convenience of modifying code with Paredit when I'm working in another language.

Lisp quotes does have plenty of advantages for human reading, though.

Only the parenthesis in Lisp have to be like that to serve a purpose (data is code is AST, homoiconicity, macros, et al). They cannot really be changed much and still have a Lisp proper.

Whereas Smalltalk IDE window handling could be improved tremendously from the mid-90's designs it still carries to this day. Not the reflective/debugging/refactoring capabilities (the good parts). Just the GUI and the handling.