Permalink | Leave a comment  »

Permalink | Leave a comment  »

Permalink | Leave a comment  »

Permalink | Leave a comment  »

Last summer I gathered together a few of my recent tracks and uploaded them to Last FM as Summer EP. I didn't really push it much and it was only really an EP because Last FM prefers it if you create an "album" rather than uploading individual tracks :)

Anyway yesterday someone asked me on twitter if I could send them some of my tracks for a radio show. And at that point I discovered that I still had the original ZIP file of the 320K mp3s that I had uploaded (that's a nice feature, thanks Last FM!) So rather than mail the file (google mail was struggling with the size of the message,) I uploaded it to rabidgravy.com so I could share it more widely.

Download the whole EP as single ZIP file here.

So here you have it, last summer's Summer EP. Download it, play it, blog about it, share it with your friends and enjoy it. Let me know what you think either with a comment here or on the Soundcloud tracks below.

I'm always interested in doing live performances, suggestions for remixes and ideas for other collaborative projects, e-mail me or contact me via twitter.

Test Tube by Rabid Gravy Accidental Ambience by Rabid Gravy Tunnel by Rabid Gravy Terminal Building (Harder Wider mix) by Rabid Gravy Revolution by Rabid Gravy Lifetime Of Dither by Rabid Gravy

This work is licensed under a Creative Commons Attribution 3.0 Unported License.

Permalink | Leave a comment  »

Permalink | Leave a comment  »

Permalink | Leave a comment  »

Permalink | Leave a comment  »

Permalink | Leave a comment  »

via netaudiolondon-op.heroku.com

I'd really like to play this gig. if you haven't already get in there and drop a vote. It's going to be great,

http://netaudiolondon-op.heroku.com/

Permalink | Leave a comment  »

Permalink | Leave a comment  »

via meeblip.noisepages.com

I've just ordered one of these. It's revolutionary, a completely opensource digital synthesizer - both the hardware design and the software are completely open and free to alter in any way you see fit.

It's going to sound great too.

Permalink | Leave a comment  »

Permalink | Leave a comment  »

The Freesound Challenge is about making a work of audio creativity using a random selection of samples from the wonderful Freesound Project like a sort of musical "Scrapyard Challenge" but with audio samples rather than actual junk[1].  To this end I've created the group on Soundcloud - the following is from its description:

The Freesound Challenge is an experiment to see how creative people can be in creating music with constrained raw materials using the wonderful resources found at The Freesound Project.

Clearly you also need to have an account at Soundcloud but I'm guessing that it's as ubiquitous among people who like to make noise and share it as Flickr is with those with a camera :)

I'm really looking forward to hearing some really exciting works and I'm sure there are plenty of other people who will be excited by it too.

As alluded to above I'd be interested in making a Net Label release of the best examples, but let's see how it goes first. 

This has got to be more fun than some "remix competition" if only because we don't have the faintest idea of what kind of stuff we are going to get :)

Tell your friends, tell the press. Let's have some fun with noise :)

[1]  I'd like to do a real musical "Scrapyard Challenge" too but this requires some physical organisation, a venue and a "scrapyard" of musical (or potentially musical) junk. If you've got any ideas how this can be achieved get in touch :)

Permalink | Leave a comment  »

The Voodoo Slices EP is now released.  You can listen at Last.fm or download the tracks in various formats from Gravy Sounds on archive.org or whole thing as a ZIP file of 320K MP3s here.

I've been fortunate enough to obtain some fantastic remixes of my track "Voodoo Slice", these guys need some praise for crafting gems from such rough raw materials.

Lemon slice by DyLABs

Voodoo Slice (kongsized remix) by kongsized

Rabid gravy-Voodoo Slice ( vik44 remix) by vik44

Voodoo Slice by Rabid Gravy

And this is the cover by the lovely Kev Gater

Many thanks to the wonderful producers for the remixes and Kev for the great artwork.

Hope you enjoy it.

Permalink | Leave a comment  »

Permalink | Leave a comment  »

Permalink | Leave a comment  »

Permalink | Leave a comment  »

I can't work out whether these idiots have either just spewed verbatim part of their templating code or have simply and naively chosen the wrong text randomly from the net in a vain attempt at defeating content based spam filters, in which case why didn't they just use Wikipedia - after all that is what it's for right?

Anyway, nice one spammers. I knew you were scum before but now I know you're stupid scum too ...

Return-Path: <info@irate.blue-ruinous.com.net>
X-Spam-Checker-Version: SpamAssassin 3.2.5 (2008-06-10) on coriolanus
X-Spam-Level: ***
X-Spam-Status: No, score=3.4 required=5.0
 tests=BAYES_50,DNS_FROM_OPENWHOIS,
 HTML_MESSAGE,HTML_MIME_NO_HTML_TAG,MIME_HTML_ONLY,MIME_HTML_ONLY_MULTI,
 MPART_ALT_DIFF autolearn=no version=3.2.5

....

X-DomainKeys: Sendmail DomainKeys Filter v1.0.2 mail.bensalembedroom.com
 E1D58ED9EEA
X-DKIM: Sendmail DKIM Filter v2.8.2 mail.bensalembedroom.com E1D58ED9EEA
MIME-Version: 1.0
Precedence: bulk
From: Important-Wire-Notification<info@irate.Blue-Ruinous.com>
To: me@mail.bensalembedroom.com
Subject: 1500Usd Wired to Your Bank_Account in 2Mins - 93% Apps_Approved
List-Unsubscribe: <mailto:care@mail.bensalembedroom.com>
Reply-to: <info@irate.Blue-Ruinous.com>
Z-PID: 184197610|gm|216.66.240.36|2010-06-24|5754|alm02
Content-Type: multipart/alternative;boundary=np4c236147e12fb
Message-Id: <20100624134439.E1D58ED9EEA@mail.bensalembedroom.com>
Date: Thu, 24 Jun 2010 08:44:39 -0500 (CDT)

This is a MIME encoded message.

