This document is copyright (c) 1993 by J.J. de Graaff.

$Date: 93/07/24 22:39:40 $
$Revision: 1.3 $


               The RN User's Guide to TRN



This guide describes trn from the viewpoint of a rn user. On the 
system on which I am news administrator I still see numerous people 
reading news with rn. My opinion is that for most of these people 
it would be worthwhile to invest some time in learning to use trn. 
True, trn is more complicated than rn, but this also means that 
there are more different ways to read or browse through the news 
articles, some of which might help tremendously in cutting down on 
reading time or in managing newsgroups with a large number of 
articles.

It doesn't take much time to get at least some experience with trn, 
while the benefits might be large. In fact, I introduced several rn 
users to trn in much the same way as described below, and they 
wouldn't want to give up trn anymore. Note that even though this 
guide assumes that you have some experience with newsreading in 
general, and in using rn in particular, it can still be beneficial 
to somebody just starting with trn.


"So what's so special about trn anyway?"

The main difference between trn and rn is hidden in the different 
names. The 't' in trn stands for 'Threaded'. So what's a thread, 
and why is this convenient? A thread consists of a number of 
related articles. Say, for instance, that you post an article to 
ask about the current price of watermelons. You get several 
replies, one of which asks you a question about the quality of the 
watermelons. You again reply to this post. All these articles are 
related to each other, and this relation can be shown in a tree 
format:

          [1]-[1]		1: Price of watermelons anyone?
             \[2]-[2]		2: What quality? (was: Price...)

These articles are said to belong to the same thread. TRN knows 
about these threads, and it can represent them to you. RN will only 
let you operate on the individual articles, while trn will also let 
you operate on whole threads of articles.


"Cute, but what's the gain?"

You don't realize that yet? The major gain is that articles that 
belong to each other are grouped together. This has several 
advantages. First, it's easier to select what to read. You can 
evaluate whole threads of articles instead of evaluating each 
article by itself. Clearly, this will allow you to scan much more 
articles.

The reading of articles is also improved in several ways. For 
instance, articles are grouped together. In rn articles are 
presented in a haphazard order, making it hard to judge the 
different threads. There is a possibility to read the next article 
with the same subject in rn, but if the subject changes you're out 
of luck. Also, you never know how many articles there are with a 
subject until you have read them all. There is no visual 
indication of this. With trn, selection of articles is done at the 
thread level. Once a thread is selected, all articles can be read 
in the correct order, regardless of changes in subject.

To sum it up:
Related articles are grouped and ordered before they are presented.


"Hmm, sounds cool, but since I don't read much news anyway..."

Well, there might be several reasons why you don't read much news.
For instance, you might not have more time to read news. TRN will 
probably make it easier to read more news in the same amount of 
time. This means that you will either be able to read more news, or 
it will take less time.

Another reasons might be that you only read a few newsgroups. In 
this case it might be profitable to switch to trn, but it might 
also not have any benefit. If you read groups with lively 
discussion, switching to trn will benefit you. However, if you read 
low volume groups, or groups with only separate articles, like 
comp.risks or comp.virus, then you might not benefit from trn.


"Well, I'm still not sure whether I should switch to trn."

I put off learning trn too. Actually, I used to read news using 
xrn, an X program based on rn. When I was forced to use a 
character-based newsreader because I had to read via modem, I had 
to switch to trn, and I hated it, mostly because I just didn't know 
my way around. I knew what to expect from rn, and it took me some 
time to really get used to trn. Then again, I didn't have this 
guide to help me. Not that this guide will explain all of trn, far 
from it. It will give you a starting point to use trn, and it won't 
take more than 10 minutes. Give it a try. You can always go back to 
rn, but chances are you'll like trn more.


"Ok. Might as well bite the bullet. 10 minutes, no more!"

Cool. Let's go.

-----

Starting up trn

First we'll have to start up trn. Just to make sure we also need the
option '-x'. This option will enable the threading behavior of trn.
Usually, this option is the default, and you can probably omit it.

	$ trn -x

After this, trn should start up, and present the first five groups 
with unread news, just like rn does. Remember that trn is based on 
rn, and this is the part that resembles rn the most. Actually, 
there is only one difference here: the default choice for the first 
newsgroup should be a '+'. This '+' is the command to invoke the 
thread selector, which we will do in a minute. If you were to type 
a 'y' at this prompt, trn would behave exactly as rn does.


Getting to the right group

Ok, before we examine the thread selector, we'd better pick a good 
group to demonstrate it with, a group in which we don't care about 
the articles, so we can read and skip articles at will. A good 
newsgroup to do this with is comp.os.linux, because it contains a 
lot of articles, so it will make the advantages all the more 
apparent. We can go to this group just like in rn, with the 'g' 
command. At the prompt, type:

	[+ynq] g comp.os.linux

