It's not really subjective because people have had the opportunity to program in the nested 'read from the inside out' style of lisp for 50 years and almost no one does it.

TXR Lisp has this notation, combined with Lisp parethesis placement.

Tather than obj.f(a, b). we have obj.(f a b).

  1> (defstruct dog ()
       (:method bark (self) (put-line "Woof!")))
  #<struct-type dog>
  2> (let ((d (new dog)))
       d.(bark))
  Woof!
  t

The dot notation is more restricted than in mainstream languages, and has a strict correspondence to underlying Lisp syntax, with read-print consistency.

  3> '(qref a b c (d) e f)
  a.b.c.(d).e.f

Cannot have a number in there; that won't go to dot notation:

  4> '(qref a b 3 (d) e f)
  (qref a b 3 (d)
    e f)

Chains of dot method calls work, by the way:

  1> (defstruct circular ()
       val
       (:method next (self) self))
  #<struct-type circular>
  2> (new circular val 42)
  #S(circular val 42)
  3> *2.(next).(next).(next).(next).val
  42

There must not be whitespace around the dot, though; you simply canot split this across lines. In other words:

   *2.(next)
   .(next) ;; nope!
   .(next) ;; what did I say?

The "null safe" dot is .? The following check obj for nil; if so, they yield nil rather than trying to access the object or call a method:

  obj.?slot
  obj.?(method arg ...)

It's not like postfix replaces everything else. You can still do foo(bar, baz) where that makes the most sense.

However, experience shows that functions having one "special" argument that basically corresponds to grammatical subject in natural languages is such a common case that it makes sense for PLs to have syntactic sugar for it.

Look at the last line in the example, where I show a method being called on a tuple. Postfix syntax isn't limited to methods that take a single argument.