--np4c236147e12fb
Content-type: text/html;Content-Disposition: inline

<div style="color:#FFFFFF; font-size:0.001px; line-height:0.001%"> Complete the final_step by filling out this 2.Minute form. No Faxing_required!
   => "right_arrow png",

    eval   $out = $lh->SUPER::maketext(@stuff) };

While you can use arbitrary unique IDs for lexicon keys (like "_min_larger_max_error"), it is often useful for if an entry's key is itself a valid value, like this example error message:

            $lh = $class->get_handle($chosen_language)
        $lh = YourProjClass->get_handle(

  use ThisProject::I18N;
      $lh->init();
        $lh = Projname::L10N->get_handle(  ) || die "Language?";
  "I ate [quant,_1,rhubarb pie[ "
    return join '',
      
LANGUAGE CLASS HIERARCHIES

and then I can use it as:
An object belonging to a language class is called a "language handle"; it's typically a flyweight object
    * An item "_*" is interpreted to mean "all of @_ except $_[0]"  I e , @_[1 $#_]  Note that this is an empty list in the case of calls like $lh->maketext(key) where there are no parameters (except $_[0], the language handle)

   # that we load class ThisProject::I18N::en
  
  } 
      
      If you get tired of constantly saying print $lh->maketext, consider making a functional wrapper for it, like so:

One possibly useful value for the "fail" attribute is the method name "failure_handler_auto"  This is a method defined in class Locale::Maketext itself  You set it with:

  "Minimum ([_1]) is larger than maximum ([_2])!\n",
      YourProjClass->fallback_languages()

  } 
 
  $lh->fail_with( undef );
            $lh = $class->get_handle()
The "fail" attribute can be accessed with the fail_with method:
  else            $pod_bay_door->leave_closed() } 
(This is meant to be somewhat like the AUTOLOAD mechanism in Perl's function call system -- or, looked at another way, like the AutoLoader module )
      $lh->foo(" _1 ", " bar ", "baz"),  #!!!
The group as a whole is interpreted as follows:

         "[quant,_1,document was, documents were] matched \n" 

  => "Couldn't find file \"[_1]\"!\n", 
While the key must be a string value (since that's a basic restriction that Perl places on hash keys), the value in the lexicon can currenly be of several types: a defined scalar, scalarref, or coderef  The use of these is explained above, in the section 'The "maketext" Method', and Bracket Notation for strings is discussed in the next section

    my($failing_lh, $key, $params) = @_;
In order to make sense of Maketext and how all its components fit together, you should probably go read Locale::Maketext::TPJ13, and then read the following documentation
      ") is larger than maximum (",

    This is generally meant to be called from inside Bracket Notation (which is discussed later), as in

  which you'd then call in a construct like this:

      You may also wish to discuss with the translators the question of how to relate different subforms of the same language tag, considering how this reacts with get_handle's treatment of these  For example, if a user accepts interfaces in "en, fr", and you have interfaces available in "en-US" and "fr", what should they get? You may wish to resolve this by establishing that "en" and "en-US" are effectively synonymous, by having one class zero-derive from the other
 
     

  to this code that uses a key-as-value:
These are to do with constructing a language handle:
  } 
In the notation discussed so far, the characters "[" and "]" are given special meaning, for opening and closing bracket groups, and "," has a special meaning inside bracket groups, where it separates items in the group  This begs the question of how you'd express a literal "[" or "]" in a Bracket Notation string, and how you'd express a literal comma inside a bracket group  For this purpose I've adopted "~" (tilde) as an escape character: "~[" means a literal '[' character anywhere in Bracket Notation (i e , regardless of whether you're in a bracket group or not), and ditto for "~]" meaning a literal ']', and "~," meaning a literal comma  (Altho "," means a literal comma outside of bracket groups -- it's only inside bracket groups that commas are special )
        print "Foobar $thing stuff\n"; 

The effect of using "failure_auto_handler" is like an AUTO lexicon, except that it 1) compiles $key even if it starts with "_", and 2) you have a record in the new hashref $lh-> 'failure_lex'} of all the keys that have failed for this object  This should avoid your program dying -- as long as your keys aren't actually invalid as bracket code, and as long as they don't try calling methods that don't exist

      Remind the translators to consider the case where N is 0: "0 files found" isn't exactly natural-sounding in any language, but it may be unacceptable in many -- or it may condition special kinds of agreement (similar to English "I didN'T find ANY files")
 

These are covered in the following section
 
    );
I can picture all sorts of circumstances where you just do not want lookup to be able to fail (since failing normally means that maketext throws a die, altho see the next section for greater control over that)  But here's one circumstance where _AUTO lexicons are meant to be especially useful:
       ref($failing_lh), "\t", $key, "\n";
      get_handle appends the return value of this to the end of the list of classes it will try using  Unless you override this method, your project class will inherit Locale::Maketext's fallback_language_classes, which currently returns an empty list, ()  By setting this to some value (namely, the name of a loadable language class), you can be sure that get_handle will always manage to construct a language handle
            # Config file missing, maybe?

    => "/styles/en_us/",

      "Couldn't find file \"[_1]\"!\n", $filename
    $lh->SUPER::init();
      return Chineeze::taiwan2mainland($value);

    Because if _1 is one, you get "1 document were matched"  An acceptable hack here is to do something like this:
    *
    return $out unless $@;

        ); 
    

         "Couldn't access datanode [sprintf,%10x=~[%s~],_1,_2]!\n" 

    * Once the program is otherwise done, and once its localization for the first language works right (via the data and methods in Projname::L10N::en_us), you can get together the data for translation  If your first language lexicon isn't an _AUTO lexicon, then you already have all the messages explicitly in the lexicon (or else you'd be getting exceptions thrown when you call $lh->maketext to get messages that aren't in there)  But if you were (advisedly) lazy and are using an _AUTO lexicon, then you've got to make a list of all the phrases that you've so far been letting _AUTO generate for you  There are very many ways to assemble such a list  The most straightforward is to simply grep the source for every occurrence of "maketext" (or calls to wrappers around it, like the above pmt function), and to log the following phrase
  $lh->fail_with('failure_handler_auto'); 

      $lh = YourProjClass->get_handle() || die "lg-handle?";

      Create a class for the language your internal keys are in  Name the class after the language-tag for that language, in lowercase, with dashes changed to underscores  Assuming your project's first language is US English, you should call this Projname::L10N::en_us  It should consist minimally of:
      
      $lh->foo( $_[1], "bar", "baz"),
 