Trn now tells you how many unread articles it has in comp.os.linux. 
Wow! You would never want to read that with rn, but let's see how 
trn handles this. Now we get to the scary part, the thread 
selector. Scary, because it's radically different from rn. Let's 
just type a space to go to the thread selector.


The thread selector

The thread selector will show the first few threads. Each thread is 
identified with a character in front of it, and the cursor is over 
the first thread. There are several different ways to read or skip 
these threads, but I'll only describe two different ways.

Before we start reading, let's look at the thread selector some 
more. Below is part of what the thread selector screen might look 
like. On top and and the bottom are some status lines, showing the 
number of articles left, and the default commands. Between these 
lines are the threads. A sample of these is listed below. There are 
three columns: the first column contains a letter or digit to 
identify the thread. The middle column contains the names of 
authors that have contributed to this thread, and the last column 
contains the subject line in the thread. 

Note that in the second thread (b), there are two different subjects.
This sometimes happens when a discussion digresses from it's original
subject. Even though the subject is different, trn still holds these
articles together within a thread, because the started of from the
same article.

======
a Linus Torvalds	ANNOUNCE: Yet another Linux kernel
  Joe B Low
b Cliff A Adams		STRN ported to Linux
  Hans de Graaff
  Harry B L Goodwill 	Yet another newsreader (was: STRN...)
======


Selecting articles with the thread selector


There are several ways to use to thread selector to select articles
for reading. I will describe three different options, each with a
different focus and goal.

Selecting a thread one at a time

If we select a thread one at a time, there are only two options:
either we want to read the current thread, or we don't. If the thread
is not interesting, you can use the comma: ','. It will mark the
current thread as read, and it will not appear again the next time
around. In the thread selector, this is indicated with a minus '-'
next to the letter of the thread. Also, the thread selector advances
the cursor to the next thread.

To read a thread, press enter while the cursor is on the letter of the
thread. The first article in the thread will be presented, along with
the navigation tree in the upper right, and reading will proceed just
as described below. After reading the thread trn will return to the
thread selector. The thread that just has been read has disappeared, as
have all the threads that were disselected using the ','. Now you can
start again by reading the thread with return, or by disselecting it
with ','.


Selecting threads on the screen

Another way to use the thread selector is to see the screen as a
menu. You just select all the threads that look interesting, and then
proceed with reading them. This is more efficient if there are only a
few threads you want to read. Selecting threads in the thread selector
is easy: just press the letter (or digit) corresponding to the thread.
The thread selector indicates the selection of the thread with a plus
'+' next to the letter of the thread. 

After selecting all the threads you want to read you can use the 'D'
command to read them. The thread selector will let you read each
thread you selected in turn. Note that the 'D' command will also mark
all unmarked threads as read. This means that they won't come back
anymore. 


Selecting threads in the group

The last way of selecting threads is to first select all the threads
in a group, and then read them. This is very similar to the previous
method (using 'D'), but instead of selecting threads on the current
screen only, you consider all the threads in the group. To accomplish
this you will have to be able to "scroll through" the threads. This
can be done using '<' and '>'. These commands will show you the next
'>' and previous '<' screen of threads. You can now select threads in
the usual manner (using its letter or digit). After you have selected
all interesting threads you can press 'Z' to read them. Note that this
will also mark all unmarked threads in the group as read. After
reading all the selected threads there are no threads left in the
group.



Reading threaded articles

While reading an article, you will notice a small tree of 
articles in the upper right corner of the screen. (Of course, if 
you're unlucky, there's only one article in the thread, so its tree 
won't be that interesting.) The current article in the thread is 
highlited. Articles that have already been read are marked with 
parentheses, and articles that are still unread are marked with 
square brackets. As you read through the articles in a tree you 
will see yourself move through the map of the tree, leaving a trace 
of parentheses.

The actual reading of the article isn't any different from reading 
an article in rn. In fact, all the stuff that works in rn will also 
work in trn, like saving the article with 's', or skipping it with 
'n'. 

Pressing space at the end of an article will get you the next article
in the thread, or if the thread is exhausted, the next thread. If
there are no more selected threads you will be returned to the thread
selector, or to the newsgroups mode. Depending on whether there still
are unread threads.


"That's it?"

Yes and no (my favorite answer :-). Yes, this is the basic 
knowledge needed to read news with trn, and these are the commands 
that I use most of the time. No, because there are much more 
possibilities. All of these are described in the man-page, or in 
the help-screens that can be accessed with 'h'. However, my advice 
is to start with the commands listed above, and get comfortable 
with these commands, the notion of threads, and the thread 
selector. After some time, you can start to extend on this 
knowledge.

-- 
Hans de Graaff                  | I want someone to follow,
J.J.deGraaff@IS.TWI.TUDelft.NL  |   who doesn't lead the way
Department of Informatics       | I want someone to listen,
Delft University of Technology  |   who won't repeat what I say
               Room: 2.003, Telephone: +31-15-78-5811 
