Check this out:
I can watch the JBoss Mail Server Forum from my Firefox feeds. Its the same way you can read your favorite blog. I wish I could say it was increadibly straightforward, but the forums don't yet put that little HTML tag at the top that advertises this feature:
<link rel="alternate" type="application/rss+xml" title="RSS 2.0"
However you can just create a new live bookmark by clicking the little orange icon at the lower right-corner of the browser. Then right click on the new Live Bookmark, click properties. Then replace the feed URL with: http://www.jboss.org/modules/bb/rss?f=186 for the JBoss Mail Server forum. Since this is the most important forum, do that right now.
If you want to watch other forums you can do the same thing by just capturing the forum's id (it is displayed at the end when you go the the main page of that forum).
The feeds are listed in the same order as they are in the forum, meaning things that are stuck to the top...stay at the top here too. Its a convienient way to watch ongoing topics. It would be nice if you could get comment feeds too, but that is not yet supported.
Personally, I usually think that the tech industry has gotten a little too "standards happy". Moreover, I think that good standards need "extension points" that ensure extended capabillity without sacrificing compatibility. J2EE has a good and bad history with this.
On one hand, each appserver has different strengths and weaknesses. On the other hand, sometimes these change how you write your code. For instance, clustering options. If you are aware that you'll have a mid-tier proxyless load balanced RMI implementation (ala JBoss -- confusingly provided via dynamic proxies) you might write your code a little more liberally on its remote call usage than if you know you'll have a mid-tier proxy balanced RMI over IIOP implementation. If you know your appserver has an RMI/HTTP implementation then you might not swallow all of web services just to do site-site communication within your organization accross firewalls.
Still, standards should assure the code will still run (at least badly) between servers provided you've been careful ("import com.bea.*" would be a good clue). And where that falls apart they should assure that the "able" in "portable" (meaning able to be ported which isn't a synonym for "plug n' play") isn't a huge effort. I think despite all of the whining, J2EE deserves a lot of credit here. Personally, I've been a long time critic of the Java Community Process (my own opinion only) mainly because I think good APIs are designed via code not by committee discussions, but getting the major players to come to the table deserves some commendation (whoa did I say something nice about the JCP). Open source is really starting to thrive and drive this. Let's face it. The programming model and even some of the technical decisions behind EJB 1.x-2.x sucked. EJB 3 is really a whole different beast. Built on the core provided by J2EE but really kind of a "how real Java developers think" approach.
Lastly, standards should assure integration at the protocol layer. The W3C and really open source has done a lot in this area. Examples from Apache to Sam Ruby's spawning the Atom effort (originally called Pie and then NPie IIRC) among many other examples. However, I think this is an area we have a lot further to go. Web Services has created a huge number of specs and I'm getting a bit of de ja vu from the CORBA days (though I mostly observed). Now we are approaching a potential integration brick wall as companies create road blocks in the form of software patents. Moreover, not all web services implementations actually work together properly the way they are supposed to. Standards are a good faith effort and sometimes the faith isn't that good and other times... well... we kinda screw it all up, as is probably the case with Apple's iTunes syndication and Disney's Gears behind the Ears (there you go Sam).
Driving this process has been new techniques of communication. When I first installed this blog and invited the other JBoss guys to post on it, it was treated with some trepidation as was the JBossWiki. However, I think you can see they've been fully embraced here, especially by management. I'm not going to hype cluetrain because it was written like some kind of weird manifesto anyhow, but new standards like syndication are changing the way we communicate. It even appears to be working...mostly! More importantly the way we communicate is changing the way standards and technology in general are created. I think this is why things tend to fall short of our expectations. Conway's Law is nearly inescapable and we need to create better communication and structures of communication to counter balance this or we are just stuck.
That's actually one of my major goals for JBoss Mail Server. I want to do more than build just a mail server but to really change the way we communicate. I want to do more than kill spam for good, but find ways to make effective communication easier. Of course, we have to walk before we run, but I think we'll get there. Its really about trying to think different and drive the standard forward. For instance, why are IM and mail different at the lower levels? Why can't we syndicate our HAM to kill our spam? Why do 12 copies of the same attachment get sent rather than one get syndicated and why do I have to deal with that oppressive document management system just to make that happen? Why can't my email just arrange itself topically and appropriate materials syndicate automatically? Drag the standards forward kicking and screaming if we must, while making sure we stay compatible and continue to communicate.
That being said, what do I do about how bad JavaMail sucks, especially performance-wise (maybe a big synchronized singleton hashmap for all the mime types wasn't such a great idea)?