Currently, bracket groups do not nest  That is, you cannot say:

  # Make all lookups fall back onto an English value,
    long long message 

     
      "Hoohah ",

Also, calling &$coderef($lh,   parameters  ) can throw any sort of exception (if, say, code in that sub tries to divide by zero)  But a very common exception occurs when you have Bracket Notation text that says to call a method "foo", but there is no such method  (E g , "You have [quatn,_1,ball] " will throw an exception on trying to call $lh->quatn($_[1],'ball') -- you presumably meant "quant" ) maketext catches these exceptions, but only to make the error message more readable, at which point it rethrows the exception
    my $lh = $_[0];
In other words, text outside bracket groups is turned into string

        some code here 

CONTROLLING LOOKUP FAILURE
 "Minimum ([_1]) is larger than maximum ([_2])!\n",
      will try loading the classes YourProjClass::en_us (note lowercase!), YourProjClass::fr, YourProjClass::kon, YourProjClass::i_klingon and YourProjClass::i_klingon_romanized  (And it'll stop at the first one that actually loads )
Construction Methods
          'en-US', 'fr', 'kon', 'i-klingon', 'i-klingon-romanized'

      Assuming your call your class Projname::L10N, create a class consisting minimally of:
 

             || die "Can't get a language handle";
Or you may want to override it with something that traps any exceptions, if that's critical to your program:
        use base qw(Projname::L10N);

    return join '',

    * I assume that each language class derives (directly or indirectly) from your project class, and also defines its @ISA, its %Lexicon, or both  But I anticipate no dire consequences if these assumptions do not hold
      If the first item in a bracket group is empty-string, or "_*" or "_digits" or "_-digits", then that group is interpreted as just the interpolation of all its items:

  "_main_splash_imagemap"
these rules: 
  => "Couldn't find file \"[_1]\"!\n", 
          if($preferred_language) 

  die $lh->maketext( "_min_larger_max_error", $min, $max )
$lh->fail_with or $lh->fail_with(PARAM)
Or write the "bar" method so you don't need to pass it the output from calling quux
A language class is a class containing a lexicon of phrases as class data, and possibly also some methods that are of use in interpreting phrases in the lexicon, or otherwise dealing with text in that language
            return $negative;
         #   except that we actually call numf to
   if $min > $max; 

ENTRIES IN EACH LEXICON
But it actually compiles as this:

        } 
  $lh->fail_with( 'failure_method' );
  sub init 
  => "Le minimum ([_1]) est plus grand que le maximum ([_2])!\n", 
 

A language handle is a flyweight object -- i e , it doesn't (necessarily) carry any data of interest, other than just being a member of whatever class it belongs to
  getopt('oDI', \%opts) or die $lh->maketext('_USAGE_MESSAGE'); 

$language->quant($number, $singular, $plural, $negative)

    },

            return "1 $singular";
    returning 
            return "$number $plural";
HOW TO USE MAKETEXT
  "Hoohah [foo, _1 , bar ,baz]!" 
    * I foresee no problems with having multiple inheritance in your hierarchy of language classes  (As usual, however, Perl will complain bitterly if you have a cycle in the hierarchy: i e , if any class is its own ancestor )
        $lh->that_method_name(
 

      Remember to ask your translators about numeral formatting in their language, so that you can override the numf method as appropriate  Typical variables in number formatting are: what to use as a decimal point (comma? period?); what to use as a thousands separator (space? nonbreakinng space? comma? period? small middot? prime? apostrophe?); and even whether the so-called "thousands separator" is actually for every third digit -- I've heard reports of two hundred thousand being expressable as "2,00,000" for some Indian (Subcontinental) languages, besides the less surprising "200 000", "200 000", "200,000", and "200'000"  Also, using a set of numeral glyphs other than the usual ASCII "0"-"9" might be appreciated, as via tr/0-9/\x 0966}-\x 096F}/ for getting digits in Devanagari script (for Hindi, Konkani, others)

If the language handle has no "fail" attribute, maketext will simply throw an exception (i e , it calls die, mentioning the key whose lookup failed, and naming the line number where the calling $lh->maketext(key,  ) was

          my $class = $_[0];
  "Minimum ([_1]) is larger than maximum ([_2])!\n", 
      

QUICK OVERVIEW
    But for "directory", you'd want "[quant,_1,direcory,directories]" so that our elementary quant method doesn't think that the plural of "directory" is "directorys"  And you might find that the output may sound better if you specify a negative form, as in:

$language->sprintf($format, @items)
  print $lh->maketext("You won!"), "\n"; 

    * Decide what system you'll use for lexicon keys  If you insist, you can use opaque IDs (if you're nostalgic for catgets), but I have better suggestions in the section "Entries in Each Lexicon", above  Assuming you opt for meaningful keys that double as values (like "Minimum ([_1]) is larger than maximum ([_2])!\n"), you'll have to settle on what language those should be in  For the sake of argument, I'll call this English, specifically American English, "en-US"
          my $lh;

  } 

  # In some other languages, left equals

   => "left_arrow png",

      instead do it thru maketext, using no variable interpolation in the key:

These are methods that you may find it handy to use, generally from %Lexicon routines of yours (whether expressed as Bracket Notation or not)
 
    return undef;
    

    return 0 if $answer eq 'n' or $answer eq 'non';
  sub 
      join '',

      
