What a namespace really gives you is composition.  You're using RSS
1.0, which is a powerful syndication protocol made from lots of little
sub-components plugged together by namespaces.

RSS 1.0 itself is small and easily learned. It knows about
"syndication", but no more.
Dublin Core knows about cataloguing metadata, so it understands
"Authors" and "Rights". By adding it to RSS 1.0, you can gain
properties that can represent a much deeper description of your content
than RSS' own trivial model, but you don't need to extend RSS itself.

In contrast there is RSS 2.0.  This takes the opposite approach and
ignores namespacing. So every time it's realised that there's a useful
feature missing, the RSS 2.0 autocrat inventor adds yet another random
property to it. The 2.0 protocol is an ugly rag-bag of random rubbish
tacked onto it. It's big and bloated for most purposes, but it still
isn't as simply and elegantly extensible as the much simpler RSS 1.0.

In one sense there is nothing that RSS1.0 and namespaces can give you
that a well though-out RSS 2.1 could give you without namespaces. But
this hypothetical 2.1 version would be bigger, it would be more
specific to one subset of users' requirements, and it would not offer
the huge re-use potential that a smaller namespace like DC does.

On your next project you might be cataloguing a library of video clips.
You bump into Dublin Core again and you gain the advantage of _already_
knowing this namespace and how to use it - an advantage for you. Then
you add a syndication feed to this library and you choose to do it in
RSS 1.0 with DC. Now there's a synergy effect too - the project is
simpler and better because it's using the same representation
throughout. This has advantages for the finished project, as well as
for you.

RDF is also a useful part of this. RDF doesn't have an "application
area" like syndication, it's much more general. It isn't even a
"metadata protocol", as is sometimes claimed. All it adds is a
graph-like model of obejcts and properties, so that any application
understanding RDF but not (for instance) DC can still extract a useful
data model that "knows" there are entities called "Item", "Author" etc.
and that "phoneNumber" is a _property_ of an _entity_ called "Author"
(XML alone can't do this).