
What is dynamic feeding and how does it work?

Dynamic feeding comes in three parts.  The first is a feeding system that
does not use the B or C news "sys" file.  Instead, each site you feed
gets a newsrc file, just like any user who reads news.

The feeding program finds out what news is 'unread', feeds it out, and
marks it as read.

This means group by group control over what is fed.  The sys file had this,
but only up to a certain limit, and it was quite difficult to work with.
In addition, permission to change the sys file can only be given to
highly trusted users, such as the superuser.

(The 'feed' program requires no special permissions!  If you like, you can
even give remote sites user accounts on your system and have them maintain
their subscription list directly.)

The second part is the 'rcmerge' program.  It takes the old newsrc for
a site, and combines it with a new subscription request.  The subscription
request contains desired groups and distributions, along with patterns that
match groups which should be included or deleted from the newsrc.  Rcmerge
builds a new newsrc file, remembering what had been read up to that point.

In between the feed site and the recipient lies the setfeed program, which
takes a subscription request from the recipient and stores it for input
to rcmerge.

You can stop here if you like, and simply use the above tools to have
the recipient control what news is fed to him or her.

The third part lies on the recipient's system.  It's a program like the
arbitron program that measures USENET readership.  It figures out what
your users are subscribing to, and builds a subscription request from it.


The result can be a completely dynamic feed.  Only groups that people are
actually reading get sent.  When everybody unsubscribes, the group stops
being sent almost immediately.  As soon as one user resubscribes, the
group re-appears again.   In fact, if the gap in subscription was short,
all the old articles that didn't get sent (up to a limit) will now be sent,
so that nothing or little is missed.

The sites you feed are included in the subscription list.  So if somebody
downstream subscribes to a group, a requests comes to you to feed it.
But if you don't have it, that generates a request from you to *your*
upstream site to feed it.

The first time somebody requests a group, up to 80 back articles are sent,
so people can get into a group right away.

Of course, you still have complete control over what you send out.  You can
stop downstream sites from getting groups you don't want them to get.  You
can also request that some groups be sent even if they don't ask for them.

Likewise, as a recipient, you can requests that some groups be sent no
matter what.  You can also stop your users from requesting groups that
you don't want to pay for.

"Backbone" style sites won't go for dynamic feeding, of course.  They will
want to feed everything.  But for leaf and intermediate-leaf sites --
particularly those concerned about long distance bills, network usage,
CPU and disk space -- dynamic feeding is ideal.

It turns USENET into a dynamic network, where a newsgroup can be as efficient
as an optimal mailing list.