From then on, you use the maketext function to access entries in whatever lexicon(s) belong to the language handle you got  So, this:
        # And, assuming you want the base class to be an _AUTO lexicon,
    package YrProj::zh_cn; # Chinese with PRC-style glyphs

  } 
          my $preferred_language = $Config_settings 'language'};
            rest of items in this group 
      get_handle appends the return value of this to the end of whatever list of languages you pass get_handle  Unless you override this method, your project class will inherit Locale::Maketext's fallback_languages, which currently returns ('i-default', 'en', 'en-US')  ("i-default" is defined in RFC 2277)
would compile to this:

  sub maketext 
  %Lexicon = (
        # as is discussed a few sections up:
    If you want anything fancier, consider overriding this with something that uses Number::Format, or does something else entirely
    return undef unless defined $_[1] and length $_[1];
    Currently this isn't used for anything, but it's provided (with default value of (ref($language) && $language-> 'encoding'})) or "iso-8859-1" ) as a sort of suggestion that it may be useful/necessary to associate encodings with your language handles (whether on a per-class or even per-handle basis )
    * Otherwise, each item is interpreted as a string literal
    
  $lh = TkBocciBall::Localize->get_handle();

      "!",
      my $value = $self->maketext(@_);
METHODS
 

Brackets must be balanced -- every openbracket must have one matching closebracket, and vice versa  So these are all invalid:

As you're writing an application, you decide as you go what messages you need to emit  Normally you'd go to write this:

  if(-e $filename) 

 
      It runs thru the entire given list of language-tags, and finds no classes for those exact terms, it then tries "superordinate" language classes  So if no "en-US" class (i e , YourProjClass::en_us) was found, nor classes for anything else in that list, we then try its superordinate, "en" (i e , YourProjClass::en), and so on thru the other language-tags in the given list: "es"  (The other language-tags in our example list: happen to have no superordinates )

      Language classes are what YourProjClass->get_handle will try to load  It will look for them by taking each language-tag (skipping it if it doesn't look like a language-tag or locale-tag!), turning it to all lowercase, turning and dashes to underscores, and appending it to YourProjClass   "::"  So this:
These are Locale::Maketext's assumptions about the class hierarchy formed by all your language classes:
     
    *
 

 "Minimum ([_1]) is larger than maximum ([_2])!\n",
      YourProjClass->fallback_language_classes()
A language handle is implemented as a blessed hash  Subclasses of yours can store whatever data you want in the hash  Currently the only hash entry used by any crucial Maketext method is "fail", so feel free to use anything else as you like

  $lh->fail_with( \&failure_handler );

        join('',
    It's for quantifying a noun (i e , saying how much of it there is, while giving the currect form of it)  The behavior of this method is handy for English and a few other Western European languages, and you should override it for languages where it's not suitable  You can feel free to read the source, but the current implementation is basically as this pseudocode describes:
      If you're using localization in an application that keeps a configuration file, you might consider something like this in your project class:

        print $lh->maketext("Foobar [_1] stuff\n", $thing); 

  sub my_clever_failure_handler 
         elsif $number is 1,
  sub 

      my $self = shift(@_);
    * maketext and other methods to do with accessing %Lexicon data for a given language handle
  # to be called by $lh->maketext(KEY, params  )
        sub pmt (@)   print( $lh->maketext(@_)) }

    *

    * Once you've localized your program/site/etc  for all desired languages, be sure to show the result (whether live, or via screenshots) to the translators  Once they approve, make every effort to have it then checked by at least one other speaker of that language  This holds true even when (or especially when) the translation is done by one of your own programmers  Some kinds of systems may be harder to find testers for than others, depending on the amount of domain-specific jargon and concepts involved -- it's easier to find people who can tell you whether they approve of your translation for "delete this message" in an email-via-Web interface, than to find people who can give you an informed opinion on your translation for "attribute value" in an XML query tool's interface

 
 
      This constructs a language handle  You usually don't call this directly, but instead let get_handle find a language class to use and to then call ->new on
The "maketext" Method
 
        use Projname::L10N;

BRACKET NOTATION

 
      $lh = YourProjClass::langname->new();
  }

Otherwise, the "fail" attribute's value should be a string denoting a method name, so that $lh->maketext(key,  params  ) can give up with:

    *
      Examples: "[_1]" and "[,_1]", which are synonymous; and "[,ID-(,_4,-,_2,)]", which compiles as join "", "ID-(", $_[4], "-", $_[2], ")"
 "_min_larger_max_error"
     
    go_process_file($filename)
    
to ThisProject/I18N/en pm, because if _AUTO is true there, then just looking for an entry with the key "Couldn't find file \"[_1]\"!\n" in that lexicon will cause it to be added, with that value!
    This returns the given number formatted nicely according to this language's conventions  Maketext's default method is mostly to just take the normal string form of the number (applying sprintf "%G" for only very large numbers), and then to add commas as necessary  (Except that we apply tr/, / ,/ if $language-> 'numf_comma'} is true; that's a bit of a hack that's useful for languages that express two million as "2 000 000" and not as "2,000,000")
$language->encoding()
Now, as to what you may want to do with these handlers: Maybe you'd want to log what key failed for what class, and then die  Maybe you don't like die and instead you want to send the error message to STDOUT (or wherever) and then merely exit()

If the language handle has a "fail" attribute whose value is a coderef, then $lh->maketext(key,  params  ) gives up and calls:
      

    return 1 if $answer eq 'o' or $answer eq 'oui';
  => "",   # fill in something here, Jacques! 

    *
        sub get_handle_via_config 
        1; 
      Otherwise (i e , if not a CGI), this tries various OS-specific ways to get the language-tags for the current locale/language, and then pretends that those were the value(s) passed to cet_handle

    *
    
         #  stringify $number before returning it  
    sub maketext 
          any methods you might want all your languages to share 
      When get_handle is called with an empty parameter list, magic happens:
The normal course of action is to call:
  } else 
    my $lh = $_[0];  # a newborn handle

  "I ate [quant,_1,rhubarb pie "
  my $response;

  "_forward_icon"

