Many programs, or parts thereof, reduce to SQL expressions over data.
Programmers who don't understand RM well tend to under-use it for
computation. A declarative expression can often elide a lot of
imperative tedium.

I believe there is a simple answer:  The relational approach implies
the appearance of many abstract identifiers.

[Side note:  Marshall allows a relational approach to encompass
extensive use of RVAs - even to the point where at each level in the
hierarchy of a heavily nested composite value, a relation is only
being used to represent the children of a given node.  This avoids the
need to introduce lots of abstract identifiers, but I don't agree with
Marshall that such an approach should be called "relational".  Of
course if anyone really wants to call that relational then that's fine
by me - after all it's just a word.  My argument of course only
applies when heavily nested RVAs are not being used]

I think you may be discounting the importance of languages (or more
specifically grammars) or the concept of a well formed formula.  After
all the First Order Logic (FOL) is formalised with the concept of a
wff which is defined recursively.  It seems wrong to assume that data
management doesn't encompass recording wffs.  It seems wrong to assume
that wffs can be represented /naturally/ in the RM.  While it's true
that the RM/RA is closely associated with set theory and the FOL,
anyone using the full power of the FOL does a lot more than calculate
with known extensions of sets.

Sorry I have no idea what you're getting at.

Let me be more specific:  when you see a wff in some formal language,
do you actually think of it as a relation?   How is that useful?  More
specifically, how is the RA useful?   Can you give me an example
together with the relation's degree and the names and types of its
attributes?

I'm suggesting that in certain situations the RM is cumbersome, making
it inappropriate or inapplicable.   This is specifically with regard
to /recursive data types/.

For example, recursive data types are appropriate for representing
wffs in most formal languages.  They are also relevant in compound
documents.  Eg

struct Chapter
{
   String title;
   Vector<Paragraph> paragraphs;
   Vector<Chapter> subchapters;
};

There are two ways that the RM can be used to represent recursive data
types:

1.  Using recursive RVAs; or
2.  By introducing abstract identifiers for all the nodes, and
appropriate integrity constraints

I find the first quite reasonable, but I'm suspicious of actually
calling such an approach "relational".

In the second case lots of integrity constraints are needed because
the RM is too flexible! It needs to be heavily constrained to only
represent tree structures. The integrity constraints quickly get
horribly messy - particularly for a reasonably complex grammar, and I
believe it's possible to interpret it as a manually written
axiomatization of pointer semantics (the ability to "dereference" an
abstract identifier as though it points at one and only one child node
in the tree).  If you compare the RM to the grammar you will find the
former to be /much more complex/.

The following is the example I used when I talked about this 12 months
ago:

Using Prolog notation, consider the following relations which allow
for representing an expression such as (x+1)*3:

   var(N,S) :- node N is a variable named S
   number(N,I) :- node N is a number with value I
   add(N,N1,N2) :- node N is the addition of nodes N1,N2
   mult(N,N1,N2) :- node N is the product of nodes N1,N2

Define a view called nodes(N) which is a union of projections as
follows:

   nodes(N) :- var(N,_).
   nodes(N) :- number(N,_).
   nodes(N) :- add(N,_,_).
   nodes(N) :- mult(N,_,_).

The following are the integrity constraints (each query must be
empty):

   var(N,S1), var(N,S2), S1 <> S2?
   number(N,I1), number(N,I2), I1 <> I2?
   add(N,N1,_), add(N,N2,_), N1 <> N2?
   add(N,_,N1), add(N,_,N2), N1 <> N2?
   mult(N,N1,_), mult(N,N2,_), N1 <> N2?
   mult(N,_,N1), mult(N,_,N2), N1 <> N2?
   var(N,_),  number(N,_)?
   var(N,_),  add(N,_,_)?
   var(N,_),  mult(N,_,_)?
   number(N,_), add(N,_,_)?
   number(N,_), mult(N,_,_)?
   add(N,_,_), mult(N,_,_)?
   add(_,N,_), not nodes(N)?
   add(_,_,N), not nodes(N)?
   mult(_,N,_), not nodes(N)?
   mult(_,_,N), not nodes(N)?

I'm with you even though we think of the activities involved as being
natural to us.  The RM is an artifice, so are models in general.  So is
FOL (even with its trap lingo like "Exists").  I doubt if mathematics is
any more natural than a data model as it produces some conclusions that
nobody can actually visualize.  The consequences of relational closure
are one small example.  The reason I think this is important is that it
means there ought to be nothing to prevent us devising even more useful
artifices, even if most of us, including me, don't possess the insight
to do that.

Being part of nature, we are hardly in a position to duplicate it.  Our
only advantage is the artifice wherein we can drop the natural aspects
that are inconvenient or irrelevant, as we see it, to some purpose.
We've been practising this since the Stone Age.

It bugs me when people pretend that we have re-produced anything but our
own mental creations, I think that is the first step down the mystic
slope.  But reason and rationality too can get out of control, as modern
history shows.  Does that sound odd coming from an atheist?

Yes! Formal systems and symbolic manipulation are symbolic and abstract
not natural.

When I said "universally applicable" I meant (only) with respect to
the recording of data, where data means "encoded values".

When you say "data" do you always mean "encoded facts"?

Exactly!

Agreed.

Yes that fits with your assumption that data = encoded facts.

However it doesn't make sense when you say data = encoded values.
Encoded values just "are".  They don't necessarily refer to anything
in the real world.