Ever suspected that a smurf maybe living in your PC?
The infestation may be more real than you think!

Conspiracy Theory #1 The Operating System

Ever used Linux? One of the more popular varieties of the Linux
Operating System is called Red Hat. Now we all know Papa Smurf
wears a red hat and we all know that Papa smurf knows best!
Subliminal messages I hear you say?
I think there is something in that for all of us, don't you?

Conspiracy Theory #2 The Computer Language

Date: Mon, 18 Oct 1993 15:05:47 -0400 (EDT)
From: Steve Dunham <dunhams@cl-next4.cl.msu.edu>
To: dunhamda@cl-next4.cl.msu.edu
Subject: SMURF!

A mere six months after its creation at the University of Waterloo, Microsoft and Borland have announced the release of IBM PC-based compilers for the popular SMURF programming language. From MicroSMURF (a division of Microsoft devoted to SMURF) we will see WinSMURF by July '94. From Borland we'll see Borland SMURF++ by August '94. Wait a Second... What the HECK is SMURF? For those of you who haven't heard of SMURF, I'll enclose the following press release, dated April 9th, 1993 --------------------------------------------------------------------- Waterloo Announces the Release of SMURF Prof. B. W. Becker of the University of Waterloo has officially released his unix based SMURF compiler to the world. Developed at UW to provide a powerful object-oriented programming language for second year CS students, SMURF is a powerful and yet simple language well suited to a teaching environment. SMURF stands for Short Modular Un-Recursive Function. A brief introduction to SMURF follows. SMURF is Short SMURF programs are, by necessity, very short. An individual SMURF program can't contain more than four function-calls. For example, a SMURF module might contain one variable assignment, one function which acts on this variable, one call to another SMURF, and a return function which passes the modified variable to the previous SMURF. Each smurf module can access only one variable, called SMURF. SMURF is Modular SMURF programs may only contain four function calls, but you can have thousands of the little fuckers working together. Picture your CPU, swarming with SMURFs, each perform its own little job without giving a shit about what the other SMURFs are doing, how much CPU time its taking up, or who actually owns that file you told it to erase. SMURF is un-recursive As Bill Gates so eloquently said in his '91 interview in BYTE magazine "recursive programming sucks!" To combat this archaic programming style, a SMURF function can not call itself. Complex function-tree-structure analysis built into the SMURF compiler makes sure that sneaky programmers can't trick the SMURFs. SMURF has (duh) functions Function: If you don't know what these are, you must be very confused by now. SMURF Modules A programmer writing in SMURF must quickly learn the 100 or so different kinds of SMURF modules. Rather than have libraries which link different kinds of functions into a module, each library has its own kind of SMURF module which it automatically links to. The downside of this is that you can't use functions from two different libraries in the same module. When you're dealing with a maximum of four function calls per module, this usually isn't much of a problem. Several kinds of SMURF modules are described below. PapaSMURF: This is the main module, the progenitor of all other SMURFs. It does nothing but execute other SMURF modules. In other words, it bosses the other SMURFs around. There can only be one PapaSMURF. SMURFette: This module has no function libraries linked to it. It accepts no parameters. It returns no values. It is incapable of input or output. In other words, it performs no useful function in a SMURF program. It can, however, link to any other SMURF module. SMURF project-chief Yohan claims "it keeps the other SMURFs happy, and hard working". There is only one SMURFette, and in large SMURF programs especially, she gets linked constantly. The SMURFette module must be linked to the PapaSMURF module, and in multitasking SMURF programs, PapaSMURF's call to SMURFette have priority over all other calls. BrainySMURF: This module performs all the input and output functions available in SMURF. In other words, whenever you want user input, or wish to output information to the screen, you have to call BrainySMURF. The BrainySMURF library is one of the most criticized parts of SMURF. The input routines work fine, but the output routines are slow and tend to include extraneous information. You can have as many BrainySMURF modules as you want, but you'll wish you had less. ClumsySMURF: Whenever you define your SMURF variable in a module, you'll use some memory. SMURF doesn't reclaim this memory when the module is exited, you have to destroy the variable using ClumsySMURF if you want that. If you ever have more than one ClumsySMURF module running simultaneously, chances are they'll get confused, and start randomly destroying memory. HeftySMURF: This module moves information from one memory location to another. Whenever you want to assign a variable or copy a list, you've gotta call HeftySMURF. There are hundreds more. Type "man SMURF" for more information. Hello SMURF! For those of you who are confused, I'll show you an example SMURF program. Note, each of these is a separate module-file, the name of which is given. Papa.SMURF SMURF! { Link Smurfette.SMURF; Call Brainy.SMURF.Smurf-them-hello-Brainy; } ENDSMURF. Smurfette.SMURF SMURF! {} ENDSMURF. Brainy.SMURF.Smurf-them-hello-Brainy SMURF! { SMURF = Call Hefty.SMURF.What-is-their-name-Hefty; OutSmurf("Hello "SMURF); Call Clumsy.Destroy-this-name-for-us-Clumsy(SMURF); ReSMURF(); % Poor Brainy didn't get to SMURF with SMURFette } ENDSMURF. Hefty.SMURF.What-is-their-name-Hefty SMURF! { CreateSmurfString(SMURF); Call Brainy.SMURF.Ask-them-their-name-Brainy(SMURF); Link Smurfette.SMURF; ReSMURF(SMURF); } ENDSMURF. Brainy.SMURF.Ask-them-their-name-Brainy(SMURF); SMURF! { SMURF = GetStringSMURF("What the smurf is your name?"); % Ha, this time I will SMURF her good! Link Smurfette.SMURF; ReSMURF(SMURF); } ENDSMURF. Clumsy.SMURF.Destroy-this-name-for-us-Clumsy(SMURF); SMURF! { SmurfWithAHammer(SMURF); Link Smurfette.SMURF; ReSMURF(); } ENDSMURF. Of course, this is a very simple program, which is why so little code was needed. The 420 megabyte example source code for CalcuSMURF"(a non smurfentific...er...scientific calculator), which comes on CD-Rom with WinSMURF, gives a much better demonstration of the power of SMURF. SMURF can be ftped at mushroom.uwaterloo.edu. --------------------------------------------------------------------- cbnorman@descartes.uwaterloo.ca "Have a smurfy day!" - Bill Gates SMURF project manager