Here is a brief checklist on how to use Maketext to localize applications:
         Couldn't access datanode      Stuff=[thangamabob]! 

    * You may at this point want to consider whether the your base class (Projname::L10N) that all lexicons inherit from (Projname::L10N::en, Projname::L10N::es, etc ) should be an _AUTO lexicon  It may be true that in theory, all needed messages will be in each language class; but in the presumably unlikely or "impossible" case of lookup failure, you should consider whether your program should throw an exception, emit text in English (or whatever your project's first language is), or some more complex solution as described in the section "Controlling Lookup Failure", above
         else
 

    *

You might want to do the same thing for expressing key bindings or the like (since hardwiring "q" as the binding for the function that quits a screen/menu/program is useful only if your language happens to associate "q" with "quit"!)

If you need a notation that's that powerful, use normal Perl:
        use Projname::L10N;
  "_backward_icon"
   # make a language handle from among the classes available,

Note, incidentally, that items in each group are comma-separated, not /\s*,\s*/-separated  That is, you might expect that this bracket group:

  die "Couldn't make a language handle??" unless $lh; 

    * An item that is "_digits" or "_-digits" is interpreted as $_[value]  I e , "_1" is becomes with $_[1], and "_-3" is interpreted as $_[-3] (in which case @_ should have at least three elements in it)  Note that $_[0] is the language handle, and is typically not named directly
 

"failure_auto_handler" may not be exactly what you want, but I hope it at least shows you that maketext failure can be mitigated in any number of very flexible ways  If you can formalize exactly what you want, you should be able to express that as a failure handler  You can even make it default for every object of a given class, by setting it in that class's init:
 

You may also want to read over the source for File::Findgrep and its constituent modules -- they are a complete (if small) example application that uses Maketext
 
Utility Methods
  if($response)   $pod_bay_door->open()         }

  "_general_graphics_path"
         "Your search matched [quant,_1,document]!" 
  "I ate quant,_1,rhubarb pie] "
      you clever things here 

Note that the reason that keys that start with "_" are immune to _AUTO isn't anything generally magical about the underscore character -- I just wanted a way to have most lexicon keys be autoable, except for possibly a few, and I arbitrarily decided to use a leading underscore as a signal to distinguish those few
  ) if $min > $max; 
      If none of those language-tags leads to loadable classes, we then try classes derived from YourProjClass->fallback_languages() and then if nothing comes of that, we use classes named by YourProjClass->fallback_language_classes()  Then in the (probably quite unlikely) event that that fails, we just return undef

    my $lh = $_[0];

  return & $that_subref}($lh, $key, @params); 
    *
Bracket Notation is a crucial feature of Locale::Maketext  I mean Bracket Notation to provide a replacement for sprintf formatting  Everything you do with Bracket Notation could be done with a sub block, but bracket notation is meant to be much more concise
      

    my $out;
  } 
 
  => "",   # fill in something here, Jacques 

        $Carp::Verbose = 1;
  } 
          } else 
             || die "No language handle for \"$chosen_language\" or the like";
   # and that's the class that $lh belongs to
Other than those two situations, I don't imagine that it's useful to override the maketext method  (If you run into a situation where it is useful, I'd be interested in hearing about it )

  my $lh = ThisProject::I18N->get_handle();
         # so if maketext fails, we see made the call to pmt 
But failure_handler_auto, instead of dying or anything, compiles $key, caching it in $lh-> 'failure_lex'} $key} = $complied, and then calls the compiled value, and returns that  (I e , if $key looks like bracket notation, $compiled is a sub, and we return & $compiled}(@params); but if $key is just a plain string, we just return that )
  die $lh->maketext(

    * Language classes may derive from other language classes (altho they should have "use Thatclassname" or "use base qw(  classes  )")  They may derive from the project class  They may derive from some other class altogether  Or via multiple inheritance, it may derive from any mixture of these
  "Couldn't find file \"[_1]\"!\n"

      In all cases where the very common phenomenon of quantification (saying "N files", for any value of N) is involved, each translator should make clear what dependencies the number causes in the sentence  In many cases, dependency is limited to words adjacent to the number, in places where you might expect them ("I found the-?PLURAL N empty-?PLURAL directory-?PLURAL"), but in some cases there are unexpected dependencies ("I found-?PLURAL   "!) as well as long-distance dependencies "The N directory-?PLURAL could not be deleted-?PLURAL"!)
    my $lh = $_[0];
 
      

   ^^^^^^^^^ XX ^^^^^^^^^^^^^^^^^^^^^^^^^^ XX ^^^^ 
But I consider that somewhat of a distraction from the work of getting the main code working -- to say nothing of the fact that I often have to play with the program a few times before I can decide exactly what wording I want in the messages (which in this case would require me to go changing three lines of code: the call to maketext with that key, and then the two lines in ThisProject/I18N/en pm)
    my $answer = lc $_[1];  # smash case

  } else 
    
rather than this more cryptic mess:
      (You may, in fact, want to start with localizing to one other language at first, if you're not sure that you've property abstracted the language-dependent parts of your code )

         "[quant,_1,file,files,No files] matched your query \n" 

I almost always use keys that are themselves valid lexicon values  One notable exception is when the value is quite long  For example, to get the screenful of data that a command-line program might returns when given an unknown switch, I often just use a key "_USAGE_MESSAGE"  At that point I then go and immediately to define that lexicon entry in the ProjectClass::L10N::en lexicon (since English is always my "project lanuage"):
Other data worth storing in a lexicon might be things like filenames for language-targetted resources:
  "Couldn't find file \"[_1]\"!\n"

      $lh = YourProjClass->get_handle(   langtags   ) || die "lg-handle?";

When that string is compiled from bracket notation into a real Perl sub, it's basically turned into:

