It gives me no little amount of pleasure to declare that my little pet
project, the mailing list manager called Enemies of Carlotta, has reached
the version number 1.0.

The distribution files are available at the home page of the program:
http://liw.iki.fi/liw/eoc/ . Feel free to drop by.

My first memory of using a mailing list is from the first "Linux activist"
list at hut.fi, run by Ari Lemmke, using his own software.  It was rather
complicated to use. It probably wasn't my first mailing list, but I can't
remember any earlier. I've since used lists run on, at least, Majordomo,
Listserv, Smartlist, Mailman, Ezmlm, sendmail aliases maintained in
various ways, and a couple of home grown solutions. I've administered
lists on Ezmlm for some years, but not on any other software.

Before my first experience with ezmlm, I found mailing lists to be
rather awkward to use. Subscription and unsubscription commands were
difficult to remember exactly, and every list manager wanted me to send
the commands to a different address, and wanted me to follow a different
syntax to give the commands. Sometimes they wanted me to put commands in
the subject, sometimes in the body. Sometimes they wanted me to say just
"subscribe" and sometimes they wanted me to say something more, such as
the name of the list or my own name and address. They all wanted me to
save the instructions they sent me so that when I wanted to unsubscribe,
possibly years later, I would have no trouble doing it.

Then, after the middle of the 1990s, mailing lists were used to
attack people. The attacker would subscribe the victim to hundreds,
even thousands of mailing lists. This would render the victim's e-mail
useless for days, even weeks, and some of them would still be subscribed
to some of the lists years later. Ugly.

Mailing list software authors responded to this in various ways. A typical
way was to require all subscribers to have a password. Some list managers
had had passwords even earlier.

Yeah, that's exactly what everyone wanted. Yet another few dozen passwords
to keep track of.

In 1997, I needed to set up some mailing lists myself, and while looking
for tools I stumbled on Ezmlm, by Daniel Bernstein.  It was a breath of
fresh air. First, it was small and simple and fast, which was not the
case with some of the software I'd been victimized by. Secondly, and more
importantly, its design was intelligent. The mailing list commands were
incorporated into the addresses. Before, instructions for subscribing
to a list could be something like this:

    Send mail to foo-request@example.com, with the word "subscribe"
    (but nothing else) in the subject, and with an empty body. To send
    an empty in mailer WunderBotch, do this. To send an empty mail in
    mailer LetsGoPostal, do that. To send an empty mail in Unix, give
    the following command on the command line...

With ezmlm, the instructions became:

    Send mail to foo-subscribe@example.com.

Simple. Effective. Possible to explain over the phone.

As far I know, Bernstein was the person who invented this, but I haven't
researched it. Whoever did it is brilliant.

Ezmlm also didn't require any special priviledges to be used. Any user
could create a mailing list.

There were only two problems with Ezmlm. First, it pretty much required
using Qmail, the mail transport agent Bernstein had also written. Second,
both Qmail and Ezmlm used a copyright license that was free enough to
be used without trouble, but not free enough to be free software. For
many years, I overlooked this, given the excellent technical quality of
both pieces of software, and the near-freeness of the license. It never
stopped bothering me a bit, though.

In the spring of 2002 I installed a mail server at home, at the end of
my ADSL pipe, and decided to find free alternatives for both Qmail and
Ezmlm. I settled on Postfix for my MTA, but didn't find any mailing list
manager that really appealed to me. There were a bunch, and several of
them were nice enough to be usable, but none of them had the elegance
of Ezmlm.

I gave in to the NIH syndrome and wrote my own. I decided to write it
in Python, since most of what a mailing list manager does is I/O and
simple text processing, and Python is plenty fast enough for that,
and the language is suited for it.

I copied the Ezmlm mail commands: foo-subscribe@example.com is the
address to send subscription requests for my list manager also.

I did want to improve on Ezmlm on one point: bounce handling. Ezmlm
did something wonderful for list owners by automating bounce handling
almost 100%. Where earlier list managers had usually required the
postmaster or list owner to process bounce messages by hand, Ezmlm did
them automatically. It didn't quite reach 100% effectiveness. Not due
to any fault of its own, but due to the large number of hideously broken
mail servers on the Internet.

What Ezmlm did was send out each message with the subscriber's address
encoded in the SMTP sender address. If the message bounced, the bounce
message was sent (by any non-broken mail servers, at least) to the SMTP
sender address. For Ezmlm, it meant that the bounce was handled by the
Ezmlm software, and since the subscriber address was encoded in the SMTP
sender address, it was easy for Ezmlm to unsubscribe the bouncing address.
Simple, effective, brilliant.

The problem with this scheme is that it multiples the outward bandwidth
use of a list. Older list software could send out a single copy of the
message to all subscribers at once, but Ezmlm needs to send a separate
copy for each subscriber. For mailing lists with large amounts of traffic
and many subscribers, this can be too costly.

The older software didn't actually send out a single copy. It did,
however, essentially send a single copy to each destination domain,
which is pretty much optimal. The problem with this is that when there
is a bounce, it is quite difficult to reliably figure out whose address
is bouncing: there is effectively no standard format for bounce messages.

What I wanted to do was take Ezmlm's bounce handling and make it use less
bandwidth. I did this by grouping subscribers into groups, and send out
a single copy per group. The group identifier was encoded in the SMTP
sender address so that when any address in the group started to bounce,
I could split the group into smaller groups, and ultimately into single
addresses. When a group with a single address bounced, I knew who it
was and unsubscribed them.

This idea wasn't my own. It is used by the greatly modified version of
Smartlist that runs on lists.debian.org.

Another smart thing Ezmlm did with bounces was to wait a week before
unsubscribing anyone. Every mail user has occasional trouble with their
mail connectivity, and it is polite not to unsubscribe anyone unless
they're permanently missing. Ezmlm waits for a week, at least, before
unsubscribing. My software does also.

So, now, after less than a year of slowish development, I have a stable,
working mailing list manager, which I call Enemies of Carlotta, and which
now has version number 1.0.

I use it myself on liw.iki.fi, and I know some other people are using
it as well. I don't know of any large sites using it, but perhaps that
also will happen one day. According to my benchmarking, EoC should be
able to send out one million messages in twelve hours. See the file
BENCHMARKS for details.	

I'm not going to stop development with 1.0. The next big problem to
tackle is spam protection of lists. If you want to help, or just follow
what goes on, come join us and send mail to eoc-subscribe@liw.iki.fi .