Interesting news. If I understood it correctly:

Datastax bought the company behind graph database Titan (last version is 0.5.4).

They announced that they will finish Titan 1.0 and donate it to the Apache Foundation.

Then they will work on newly rewritten implementation of graph database, integrated with their products.

And that will be opensource too.

Not sure about licensing for comercial purposes.

http://www.zdnet.com/article/datastax-snaps-up-aurelius-and-its-titan-team-to-build-new-graph-database/

There are two main technologies from the old ages of internet that are (were) used for mass distribution of assynchronous posts: mailing lists and newsgroups (NNTP).

Mailing lists are, well, just a list of recipients that will get a copy of a mail sent to a special mail on a mailing list server.

Newsgroups are "topic IDs" (such like "org.jboss.windup.users") to which you can post, and it gets distributed over NNTP protocol to newsgroups servers all over the world. It's not copied to users' inboxes - it waits until they request it from the server.

I hate mailing lists (and I am not alone by far). They are just a poor substitution for newsgroups (NNTP protocol). For many reasons:

1) Subscribe/unsubscribe nonsense

Useless overhead. Why should anyone subscribe? Why not just authenticate / get authorized and access the content? Subscribing is a waste of time.

NNTP server, on the other hand, allows authentication and authorization, and "subscription" is done in your client - you simply favorite some groups and read them at will.

2) Downloading everything

In a mailing list, you simply get all of the trafic to your inbox. If someone sends 5 MB file, you get 5 MB file. And have to delete it. (IMAP helps a bit, but you still get a copy to your inbox).

NNTP server, on the other hand, passively waits until you _want_ to read the post, and sends it on your request.

Of course, pre-downloading in favorited groups may happen.

3) Waste of disk space

Again, if someone sends a 5 MB file, and the mailing list happens to be company-wide list with 4000 recipients, then we get around 40 GB wasted (5 MB attachment is encoded into roughly 10 MB in MIME format). That's really sick. And no - if you doubt the mail servers are so dumb and they only keep one copy of the file somewhere - they really don't, at least not the one we use(d) internally (confirmed by it's admin).

NNTP server, on the other hand, really does keep just one single copy of the post, and sends it to individuals on demand. The same goes for cross-posting.

4) Silly sorting to folders using filters

If you are in a company running a lot of mailing lists, you have to create a filter for each mailing list, if you don't want to end up with 1500 mails a day in your inbox. And not just you - everyone has. Typically, everyone needs to go to the impractical web UI of mail server ZYX and do the same stuff, figuring out which headers are the right to filter by. There's usually no sharing of these filters. And yet when finished, it still doesn't work well - sometimes you get stuff you have nothing to do with in your inbox, just because some header goes wrong. Or, very often, when a mail is cross-posted, it goes to one folder, but not to the other. And if it was copied to multiple folders, we're back to #3.

Newsgroups posts, on the other hand, are sorted by definition - each posts goes to one or more groups. And that's where you find them, period. No need for everyone to waste hours to create his/her own filters, almost identical to what others have.

5) Cross-posting

With mailing lists, cross-posting is real hell. Okay, the mailing lists server can prevent sending the mail to you twice. But not two servers - they have no idea about each other's internal IDs, so if someone sends a mail to a-list@foo.org and b-list@bar.org, and you happen to be subscribed to both - you end up with 2 mails. Now, to which of them are you going to reply? Both? If not both, some people will not get your reply. And worse: You need to watch both of the copied threads; otherwise, If someone replies to just one of them (i.e. not subscribed to the other), you will miss it.

NNTP protocol, on the other hand, is distributed, the IDs are shared, and one post, no matter to what group or what server, is the same, and you get just one single copy of that post. It _will_ appear in multiple groups, but it will be the same post, and if you reply to it, it will get distributed to all newsgroup servers, and nobody will miss any reply in any of the groups the conversation goes in (cross-posted groups).

6) Missing posts when not subscribed

When you're not subscribed, you don't get the posts. And after you subscribe - you still don't get the old posts. That's really one of biggest disadvantages - which other asynchronous channel does this? Forums let you see the old posts. Google groups do. Stack overflow does. Twitter does. Facebook does. Youtube does. Wherever you "subscribe" to some content, you get the old stuff. Except mailing lists.

Of course, there are archives. But how convenient is that? Leave your mail client and go search in the ugly Mailman UI from 90's? Thanks, but no thanks.

NNTP protocol, needless to say, allows you to download whatever you want, just what the server keeps in it's archive (some delete old posts).

7) Security reasons

You want to bring a mail to broader audience. But wait! Is the original list private list? Public list? And what about the 2nd list? How the hell should I know? Well, you need to go check the domain name. And even then, you still don't know - different list, different policy. You have to remember. If you forward a mail to another list, nothing prevents you to do so, or better said, nothing reminds you not to do so.

NNTP, on the other hand, supports mechanisms to refuse forwarding of a post based on the ID's of the posts contained in the post's headers. Sure, you could do it with mails, too; but it's up to mail client if it forwards the MIME headers or not. It's not mandatory for the protocol. For NNTP, it is, so a good client should send them, and your SMTP server (often the same instance as your local NNTP server) will refuse to send the post.

On par

There are areas where NNTP is just like mails. It's the same format (MIME), after all. And NNTP is quite similar to SMTP.

For example, most mainstream email clients support NNTP: ThunderBird, Evolution, Outlook (even the old Outlook Express did), ...

Basically you work with NNTP the same way as with mails; only, the addresses are group names such like "org.jboss.windup.users".

And you can even mix recipients - a post can go as mail to some users, and to a newsgroup.

Let's revive NNTP

With the above said, I really don't get why companies run mailing lists. What advantage mailing lists give? Waste of storage on server, waste of bandwidth, waste of user's disk space, waste of CPU on mail servers, waste of people's time. It's not even simpler or anything. It's just that people are used to it, or rather, don't know about newsgroups at all.

Let's spread the word about newsgroups. It's one of the best things that came from internet's stone ages, and should not be forgotten.

Share this article if you agree, and let me know in comments.

Good news!

Windup rules, when written in Java syntax (instead of XML), is now much nicer, after we did [WINDUP-409] in PR #380 @Rules( phase = ..., .... by OndraZizka .

Before, metadata were provided by callback methods. Combined with our insisting on space-wasting formatting, each piece of metadata required 5 lines in class source.

public class SkipArchivesRules extends WindupRuleProvider
{
    private static final Logger log = Logging.get(SkipArchivesRules.class);

    @Override
    public void enhanceMetadata(Context context)
    {
        super.enhanceMetadata(context);
        context.put(RuleMetadata.CATEGORY, "Java");
    }

    @Override
    public List<Class<? extends WindupRuleProvider>> getExecuteAfter()
    {
        return asClassList(IdentifyArchivesRules.class, SkipArchivesLoadConfigRules.class);
    }

    @Override
    public List<Class<? extends WindupRuleProvider>> getExecuteBefore()
    {
        return asClassList(DecompileArchivesRuleProvider.class);
    }

    @Override
    public Class<? extends RulePhase> getPhase()
    {
        return Implicit.class;
    }
...

Now it's just one line with annotations:

@RuleMetadata(tags = "java", after = {IdentifyArchivesRules.class, SkipArchivesLoadConfigRules.class}, before = {DecompileArchivesRuleProvider.class}, phase = DependentPhase.class)
public class SkipArchivesRules extends AbstractRuleProvider
{
    private static final Logger log = Logging.get(SkipArchivesRules.class);
...

Isn't it great improvement?