It is a common feature of applications (whether run directly, or via the Web) for them to be "localized" -- i e , for them to a present an English interface to an English-speaker, a German interface to a German-speaker, and so on for all languages it's programmed with  Locale::Maketext is a framework for software localization; it provides you with the tools for organizing and accessing the bits of text and text-processing code that you need for producing localized applications
        my $lh = Projname::L10N->get_handle(  ) || die "Language?"; 

    $lh->fail_with('my_clever_failure_handler');

      The basic quant method that Locale::Maketext provides should be good for many languages  For some languages, it might be useful to modify it (or its constituent numerate method) to take a plural form in the two-argument call to quant (as in "[quant,_1,files]") if it's all-around easier to infer the singular form from the plural, than to infer the plural form from the singular

        );

  } 
  return $lh->$that_method_name($phrase, @params); 
       
$language->quant($number, $singular, $plural)

  ); 
    * You must have a project base class, which you load, and which you then use as the first argument in the call to YourProjClass->get_handle(  )  It should derive (whether directly or indirectly) from Locale::Maketext  It doesn't matter how you name this class, altho assuming this is the localization component of your Super Mega Program, good names for your project class might be SuperMegaProgram::Localization, SuperMegaProgram::L10N, SuperMegaProgram::I18N, SuperMegaProgram::International, or even SuperMegaProgram::Languages or SuperMegaProgram::Messages
If the value is a scalarref, the scalar is dereferenced and returned (and any parameters are ignored)  If the value is a coderef, we return &$value($lh,   parameters  )  If the value is a string that doesn't look like it's in Bracket Notation, we return it (after replacing it with a scalarref, in its %Lexicon)  If the value does look like it's in Bracket Notation, then we compile it into a sub, replace the string in the %Lexicon with the new coderef, and then we return &$new_sub($lh,   parameters  )

      Submit all messages/phrases/etc  to translators
Or instead of storing this in the language class's lexicon, you can (and, in some cases, really should) represent the same bit of knowledge as code is a method in the language class  (That leaves a tidy distinction between the lexicon as the things we know how to say, and the rest of the things in the lexicon class as things that we know how to do ) Consider this example of a processor for responses to French "oui/non" questions:
            return "$number "   $singular   "s";
      "!",
    print LEX_FAIL_LOG scalar(localtime), "\t",
       
         # "pmt" is short for "Print MakeText"
      otherwise deal with the exception 
Bracket Notation is a like a miniature "template" system (in the sense of Text::Template, not in the sense of C++ templates), where normal text is passed thru basically as is, but text is special regions is specially interpreted  In Bracket Notation, you use brackets ("[  ]" -- not "   }"!) to note sections that are specially interpreted
        1; 

          return $lh;
    use base ('YrProj::zh_tw');  # Taiwan-style
    *
  }
    * Otherwise this bracket group is invalid  For example, in the group "[!@#,whatever]", the first item "!@#" is neither empty-string, "_number", "_-number", "_*", nor a valid method name; and so Locale::Maketext will throw an exception of you try compiling an expression containing this bracket group
$language->numf($number)
    *

      Otherwise, each group is taken to be a comma-separated group of items, and each item is interpreted as follows:
    * If the first item in a bracket group is "*", it's taken as shorthand for the so commonly called "quant" method  Similarly, if the first item in a bracket group is "#", it's taken to be shorthand for "numf"

    These two methods are discussed in the section "Controlling Lookup Failure"
        package Projname::L10N::en_us;
            rest of items in this group 

        "\n",
 
I think that keys as lexicon values makes the completed lexicon entries more readable:

    my($lh, @stuff) = @_;

  # Set to nothing (i e , so failure throws a plain exception)
      Go and write your program  Everywhere in your program where you would say:
  EOSTUFF 

    => "/styles/en_us/hey_there wav",

    This is just a wrapper around Perl's normal sprintf function  It's provided so that you can use "sprintf" in Bracket Notation:

          }

  "_alert_sound"
        %Lexicon = (

  sub lex_fail 
      But for other languages (as is discussed at length in Locale::Maketext::TPJ13), simple quant/numerify is not enough  For the particularly problematic Slavic languages, what you may need is a method which you provide with the number, the citation form of the noun to quantify, and the case and gender that the sentence's syntax projects onto that noun slot  The method would then be responsible for determining what grammatical number that numeral projects onto its noun phrase, and what case and gender it may override the normal case and gender with; and then it would look up the noun in a lexicon providing all needed inflected forms

        use vars qw($lh);
I do not anticipate that you will need (or particularly want) to nest bracket groups, but you are welcome to email me with convincing (real-life) arguments to the contrary
  '_USAGE_MESSAGE' => <<'EOSTUFF',
      ")!\n",

    => "/styles/en_us/main_splash png",
If maketext goes to look in an individual %Lexicon for an entry for key (where key does not start with an underscore), and sees none, but does see an entry of "_AUTO" => some_true_value, then we actually define $Lexicon key} = key right then and there, and then use that value as if it had been there all along  This happens before we even look in any superclass %Lexicons!

        ), 
Language Handle Attributes and Internals

   # Depending on the user's locale, etc , this will

      If get_handle senses that it's running in program that was invoked as a CGI, then it tries to get language-tags out of the environment variable "HTTP_ACCEPT_LANGUAGE", and it pretends that those were the languages passed as parameters to get_handle

 
         elsif there's a $plural,
Also, having valid values as keys becomes very useful if you set up an _AUTO lexicon  _AUTO lexicons are discussed in a later section

Currently, an unescaped "~" before a character other than a bracket or a comma is taken to mean just a "~" and that charecter  I e , "~X" means the same as "~~X" -- i e , one literal tilde, and then one literal "X"  However, by using "~X", you are assuming that no future version of Maketext will use "~X" as a magic escape sequence  In practice this is not a great problem, since first off you can just write "~~X" and not worry about it; second off, I doubt I'll add lots of new magic characters to bracket notation; and third off, you aren't likely to want literal "~" characters in your messages anyway, since it's not a character with wide use in natural language text

