I find the section 5.3 from the paper "Out of the tar pit" describes it very well:
> It is for this reason that Prolog falls short of the ideals of logic programming. Specifically it is necessary to be concerned with the operational interpretation of the program whilst writing the axioms.
I haven't heard of any approach that generalizes the goals of logic programming in a far better way. Is there any? (on specific usecases, having a sort of rule engine for running your "business rules" can indeed be an excellent approach)
For me, the most influential was "Out of the Tar Pit".
From the abstract: "Complexity is the single major difficulty in the successful development of large-scale software systems. Following Brooks we distinguish accidental from essential difficulty, but disagree with his premise that most complexity remaining in contemporary systems is essential."
We’re still trying to crawl out of the tar pit.
I will agree that there are a lot of really smart people in the Clojure community, but that is also true in other communities. Some of the most brilliant developers I know are hard-core C++ guys.
The original point about bugs is in my opinion, regarding my comment you replied to, very similar to a discussion about code size. There are some great reads  that go into further depth on this issue, if you are curious.
Out Of The Tarpit, by Moseley and Marks
The first half of the paper is a spot-on critique of so many things that go wrong in the process of designing and implementing large-scale software systems. The second half, where the authors propose a solution, kind of goes off the rails a bit into impracticality... but they definitely point in a promising direction, even if nobody ever uses their concrete suggestions.
It's always interesting to me to see how various people discover the basic advantage of function-oriented programming on their own.
There's also eg the copy-on-write filesystems, and git---whose main on-disk data-structures are conceptually immutable despite being implemented in C.
You might enjoy reading "Out of the tarpit" (https://github.com/papers-we-love/papers-we-love/blob/master...), a paper that deals with approaches to master software complexity.