"Forget Fen-Phen! Not Weightloss"

"Email Photos to Friends & Family * Display on Website * Save on your Computer!"

"Balding? New Medications Regrow Hair"

"Best Selling Software---Try It FREE!!!"

One of my email addresses have been made public (sold???) and is now in the hands of the 1990s version of the "Snake Oil Salesman." A day doesn't go by where I'm not bombarded with enticing offers to lose weight, regrow my hair, improve my sex life or get rich quick. I've even received solicitations by the companies that create the spamming software, and for a price, I too, can become a spammer.

So it seems that a popular use of a modern day OS is for email spamming, which got me thinking, with the BeOS we have the most modern of modern OSes and yet there is no spamming program. So the point of this newsletter article (besides fulfilling my obligation to provide this week's Insight) is to remedy this situation (for better or worse).

Our "Marketing Tool for the 90s" will build on mail and query features built into the BeOS. For simplicity, our tool will be command line based and will take three arguments: subject; message file path; and the predicate for an address book query.

(What address book you ask? There is a crude version built into the Preview Release; a more fleshed out version will be available with a forthcoming update to the Preview Release).

We start by constructing a BApplication and overriding the ArgvReceived() and ReadyToRun() methods. The ArgvReceived() function does some simple sanity checking of the parameters, opens and buffers the message content, and calls the Spam() function to do the processing. The ReadyToRun() function alerts the user if the application was executed incorrectly and quits the application:

class TSpamApp : public BApplication {

private:

bool      fArgvCalled;

public:

TSpamApp(void);
virtual void  ArgvReceived(int32, char**);
virtual void  ReadyToRun(void);
void      Spam(char*, char*, char*, off_t);
};


TSpamApp::TSpamApp(void)
  : BApplication("application/x-vnd.Be-SPAM")
{
  // init flag that ArgvReceived has been called
  fArgvCalled = FALSE;
}


void TSpamApp::ArgvReceived(int32 argc, char **argv)
{
  char      *message;
  BEntry    entry;
  BFile     file;
  BMessage  msg(B_REFS_RECEIVED);
  off_t     len;
  status_t  result;

  // flag that ArgvReceived has been called
  fArgvCalled = TRUE;

  // make sure we have the right amount of arguments
  if (argc != 4) {
    printf("USAGE: Spam subject path query\n");
    return;
  }

  // try opening message file
  entry.SetTo(argv[2]);
  file.SetTo(&entry, O_RDONLY);
  if (file.InitCheck() != B_NO_ERROR) {
    printf("ERROR: failed to open message file %s
           [0x%.8x]\n", argv[2], file.InitCheck());
    return;
  }

  // buffer message content
  file.GetSize(&len);
  if (!(message = (char *)malloc(len))) {
    printf("ERROR: failed to allocate message buffer
           (need: %Ld)\n", len);
    return;
  }
  file.Read(message, len);

  // start spamming
  Spam(argv[1], argv[3], message, len);
  free(message);
}


void TSpamApp::ReadyToRun(void)
{
  if (!fArgvCalled)
  // we got here because we were dbl-clicked or launched
  // without arguments
    (new BAlert("", "USAGE: Spam subject path query",
                "OK"))->Go();
  PostMessage(B_QUIT_REQUESTED);
}

The Spam() function performs the query that the sucker^H^H^H^H^H^Hrecipient list is generated with. It also calculates how many messages were queued successfully and provides a list of all recipients (using their real names):

void TSpamApp::Spam(char *subject, char *predicate,
                    char *message, off_t len)
{
  char          *name;
  char          *address;
  int32         count = 0;
  BEntry        entry;
  BFile         file;
  BMailMessage  *mail;
  BQuery        query;
  BVolume       vol;
  BVolumeRoster volume;
  attr_info     info;

  // construct new mail message and add our enticing
  // subject and message
  mail = new BMailMessage();
  mail->AddHeaderField(B_MAIL_SUBJECT, subject);
  mail->AddContent(message, len);

  // set up query on boot volume using passed in predicate
  volume.GetBootVolume(&vol);
  query.SetVolume(&vol);
  query.SetPredicate(predicate);

  // start query
  query.Fetch();

  // loop while we have items that match predicate
  while (query.GetNextEntry(&entry) == B_NO_ERROR) {
    file.SetTo(&entry, O_RDONLY);

    // make sure file opens ok and has email attribute
    if ((file.InitCheck() == B_NO_ERROR) &&
       (file.GetAttrInfo("PERSON:email", &info) ==
       B_NO_ERROR) && (info.size > 1)) {

      // create space for email attribute and read it in
      address = (char *)malloc(info.size);
      file.ReadAttr("PERSON:email", B_STRING_TYPE, 0,
        address, info.size);

      // we will use a BCC field since that's what other
      // spammers seem to do. BCC fields are suppressed in
      // the message and are only used for building the
      // recipient list.  The TRUE parameter means to
      // clobber any previous entries set for this field
      mail->AddHeaderField(B_MAIL_BCC, address, TRUE);

      // attempt to queue message
      if (mail->Send(FALSE) == B_NO_ERROR) {
        count++;
        printf("  QUEUED: ");
      }
      else
        printf("  FAILED: ");

      // get recipients real name
      if ((file.GetAttrInfo("PERSON:name", &info)
           == B_NO_ERROR) && (info.size > 1)) {
        name = (char *)malloc(info.size);
        file.ReadAttr("PERSON:name", B_STRING_TYPE, 0,
          name, info.size);
        printf("%s (%s)\n", name, address);
        free(name);
      }
      else
        printf("%s\n", address);
      free(address);
    }
  }
  delete mail;

  // now send all queued mail
  if (count) {
    send_queued_mail();
    printf("Spammed %d suckers\n", count);
  }
  else
    printf("No recipients found\n");
}

And let's not forget the main just for completeness:

int main(void)
{
  TSpamApp  *myApp;

  myApp = new TSpamApp();
  myApp->Run();

  delete myApp;
  return B_NO_ERROR;
}

With this simple application and the following command I can target my message to a specific audience:

$ Spam 'Reduce coding time by two thirds' blatant_lie.txt
       PERSON:group=*bedevtalk*

"Real Name" POP_User_Name@Domain_Name

So... You've been to the latest BeDC have you? Well, did you see the naked people riding their bicycles in the rain?

I tell you, I've always had a certain amount of fear and trepidation when it comes to travelling to the East coast of the United States. I always thought it was my fear of getting stuck in a snow storm, but now I know the real fear is that there are some real loonies out there! And I lived in Berkeley for several years.

Moving the BeDC to the east caused several of our demos to crash. What an unheard of event. The demo gods definitely were not smiling upon us on the 4th. But, to the credit of the Be OS community, most developers were quite pleased and excited to see the latest and greatest stuffs. If you were there you may have seen Doug Fulton's paper detector sample application, or Jean-Louis' likeness in more than one 3D application. I think the most exciting thing came with Pierre's demo where he did a Jean-Louis head in a temple setting with lots of butterflies flying around. To top this one off, it was accelerated with the 3Dfx chip set, so it was nice, smooth, and fast with nice textures to boot. This was due to the combined efforts of Geoff's glide library support and George being inspired enough to create an accelerated version of the 3D Kit in short order.

Speaking of acceleration, what's all the hullabalu about this 3Dfx chip set anyway? As I've said in the past, this chip set is arguably one of the most popular in PC class boards today. Their relatively low cost and tremendous speed have made them the target of affection for the latest and greatest games on the PC platform, and now the BeOS. So what about acceleration? We have played with Mesa, which is a freely available OpenGL®-like implementation. Brian Paul, the author, will tell you that it's not OpenGL®, is not an OpenGL® licensed product, and it does not necessarily run the OpenGL® conformance test suite. But I use it anyway because it allows us to do accelerated OpenGL® right now today.

Where does that leave our licensed OpenGL® implementation? We are currently working to extend our OpenGL® implementation to make it more easily accept hardware acceleration in the future. Be Inc. is not putting Mesa out as a replacement for our own implementation. In DTS we felt it would be extremely beneficial to have a implementation of OpenGL® that took advantage of hardware acceleration. Mesa is freely available, and it didn't require too much work on our part to make it available. So there you have it. Mesa is available today, our own extensible OpenGL® will be out in the future, with more hardware support following.

How can one describe MacWorld? Well, after 2 days straight of our own conference, head on over to the World Trade Center and do some more time over there. Booth duty is fun. No really. When you're assigned to what we call the "large demo" you get to see massive crowds at every one of your demos. Giving this demo is likened to inciting a riot. You slowly build up from one application to the next, each time running more applications at the same time. In the finale, when you have 4 QuickTime movies playing along, with pulsating 3D objects, CD sound, digitized stereo sound, and DOOM playing in the background, while you're browsing web pages on your desktop...the pulse tends to quicken.

And the most fun of all, once you've shown all this, you look at the crowd with the wry vampire smile and yell at the crowd, "DO YOU WANT TO DO THIS TO YOUR MAC?" and they wildly and desperately respond "YES!!" and they faint to the ground. And the sweetest response you could give, "of course you do, and you can, because today the BeOS is freely available, here, just take this disk and install it on your Mac." They blink a couple of times, and ask how the demo is crippled, and you tell them, no timeout, not limitations, go ahead, take it, the first one's free.

It's also very gratifying to be able to yank people into our booth by showing them third party applications that are actually shipping. This is a big moment in the history of the BeOS. With the exception of LCS and Metrowerks, this is the first time commercial apps are shipping for the BeOS. In our booth we were selling the BeSpecific disk and Audio Elements from Adamation, and Be Basics and BeStudio from BeatWare. Time and again people would ask, how do I do word processing, and I would say, Just buy BeBasics and you're all set. I think the whole community should be grateful to these early developers for making bold moves towards commercial success. When investors and users see that there are companies making a successful go of it commercially, they tend to pay more attention and vote with their own dollars.

So, I went out to dinner with the Adamation crew on one occasion, and it was very interesting. The topics covered in conversation ranged from Cockney Rhymes to sawed off bee bee guns. From Roswell conspiracies, to the domination of a new digital media environment. You simply had to be there to understand why we were all rolling on the floor laughing for 3 hours, but since you probably weren't, suffice it to say, that the BeOS community is a lively and kickin' place, and there's nowhere else I'd rather be at the moment. Besides, I've picked up quite a few CDs of dance music, and I'm anxious to try them out with that nifty Pulsar Application.

See you on the Front.

We get many questions, in person or via e-mail, regarding the Microsoft/Apple deal and, of course, I have an opinion, actually more than one. But too much has been written already on the short-term impact, the loaded symbolism of last week's events at Apple. I'm more interested in mulling over the longer-term consequences and, for this, I'd like to see a few more specks of dust settle down. In particular, I'd like to understand the meaning of the unexpected silence on some loaded topics.

As for our little company, we had a great week for one reason: BeOS developers. Monday and Tuesday, August 4th and 5th, we held a Developers' Conference at the Haynes Convention Center, ending with a Masters Awards party at the Boston Computer Museum. Pierre Raynaud-Richard also presided over a 24-hour 3D Kit programming contest.

On a parallel thread, Alex, Wes and I got up at 1:30am Tuesday morning, drove up to New York in the rain, gave an investor presentation, and came back to Boston in time for another early afternoon meeting. We won't do this too often, I hope, but it felt good seeing BeOS applications emerge as we were evangelizing investors.

As reported elsewhere, the Masters Awards generated over 100 submissions and the quality was such that we had some really difficult decisions on our hands. I won't state here what my favorites are, but I can say I'm impressed with the overall quality and creativity, as well as the way they express unique features of our OS, such as the combination of multi-processing and multi-threading, and the resulting agility and bandwidth.

The same is true of the 3D hackfest. With the first release of our 3D Kit, the programming contest provided a test of the expressive power and efficiency of this new addition to the BeOS. The traditional rotating kettle, familiar to OpenGL® programmers, now serves as a mirror for an orbiting cow textured on the fly, inevitably leading to jokes about an impending presentation of the Intel version to Gateway (no such plans at this time).

The conference consisted of technical sessions mixed with demonstrations of new products by BeOS developers anxious to trot their creations before an audience of their peers. This tested our product in places that probably hadn't been touched before—meaning we discovered fresh new bugs and gained a sense of urgency for the search-and-destroy expedition now taking place in our office. The 28,000 copies of the Preview Release we distributed at MacWorld are certain to provide us with more feedback and opportunities to refine our product.

As is now usual, but we don't take it for granted, our Macworld Expo booth was well attended. The Intel BeOS demonstration was received with an open mind (Apple probably helped by committing to Intel versions of Rhapsody), and the performance, even at this early stage, drew positive comments.

The highlight was the presence of BeOS developers—Adamation, Fusion Development, purity, ro design, and TruSpectra—in our booth, with BeatWare in a nearby booth of their own. We now see the beginnings of commercial applications on our platform; some of them were on sale and sold well at the show. I even saw BeOS software, including our $49.95 retail package, sold at the Developer Depot booth in the Apple pavilion.

Just as important, what emerges in common from these new applications is that the BeOS adds one letter to WYSIWYG, the letter N—for NOW. Real-time WYSIWYG, if you will, instead of watching the hourglass icon. This isn't just about getting tasks done faster and more securely; just as important, this is about preventing wait-time from intruding on the flow of creative thoughts. Such a benefit applies beyond multimedia creation: Ask a programmer how s/he feels waiting around for a compile.

This said, we're now in the process of broadcasting a million units of the BeOS for the remainder of this calendar year. My heartfelt thanks to all who helped prepare and deliver last week's events and motivated us to do even better in the future.

BeDevTalk is an unmonitored discussion group in which technical information is shared by Be developers and interested parties. In this column, we summarize some of the active threads, listed by their subject lines as they appear, verbatim, in the mail.

To subscribe to BeDevTalk, visit the mailing list page on our web site: http://www.be.com/aboutbe/mailinglists.html.