An exception may be thrown if key is not found in any of $lh's %Lexicon hashes  What happens if a key is not found, is discussed in a later section, "Controlling Lookup Failure"

        some code here 
  until(defined $response) 
     
  "_main_splash_png"
Now, right after you've just written the above lines, you'd normally have to go open the file ThisProject/I18N/en pm, and immediately add an entry:
And on the off chance you need a literal tilde in a bracket expression, you get it with "~~"
Compare this code that uses an arbitrary ID 

This is the most important method in Locale::Maketext:
      This is called by ->new to initialize newly-constructed language handles  If you define an init method in your class, remember that it's usually considered a good idea to call $lh->SUPER::init in it (presumably at the beginning), so that all classes get a chance to initialize a new object however they see fit
    Note that numf is called by quant for stringifying all quantifying numbers
  sub y_or_n 

$language->language_tag()
The basic design of Locale::Maketext is object-oriented, and Locale::Maketext is an abstract base class, from which you derive a "project class"  The project class (with a name like "TkBocciBall::Localize", which you then use in your module) is in turn the base class for all the "language classes" for your project (with names "TkBocciBall::Localize::it", "TkBocciBall::Localize::en", "TkBocciBall::Localize::fr", etc )
  "I ate quant,_1,rhubarb pie[ " 
 
Incidentally, note that each class's %Lexicon inherits-and-extends the lexicons in its superclasses  This is not because these are special hashes per se, but because you access them via the maketext method, which looks for entries across all the %Lexicon's in a language class and all its ancestor classes  (This is because the idea of "class data" isn't directly implemented in Perl, but is instead left to individual class-systems to implement as they see fit )

    => "/styles/en_us/main_splash incl",
  my $lh_backup = ThisProject->get_handle('en');
   # For the moment, assume that things are set up so
Note that you may have things stored in a lexicon besides just phrases for output: for example, if your program takes input from the keyboard, asking a "(Y/N)" question, you probably need to know what equivalent of "Y[es]/N[o]" is in whatever language  You probably also need to know what the equivalents of the answers "y" and "n" are  You can store that information in the lexicon (say, under the keys "~answer_y" and "~answer_n", and the long forms as "~answer_yes" and "~answer_no", where "~" is just an ad-hoc character meant to indicate to programmers/translators that these are not phrases for output)

        $lh->bar('baz', $lh->quux('quuux')),

      Bracket groups that are empty, or which consist only of whitespace, are ignored  (Examples: "[]", "[ ]", or a [ and a ] with returns and/or tabs and/or spaces between them
Also, once a project is otherwise complete and you start to localize it, you can scrape together all the various keys you use, and pass it to a translator; and then the translator's work will go faster if what he's presented is this:
    *
      (For the rest of this section, I'll assume that this "first language class" of Projname::L10N::en_us has _AUTO lexicon )
literals   Text in brackets is rather more complex, and currently follows

    print $lh->maketext("Open the pod bay door (y/n)? ");
    "some_key" => sub 
 
    So for English (with Bracket Notation) "  [quant,_1,file]  " is fine (for 0 it returns "0 files", for 1 it returns "1 file", and for more it returns "2 files", etc )
    return $lh_backup->maketext($key,@params);
 
    * Methods to do with constructing language handles
   "Minimum ([_1]) is larger than maximum ([_2])!\n",

Bracket Notation is discussed in a later section  Note that trying to compile a string into Bracket Notation can throw an exception if the string is not syntactically valid (say, by not balancing brackets right )

      Translators may request clarification of the situation in which a particular phrase is found  For example, in English we are entirely happy saying "n files found", regardless of whether we mean "I looked for files, and found n of them" or the rather distinct situation of "I looked for something else (like lines in files), and along the way I saw n files " This may involve rethinking things that you thought quite clear: should "Edit" on a toolbar be a noun ("editing") or a verb ("to edit")? Is there already a conventionalized way to express that menu option, separate from the target language's normal word for "to edit"?
    You may override this as you like; Maketext doesn't use it for anything

    * Methods that you may find it handy to use, from routines of yours that you put in %Lexicon entries
    *
          '_AUTO' => 1,
 
        "Foo ",
Note that you might find it useful in some cases to override the maketext method with an "after method", if you want to translate encodings, or even scripts:
      This method (by having it return the name of a language-tag that has an existing language class) can be used for making sure that get_handle will always manage to construct a language handle (assuming your language classes are in an appropriate @INC directory)  Or you can use the next method:
      "Minimum (",
  $handler = $lh->fail_with(); 

but since you anticipate localizing this, you write:
If you call $lh->maketext(key,   parameters  ), and there's no entry key in $lh's class's %Lexicon, nor in the superclass %Lexicon hash, and if we can't auto-make key (because either it starts with a "_", or because none of its lexicons have _AUTO => 1,), then we have failed to find a normal way to maketext key  What then happens in these failure conditions, depends on the $lh object "fail" attribute
    *
However, if you set "_AUTO => 1" in the %Lexicon in, ThisProject/I18N/en pm (assuming that English (en) is the language that all your programmers will be using for this project's internal message keys), then you don't ever have to go adding lines like this
        ), 
         if $number is 0 and there's a $negative,
   

$language->quant($number, $singular)
    $response = $lh->y_or_n( get_input_from_keyboard_somehow() );
      This tries loading classes based on the language-tags you give (like ("en-US", "sk", "kon", "es-MX", "ja", "i-klingon"), and for the first class that succeeds, returns YourProjClass::language->new()
  emits the right text for this language  If the object in $lh belongs to class "TkBocciBall::Localize::fr" and %TkBocciBall::Localize::fr::Lexicon contains ("You won!" => "Tu as gagn�!"), then the above code happily tells the user "Tu as gagn�!"
      Currently this OS-specific stuff consists of looking in the environment variables "LANG" and "LANGUAGE"; and on MSWin machines (where those variables are typically unused), this also tries using the module Win32::Locale to get a language-tag for whatever language/locale is currently selected in the "Regional Settings" (or "International"?) Control Panel  I welcome further suggestions for making this do the Right Thing under other operating systems that support localization
    Remember to keep in mind verb agreement (or adjectives too, in other languages), as in:
  sub 

      "Hoohah ",

        use base qw(Locale::Maketext);
    Currently this just takes the last bit of ref($language), turns underscores to dashes, and returns it  So if $language is an object of class Hee::HOO::Haw::en_us, $language->language_tag() returns "en-us"  (Yes, the usual representation for that language tag is "en-US", but case is never considered meaningful in language-tag comparison )

   $min, $max
For example, here all the areas that are taken literally are underlined with a "^", and all the in-bracket special regions are underlined with an X:
This looks in the %Lexicon of the language handle $lh and all its superclasses, looking for an entry whose key is the string key  Assuming such an entry is found, various things then happen, depending on the value found:
         #

Locale::Maketext offers a variety of methods, which fall into three categories:
    go_process_file($filename)
      Create a class for your localization project  This is the name of the class that you'll use in the idiom:
$lh->failure_handler_auto
 
   # and any defaults that you declare
    my @params = @_;
  use TkBocciBall::Localize;  # the localization project class

    } 
 

Remember: Don't be afraid to read the Maketext source if there's any point on which this documentation is unclear  This documentation is vastly longer than the module source itself
      my $lh = $_[0];

      If the first item in a bracket group looks like a method name, then that group is interpreted like this:
  "Foo [bar,baz,[quux,quuux]]\n"; 
      Besides whole phrases meant for output, anything language-dependent should be put into the class Projname::L10N::en_us, whether as methods, or as lexicon entries -- this is discussed in the section "Entries in Each Lexicon", above

  }
    print $lh->maketext(

$text = $lh->maketext(key,   parameters for this phrase  );
  #  but after we log it for later fingerpointing
A typical %Lexicon entry is meant to signify a phrase, taking some number (0 or more) of parameters  An entry is meant to be accessed by via a string key in $lh->maketext(key,   parameters  ), which should return a string that is generally meant for be used for "output" to the user -- regardless of whether this actually means printing to STDOUT, writing to a file, or putting into a GUI widget

    return;

  # Set to a coderef:
The second is, in short, more readable  In particular, it's obvious that the number of parameters you're feeding to that phrase (two) is the number of parameters that it wants to be fed  (Since you see _1 and a _2 being used in the key there )

    print "Couldn't find file \"$filename\"!\n";
    *
  # Simply read:
Some users have expressed that they think this whole mechanism of having a "fail" attribute at all, seems a rather pointless complication  But I want Locale::Maketext to be usable for software projects of any scale and type; and different software projects have different ideas of what the right thing is to do in failure conditions  I could simply say that failure always throws an exception, and that if you want to be careful, you'll just have to wrap every call to $lh->maketext in an eval   }  However, I want programmers to reserve the right (via the "fail" attribute) to treat lookup failure as something other than an exception of the same level of severity as a config file being unreadable, or some essential resource being inaccessable
     
  open(LEX_FAIL_LOG, ">>wherever/lex log") || die "GNAARGH $!";
AUTO LEXICONS

         "[quant,_1,document] were matched \n" 
Then when you call $lh->maketext(key,   parameters  ) and there's no key in any of those lexicons, maketext gives up with

  return $lh->failure_handler_auto($key, @params); 
  if(-e $filename) 

  # Set to a method name:

      For some languages this issue may never come up (Danish is rarely expressed as "da-DK", but instead is just "da")  And for other languages, the whole concept of a "generic" form may verge on being uselessly vague, particularly for interfaces involving voice media in forms of Arabic or Chinese
Or maybe you don't want to die at all! Maybe you could use a handler like this:
    *

    return join '',

  #  BACKwards, and right is FOREwards
        package Projname::L10N;
 

</menu>

</div>

<b>Grand_Cash_Advance Faster.Safer.Stronger.Resource for quick_cash_loans </b><br>

<as>#sionligh.com/grd.php?r-YWZhYTFlYSFkOHA0MnBmMHAyNCExNjdhITNlOSFhbG0wMnxnbSFtZGdyYW5kY2dtZnJqITdkYXQ2dDE4IQ==<br><br>

You can get upto_Usd1500 CASH_FAST!!! Money_is wired directly into your bank_account. <BR><BR>

<b>Get a quick_cash loan_for anything!! </b><BR><BR>

Use your_cash for Tickets to the big_game ,bills ,car_payments ,emergencies ,rent_and more!<BR><BR>

- No credit_Checks<br>
- No Employment_Checks<br>
- Money_In Minutes<br>
- Secure_Online Application<br><br>

<b>Complete the final_step by filling out this 2.Minute form. No Faxing_required!</b><br><br>

<as>#sionligh.com/grd.php?r-YWZhYTFlYSFkOHA0MnBmMHAyNCExNjdhITNlOSFhbG0wMnxnbSFtZGdyYW5kY2dtZnJqITdkYXQ2dDE4IQ==<br><br>

<BR><BR><BR>
<BR>

Unsubscribe_From_Sponsor:<br>
<as>#sionligh.com/ard.php?uu-YWZhYTFlYSFkOHA0MnBmMHAyNCExNjdhITNlOSFhbG0wMnxnbSFtZGdyYW5kY2dtZnJqITdkYXQ2dDE4IQ==<BR>
orWriteto_Sandusky_LLC 3315 Hwy_50 silver_springs nevada_89429<br>
<br> <br>
<br>Unsubscribe-From_Mailing:<br>
<as>#sionligh.com/ard.php?ui-YWZhYTFlYSFkOHA0MnBmMHAyNCExNjdhITNlOSFhbG0wMnxnbSFtZGdyYW5kY2dtZnJqITdkYXQ2dDE4IQ==<BR>
Write to pobox 137 1648 S_Ohio Salina KS-67401US

--np4c236147e12fb--

Permalink | Leave a comment  »

Permalink | Leave a comment  »