I hate maintaining a separate ChangeLog on my modules. I'd rather keep it in the module's POD. But that's not the Kwalitee way to do it, and I'd rather follow standard locations.

Or better yet, get Perl to let me write where I like, and recreate the standard file as desired...

This goes in a Build.PL script: Use $class->new instead of Module::Build->new to use.

• xterm
  
• rxvt
  
• linux - Linux native terminal
  
• cons25 - FreeBSD native terminal
  
• PuTTY
  

• Ctrl-Up arrow to search readline history.
  
• Ctrl-Left arrow would move the readline cursor left word-by-word.
  
• Shift-Right arrow removes the word to the right of the readline cursor, and stores it into the paste buffer.
  
• Alt-Down arrow to slap down the paste buffer.
  
• Home and End keys move the cursor to the beginning and end of the readline, respectively.
  
• Delete key chews the character under the cursor, not the character before the cursor.
  
• etc.
  

    use Term::ReadLine::Perl::Bind;
[download]

I got really tired of being tripped up at run time by undefined subroutine references... particularly days after some change had broken a seldom used piece of code !

...this Ensure module picks up that sort of problem.

For more detail, see: Ensure Module.

I'm wondering if people would find this useful ?

Update: Doesn't seem to work anymore. E.g., latest version of autorep does not seem to have "-D" option. Instances of 'from_autosys' in code should probably be 'from_server'. I haven't used autosys for a while and am just getting back to it, so I may update this in the near future.

This is posted mainly because I said I would in response to a recent post. AutoSys is job scheduling software (like cron on steroids) from Computer Associates. This started out as just a JIL (AutoSys' Job Information Language) parser (to read files with multiple job definitions), and mutated into also getting job status and dependencies, and validating jil scripts. You'll need to configure the AUTOSERV hash...sorry this is mostly as is so things are not as generic as they could be. There is some overlap between this and what is already on CPAN (CA::AutoSys) but the existing CPAN module didn't have any JIL parsing, which is what I really needed in the beginning. If the output format of autorep or job_depends changes in past/future version of AutoSys, then something here will probably break.

And I would appreciate feedback on whether or not this works on other systems :-)

The simple perl script proof of concept demonstrated here, performs data type validation on the provided data file. The script creates an output file with bad data attributes substituted by default values. The data type specification and default values are read from a specification file.

Usage example:

Consider sales_payment.dat file:

A|10.50|CC|2006/12/05|10:05:15
2|12A|Cash|2006/12/05|10:12:18
3|100|12 Un|2006/12/05|10:15:23
4|.85|A1|2006/12/05|10:18:00
5|-100|B2|2006/12/05|10:20:00
6||C|2006/12/05|10:22:00
7|100||2006/12/05|10:26:00
8|200|D|2006/02/31|10:32:00
9|2006/02/31|10:33:00
10|400|E|2006/03/40|30:35:00
11|400|F|1234|10:41:AA
10|300|G|2006/02/31|10:05:15
[download]

transaction_number,^\d+$,-1
total_basket_amount,^[-+]?[0-9]*\.?[0-9]+$,0
payment_type,^\w$,_Unknown
date,(19|20)\d\d[/](0[1-9]|1[012])[/](0[1-9]|[12][0-9]|3[01]),1900/01/
+01
time,^([0-1][0-9]|[2][0-3]):([0-5][0-9]):([0-5][0-9])$,00:00:00
[download]

unix> perl validate_data_type.pl "sales_payment.spec" "sales_payment.d
+at" "sales_payment_out.dat" "sales_payment.log" 50
[download]

-1|10.50|CC|2006/12/05|10:05:15
2|0|Cash|2006/12/05|10:12:18
3|100|_Unknown|2006/12/05|10:15:23
4|.85|A1|2006/12/05|10:18:00
5|-100|B2|2006/12/05|10:20:00
6|0|C|2006/12/05|10:22:00
7|100|_Unknown|2006/12/05|10:26:00
8|200|D|2006/02/31|10:32:00
10|400|E|1900/01/01|00:00:00
11|400|F|1900/01/01|00:00:00
10|300|G|2006/02/31|10:05:15
[download]

Spec File> sales_payment.spec
Data In File> sales_payment.dat
Data Out File> sales_payment_out.dat
Log File> sales_payment.log
Max errors: 50
Error 1. Data type error on line: 1, attribute: 1 (transaction_number)
Error 2. Data type error on line: 2, attribute: 2 (total_basket_amount
+)
Error 3. Data type error on line: 3, attribute: 3 (payment_type)
Error 4. Data type error on line: 6, attribute: 2 (total_basket_amount
+)
Error 5. Data type error on line: 7, attribute: 3 (payment_type)
Error 6. On the data line: 9, # attributes: 3, do not match # attribut
+es in the file specification: 5
Error 7. Data type error on line: 10, attribute: 4 (date)
Error 8. Data type error on line: 10, attribute: 5 (time)
Error 9. Data type error on line: 11, attribute: 4 (date)
Error 10. Data type error on line: 11, attribute: 5 (time)
Process completed with: 10 errors

Formatted documentation available at: <a href=http://www.dwoptimize.co
+m/2007/05/data-type-validation-using-regular.html>www.dwoptimize.com<
+/a>
[download]

This is a straightforward implementation of Huffman coding in pure Perl. The module is not intended to be used in real applications as such; rather, this is an educational module, which can be used to demonstrate how it can be done.

Included in the module documentation are a simple compression and an equally simple decompression program, which demonstrate how the module can be used in compressing text files.

UPDATE: use 5.008_000 instead of 5.000_008, of course. Thanks, geekphilosopher!

UPDATE 2: Removed the use line altogether. tye has good arguments why it's harmful.

I needed a Subversion pre-commit hook script to commit based on the name and contents of the file being committed. I found a python example, so I thought I'd try something similar in perl.

Warning: this seems to work, but I do not know if I've got the subclassing of the SVN::Delta::Editor methods correct (can't find good docs or examples). Advice is appreciated.

This is a simple pod2html.pl emulator that wraps Pod::Simple::HTML. The Pod::Simple classes IMO aren't very well documented. Pod::Simple::HTML has almost nothing in the way of docs, and I havent seen a fully functional perl script that emulates the old TOMC version. So I'm hoping that this node might help fill the gap a little. I know some of you out there will have written almost the same thing so if you think yours is better or has something useful then please do post it.

I haven't tried to emulate the interface of the old pod2html.pl at all, but I might as time goes by.

Usage:

pod_to_html.pl [--css=FILESPEC] [--notoc] [PODFILE [HTMLFILE]]
  --css: If FILESPEC is 'auto' then tries to find the CSS based
    on the value of $^X. Currently 'auto' is only useful on
    Win32 ActiveState perls. If no value is provided and there
    exists a pod_to_html.css file in the same directory as the
    script is running from then it defaults to using that.
  --notoc: Turn off the Table Of Contents at the top.
  --notitlebars: Turn off the title header and footer lines

If PODFILE is omitted reads from STDIN, if HTMLFILE is omitted
writes to STDOUT.
[download]

See documentation with the code.

Note that the code computes factorials in only one place, the internal subroutine _single_term, which computes the hypergeometric probability function for a 2 x 2 contingency table (specified through its cell values, a, b, c, and d). Furthermore, the only dependance of the main routine (fishers_exact) on the Math::Pari module is through _single_term. If you prefer a library other than Math::Pari or don't like my implementation of _single_term, just replace it with your own. The rest of the code should work fine.

Also note that _single_term is called at most twice for every call to fishers_exact, so relegating this computation to a separate function doesn't significantly add to fishers_exact's overhead.

The computation of factorials attempts to use Math::Pari::factorial, and switches over to Gosper's approximation if that fails. Although, in principle, this maximizes the algorithm's accuracy, the performance cost may not justify this policy. For example, for 10_000!, the relative difference between the two methods is < 1e-10, but Gosper's is much faster:

          Rate    pari gospers
pari     604/s      --    -94%
gospers 9657/s   1500%      --
[download]

On the other hand, if you find yourself working in this regime, ask yourself whether χ² isn't more suited to your needs than than the FET.

Needless to say, I am providing this code "as is", without any expressed or implied warranties whatsoever. Use at your own risk.

This monitors jobs.perl.org (and eventually other sites) for postings of interest. There is separate code for watching the Minnesota Job Bank but since that's very specific, I left it out.

crontab entry to run once an hour, at 32 minutes past.

This is an initial step in my attempt to prepare for our perl upgrade and make it as easy as possible.

I'd really welcome some feedback if you try it out.

Update:Module::Dependency was a little cranky when I tried to install it (a few failing tests), so I forced it and it appears to work. I'll have to send something to the author.

Update:Turns out the topological sort in Graph sorts top-to-bottom, not bottom-to-top, so the list generated before was actually backwards. A simple reverse fixes the ordering.

Adds comments to your XS files with notes on the usage of the perl functions you've used. I wrote this to make noting which functions used implicit thread context or not, really easy. That and to not where a private API had been used inadvertantly.

This uses perl 5.8.6's embed.fnc file as a reference to perl's internal/public API. Perl's macros aren't listed there and so won't be covered by this utility.

If you use emacs, this function will check the syntax of your perl code and also run podchecker against it and display the result in a new buffer. You can call this function via the after-save-hook, and have the syntax checker run automatically. The function checks for CPerl mode.

Updated the code and the 'perlsyn' folder is shown only when there is a syntax error.(thanks to water)

Updated code to do a perl -wc (thanks to htoug)

I was interested in some basic stats on how my CPAN testing client was doing. This little script will check the latest X posts (defaults to 50) to the perl.cpan.testers newsgroups for a particular author and display how many PASS/FAIL/UNKNOWN reports they have submitted.

a "screenshot":

C:\>perl tester-stats.pl cpansmoke@alternation.net
Processing latest 50 items out of 142716

142716...Found 2 reports

   PASS: 002
[download]

Updated/fixed code so that lvalue methods work better.(see reply node)

  - support for 'use constant ABC => "xyz";' construct (ABC
    tag is created);
  - support for label constructs:
      EXIT:
    will produce a tag for EXIT;
  - support for full (package name + name) tags for
    constants and subroutines:
      package ABC::XYZ;
      sub hello {         # will create tags
                          # 'ABC::XYZ::hello'
                          # and 'hello', in case hello is
                          # called in the first way.
      }

Update: Now patch is provided instead of a link to it.

Update 2: This node 444294 provides a newer patch against ctags 5.5.4.

This module allows you to use any of String::Approx's functions from within a regular expression. It also provides a convenience function `fuzzy_qr` which provides a regex fragment that works like an inline `scalar amatch( $pattern, $test )` expression.

use Regexp::Approx 'fuzzy_qr';
use re 'eval';
$r = qr/((?:@{[fuzzy_qr('APT')]}\s)?\w+\d)$/;
$apt = ( "5678 DELAWARE AVENUE AOT 123" =~ $r )[0];

print "\$apt=$apt\n";
[download]

This traps warnings and prints them summarized instead of in masses. Instead of getting 3542 messages stating "Use of uninitialized value ..." at various lines you get only a few and they list all the lines it happened at and how many times.

Updated: The warnings are now displayed in the order they were first seen (they used to be in ascibetical order) and the warning messages are slightly more succinct. Instead of "on line 5 (11 times), line 8" now "on line 5 (x11) and 8".

I wrote it a long time ago (it's written in baby Perl) but have been using it monthly to make my journals, which are then really easy to edit and archive. I like keeping them in plain text format because then the entries are easy to cut and paste into other applications (emails, HTML forms, word processors, etc) without having to start a gigantic program or be online, etc.

I also like it because it simply writes a date for each day of the current month, like "Monday, July 14, 2003", with a few line breaks thrown in. That way, I can write down what I worked on that day, keep little notes or code snippets, lyrics, and so forth, and easily go back and review my month. And cross-platform date handling is a little trickier than I had initially expected, so I learned some things writing it, too.

Anyway, I know it isn't fancy, but since I use it every month, I figure somebody else out there might.

While working on a project, I was trying to find a way to get the status of numlock and preferably be able to tell when it was pressed. belg4mit pointed out that it was possible to get the scan code for Numlock using the showkey program. I took a look at the showkey source and found out that it does several things to the keyboard mode that allows it to capture raw scan codes. The first part is pretty much the same as saying ReadMode 4; with Term::ReadKey, but the last part I hadn't seen before and it set the keyboard to "MEDIUMRAW" mode. On closer inspection, it used an ioctl call to the current filehandle with some constants from the kd.h header file in the Linux kernel sources. It then does a bitwise AND with each character and 0x7f to get the scancode and also tests if a bitwise AND with 0x80 is true in which case the key was released, false it was pressed.

This program just uses the hard coded values taken from the kd.h file instead of including it like showkey does. There's probably a better way to do this, but I didn't know of one that would work easily. It also doesn't include as much error checking as showkey to make sure your keyboard gets back to how it should be or as many options for output.

Check for updated code below.

B::Deobfuscate is a backend module for the Perl compiler that generates perl source code, based on the internal compiled structure that perl itself creates after parsing a program. It adds symbol renaming functions to the B::Deparse module. An obfuscated program is already parsed and interpreted correctly by the B::Deparse program. Unfortunately, if the obfuscation involved variable renaming then the resulting program also has obfuscated symbols.

This module takes the last step and fixes names like $z5223ed336 to be a word from a dictionary. While the name still isn't meaningful it is at least easier to distinguish and read.

'test_tls.pl -q' for details

The Math::SnapTo module provides several methods to snap numeric values to desired values according to various criteria.

Update

Further research has revealed that this functionality is already available in Math::Round with the nearest() function and Math::SigFigs so this module has been slated for deletion :-(

Just what you'd expect from the title. :-)

New conversions are very easy to add; add a new row to the table, containing the source and destination unit and the factor to multiply by to get one from the other. If it's not a simple factor, add an array with two subrefs, one to convert from source to destination unit and another to convert backwards.

It will automatically keep applying conversions and reverse conversions to all the results it generates until it has calculated all related units from any given one.

Run it and it will tell you how to use it.

Install YAPE::Regex::Explain to gain insight into what you wrote. Perfect for newbies and experienced users.

http://crazyinsomniac.perlmonk.org/perl/RegexLab/

PseudoDBM - pure Perl Hash-tie()ing to fixed-length-record-text-files

Well, that's all. I think it may be usefull sometimes to have a Pseudo-DBM you can use everywhere and that's readable(for control).

File::DumbLock implements the dumbest kind of "locking" mechanism known to man. It's voluntary, and it can backfire, but virtually every plaform suports it.

Every time you "obtain a lock", a semaphore is created (a lockfile). Every time you "release a lock", that semaphore is deleted (if possible). If the lockfile can't be deleted, you'll be warned, but you'll lose the lock.

Example:

    my $dumB = new File::DumbLock(name => 'file' );
    my $dumC = new File::DumbLock(name => 'file', wait => 2 );
    print "dumB got lock\n" if $dumB->Open();
    sleep 2;
    print "dumC stole lock\n" if $dumC->Open();
    print "dumB couldn't get lock\n" unless  $dumB->Open();
[download]

You can download it at File-DumbLock-0.01.tar.gz sometime soon.

update: If you know of a module that already exists that does this, please /tell me.

I am also entertaining name suggestions: Lock::Dumb, Lock::Semaphore, Lock::Simple, File::SimpleLock ...

update: It appears i won't be changing the name. DON'T USE THIS CODE did make me chuckle heartily.

This is an implementation of a FIFO with unique elements. It was suggested by BrowserUK's RFC and debugging tips, though it does not share all properties of his uFIFO class. In particular, it is not rewindable and uniqueness is only enforced for elements presently on the queue.

Further description is in the pod.

Update: Version 0.03 -- constructor new rewritten in terms of enqueue to allow easier subclassing. Override enqueue in the child class and new will initialize using the child's version.

This node is obsolete!
A completely rewritten and enhanced version can now be found here:
http://dmcgen.bitrock.net/
The original posting below remains unchanged - just ignore it.

This is a tool for musicians to generate MIDI controller variations. The program takes a template MIDI file, or a simple plain text representation of that, and generates from the given "Alpha" and "Omega" values a given number of variations, using the algorithms "random", "morph" or "switch". A typical use for that would be to create random settings of certain controllers of an instrument within a specified range.

You can copy the POD "for example.txt" at the end of the code and use it as template text file.

Instead of a one-line command or a GUI I've made up some kind of "talking shell", who asks you for one argument after the other, reports and provides a short help text.

It's my first "more than few lines" perl program and as you may see I'm experimenting with vertically oriented formatting to increase readability - an even spacier version of the code is on my Scratchpad. I would be glad to hear your oppinion concerning that. I know that there could be some structural improvement - please tell me if you find any major do-nots or not very elegant phrases.

I'd also welcome suggestions where else to post a tool like that.

I made this after reading this post about using a simple stack-based language. The author described the language, but didn't provide any code, and I thought I could write some code quickly, so I did.

It's not very fancy, but it does seem to work. It's also not well-tested yet, but I don't expect to encounter serious bugs. :: crosses fingers :: ;-)

It's been updated a couple of times now :-)

But typing

perl -ne'BEGIN{$|=1}...'
[download]

perl -MAF -e'...'
[download]

I could always do

perl -ne'$|=1;...'
[download]

The name is short, since calling it "Acme::Autoflush" would pretty well defeat the purpose.

Simple HTML document retrieval script. Takes a url and a keyword as args, grabs the document, archives it in a directory hierarchy, does a very simple (soon to be improved) analysis for the specified keyword, and returns a relevance score. As always, suggestions for improvements are appreciated.

See the POD for info about the module.

Basically I'm just throwing this out to see if anyone can find any use for this since it's really just syntactic sugar. There's still a couple of bugs but they should go if I ever bother putting it somewhere important like CPAN or the Code Section on Perl Monks. Hey wait a second ... And if anyone actually wants to play about with it a bit further I can provide them with an actual package (tests and all!)

Any improvements/suggestions/condemnations welcome

Inspired by the discussion about subroutine defaults, I decided to write this...

You've probably seen it a thousand times: a subroutine begins with a complex series of defined($blah) or $blah = 'fribble' statements designed to provide reasonable default values for optional parameters. They work fine, but every once in a while one wishes that perl 5 had a simple mechanism to provide default values to subroutines.

This module attempts to fill that gap. It allows you to declare your subroutines with a 'default' attribute which you can use to specify whatever default values your subroutine should have, and automatically fills them in if they are undefined or not provided. It works on simple scalar arguments, list arguments, and hash-style named arguments.

Used like this:

use base 'Attribute::Default';

sub say_name : default('stephen') {
  my ($name) = @_;
  print "Hello, my name is $name\n";
}

# Prints "Hello, my name is john"
say_name('john');

# Prints "Hello, my name is stephen"
say_name();
[download]

There are actually a couple of different methods for determining the distance between 2 long/lat pairs and you need to be aware of the accuracy of each. The Great Circle method is the least accurate IIRC, but is the most accessible, as it is a part of Math::Trig. I wrote some code to do this using the various methods. As I mentioned, it finds the distances between two zip codes for which the long/lat pairs are known, but I've removed the database interface for brevity and just given the pertinent code. You should also read: this, this and (my favorite) this article.

I was pretty explicit in my code so that my non-programming sister could understand it when I showed it too her to explain the different algorithms, but I think it gets the point across.

C-.

since it's taking more than a month for me to get my CPAN id, i'll post here first. all comments are welcome.

Update: added rjray's suggestions, released as Revision 1.1

Update: added abaxaba's suggestion (silly me, i should have caught that!)

This is something I recently found while "cleaning house" in my /home prior to a disk upgrade. It reads the data parts of an XPM file and gives a simple accounting of the colors used in the pixmap, sorted in descending order of frequency. It's short and simple, so you should be able to adopt and/or adapt whatever parts you may have need for into other areas.

My original reasoning for it was when I was more fond of using background images on webpages. I tended to use marble patterns, faux-paper patterns, etc. I wanted to set a background color that was as close to the overall image as possible, so that people having network problems could still read the text even if the background hadn't loaded yet. Nothing worse than yellow text on a white background while you wait for that near-black background tile to finish loading. Basically, I grew tired of loading the image in sxpm or XV and rolling the mouse over it while guessing at which of the color specs was really showing up the most.

--rjray

Update: Someone pointed out I was missing some codons. Added them :-)

This is a translation of the bit-twiddling functions used to produce an ioctl command in Linux. See your linux.pl file for another approach. Device numbers are not so static any more.

Gradebook is a module useful for parsing Gradebook Plus text reports, a program used by many K-12 school districts. Simplely go to Reports->Gradebook of entire Class->(check fancy report, catagory totals, and sum/pct/grade)->Save to disk. The parser can then parse the contents of this file. Use it how you like; I use it so teachers can put their grades online with minimal effort on their part. It is fairly robust (especially considering the extremely unfriendly formating parsing-wise) and has methods to access all data for your convience. Note that parsing this isn't as easy as it looks; when the report gets to more than 80 columns it wraps itself to a new page. You can have up to 90 grades, which can be up to 10 pages in length. To make it even more fun, the pages are just concatrated one after another. Hence the need for a module :) Read the pod for more info. Also, you can find yourself a copy of Gradebook plus at:http://www.svemedia.com/demo.html

Update:A Sample Gradebook dump (as suggested by crazy: (this is the Gradebook supplied in the demo with 2 records added)

                                Carlmont School
                         Kingsfield's Per 7 Government
                        Gradebook as of Fri Jan 4, 2002

Name                      1   2   3  4   5   6  7     Total    Pct. 
--------------------------------------------------------------------
Adams, John              10  10  13  9  76  30  3       151    82.5 
Adams, Quincy            10  10  12  9  67  30  3       141    77.0 
Cleveland, Grover        10  10  11 10  68  30  3       142    77.6
Coolidge, Cal            10  10  14 10  82  30  3       159    86.9
Eisenhower, Dwight       10  10  15 10  93  30  3       171    93.4
Fillmore, Millard        10  10  16 10 100  30  3       179    97.8
Ford, Jerry              10  10  19 ( ) 93  30  3       165    90.2
Grant, U. S.             10  10  18 10  68  30  3       149    81.4
Harding, Warren          10  10  17 10  73  30  3       153    83.6
Hoover, Herb             10  10  20 10  92  30  3       175    95.6
Jackson, Andy            10  10  20 10  95  30  3       178    97.3
Jefferson, Tommy         10  10  19 10  78  30  3       160    87.4
Kennedy, Jack            10  10  16 10  72  30  3       151    82.5
Lincoln, Abe             10  10  18 10  75  30  3       156    85.2
Madison, Jim              9  10  14 10  80  30  3       156    85.2
McKinley, Bill          ( )  10  12 10  70  30  3       135    73.8
Monroe, John             10  10  16  5  93  30  3       167    91.3
Pierce, Frank             9  10  18  8  83  30  3       161    88.0
Polk, James               9  10  15  9  68  30  3       144    78.7
Roosevelt, Frankie       10  10  19 10  73  30  3       155    84.7
Roosevelt, Teddy         10  10  17 10  72  30  3       152    83.1
Truman, Harry            10  10  17 10  77  30  3       157    85.8
Tyler, John              10  10  10  9  88  30  3       160    90.9
Washington, George      ( )  10  14 10  79  30  3       146    79.8
Wilson, Woody            10  10  17 10  72  30  3       152    83.1

Average :                 9  10  16 19 79.5 30  3     155.4    85.7
Possible :               10  10  20 10 100  30  3       183

"( )"  Indicates the assignment was not submitted.


Key :
1) HW 9-11                             5) TEST- Chap 1
2) HW 9-12                             6) test
3) QUIZ                                7) next
4) HW 9-14




                                Carlmont School
                         Kingsfield's Per 7 Government
                        Gradebook as of Fri Jan 4, 2002

Name                            Grade    Cat 1     Cat 2     Cat 3
------------------------------------------------------------------
Adams, John                       B       81.5      96.7      69.6
Adams, Quincy                     C       74.6      96.7      65.2
Cleveland, Grover                 C       75.4     100.0      60.9
Coolidge, Cal                     B       86.2     100.0      73.9
Eisenhower, Dwight                A       94.6     100.0      78.3
Fillmore, Millard                 A      100.0     100.0      82.6
Ford, Jerry                       A       94.6      66.7      95.7
Grant, U. S.                      B       75.4     100.0      91.3
Harding, Warren                   B       79.2     100.0      87.0
Hoover, Herb                      A       93.8     100.0     100.0
Jackson, Andy                     A       96.2     100.0     100.0
Jefferson, Tommy                  B       83.1     100.0      95.7
Kennedy, Jack                     B       78.5     100.0      82.6
Lincoln, Abe                      B       80.8     100.0      91.3
Madison, Jim                      B       84.6      96.7      73.9
McKinley, Bill                    C       76.9      66.7      65.2
Monroe, John                      A       94.6      83.3      82.6
Pierce, Frank                     B       86.9      90.0      91.3
Polk, James                       C       75.4      93.3      78.3
Roosevelt, Frankie                B       79.2     100.0      95.7
Roosevelt, Teddy                  B       78.5     100.0      87.0
Truman, Harry                     B       82.3     100.0      87.0
Tyler, John                       A       90.8      90.0     100.0
Washington, George                C       83.8      66.7      73.9
Wilson, Woody                     B       78.5     100.0      87.0

Average :                     84.2      93.9      83.8
Possible :                      60        20        20

"( )"  Indicates the assignment was not submitted.

Category Key : 
1) TEST     2) HW        3) OTHER
[download]

What happens when you have too much time on your hands and you are getting drunk on vodka with a russian mathematician? Well, you get to proving that trancendental numbers are really digit sequences of uniform distribution over the 0 to 9 range.

Now that I am sober, I don't understand much of the reason behind all that, but this is a pretty nifty tool to print the relative density of digits in any numeric sequence. You can even use 'bc' or another arbitrary precision calculator to generate your large numbers.

How can we make this obfuscated?

Thanks japhy for your help. I've incorporated the smaller reader.

Actually looking at your array duplication, I can further take out the inner for loop.

I needed something like this for some of my CGI scripts. Appending to a table was a problem, as the file would sometimes loose some. I couldn't get flock to work, wanted to try writing object oriented perl.

Sample useage:

my $log=Logger->new("logfile", "/home/michael/logs");
open FILE, "myfile" or {
    $log->logger("something bad happened: $!");
    die;
}
[download]

Please comment.

<table border="0" cellpadding="2" cellspacing="0" width="140">
  <tr>
    <td align="left" colspan="1" rowspan="1" valign="middle" width="20
+">
      <font color="#000000" face="Tahoma, Verdana, Arial" size="2"><b>
+S</b></font>
    </td>
    <td align="left" colspan="1" rowspan="1" valign="middle" width="20
+">
      <font color="#000000" face="Tahoma, Verdana, Arial" size="2"><b>
+M</b></font>
    </td>
    <td align="left" colspan="1" rowspan="1" valign="middle" width="20
+">
      <font color="#000000" face="Tahoma, Verdana, Arial" size="2"><b>
+T</b></font>
    </td>
    <td align="left" colspan="1" rowspan="1" valign="middle" width="20
+">
      <font color="#000000" face="Tahoma, Verdana, Arial" size="2"><b>
+W</b></font>
    </td>
    <td align="left" colspan="1" rowspan="1" valign="middle" width="20
+">
      <font color="#000000" face="Tahoma, Verdana, Arial" size="2"><b>
+T</b></font>
    </td>
    <td align="left" colspan="1" rowspan="1" valign="middle" width="20
+">
      <font color="#000000" face="Tahoma, Verdana, Arial" size="2"><b>
+F</b></font>
    </td>
    <td align="left" colspan="1" rowspan="1" valign="middle" width="20
+">
      <font color="#000000" face="Tahoma, Verdana, Arial" size="2"><b>
+S</b></font>
    </td>
  </tr>
  <tmpl_loop name="row">
  <tr>
    <tmpl_loop name="day"><td align="left" colspan="1" rowspan="1" val
+ign="middle" width="20">
      <font color="#333333" face="Tahoma, Verdana, Arial" size="2"><tm
+pl_var name="day"></font>
    </td>
</tmpl_loop>  </tr></tmpl_loop>
</table>
[download]

It has OO methods to fork and handle IPC between the processes using TCP network sockets. Comes with excessive POD and examples. It may even be easy to use. The POD may be slightly out of sync since this is a rush release. /msg me if any troubles occur

Does not yet handle cross-platform filenames or allow for translating paths from absolute to relative (though you can of course edit its output with another Perl program).

Note that these files will actually be at least 37% bigger than the input files because of the extractor and the uuencoding. But you can send binary with them without worrying about someone trashing them in a mail or FTP program.

Just run it on another program like this:

perl watchRequire.pl myProgram.pl arg1 arg2 2>required
[download]

For an explanation of why the misfeature really is a bug, see my $foo if 0; is a bug.

To understand how to use this module, read the documentation.

Class::Flyweight is a module allows you to simply use the flyweight pattern in your modules. The major advantage to using this pattern is that the object data is not stored inside the blessed object itself. There is no way for a user of your module to access data in your object, unless you have provided the interface.

I am submitting this module for a code review, as I'm close to uploading it to CPAN. Before that I'd to get the monks' feedback and opinions before I take it to the next step.

In particular I am not sure of the following:

• Do you think people will use it?
• What about the method names? Something just doesn't feel comfortable about them. Especially clone(). Any naming suggestions?
• Where should I beef up/trim down/improve the documentation?
• Do you like the interface, and is it simple enough to not be limiting?

Please be gentle; it's very easy to outsmart this module. In particular, $(Foo('(')) will eat your entire program looking for a closing parenthesis (and then die gracefully), while $(Foo(')')) will give you a very strange error message about a missing curly or square bracket.

This module can also be used to force context--$() can be used instead of scalar(), and @() can be used instead of the mythical list(). In some cases @() may be the only way to get a list context.

I chose these semantics because they're pretty much identical to those proposed for Perl 6.

No XS required. POD is embedded. test.pl for this module is available upon request.

1056 words total, 6045 total characters
Damian1301 has 175 IMs sent while Other_name has 154 IMs sent. There w
+ere 329 IMs total
[download]

  perl -MAnySerialPort mySerialProgram.pl
[download]

It aliases the symbol table and provides a translating constructor.

Save it as AnySerialPort.pm somewhere on your Perl @INC path.

They are stored in a mysql database.

A trivial CGI::Application can then be used to browse the database.

Will need Depend::Module to run, and Depend::Browse for the browser application, available here

Sample of the browser program running is Here<here

usage: run one script:

 coverage script [ arg ... ] > listing.txt
[download]

 coverage @file > listing.txt
[download]

Thanks to Petruchio for the great code review below.   Thanks also to jeffa, chipmunk and buckaduck for number-range-matching help.   And to tye for further insight on calling subroutines.   Oh yeah, and to some guy named vroom.

Suggestions for improvement welcome and appreciated.

Updated:
2001-04-24
    Implemented most^W even more of Pfunk's suggestions.
    perldoc ipdec2oct.pl for details.

It is still kind of (OK) very rough.

My thanks to tye for a better name than I thought of.

As always the documentation is in the POD section.

use ForkBlock;

Fork {
    Parent {
        #parent code
    }
    Child {
        #child code
    }
    Error {
        #optional for handling non-recoverable errors
    }
};
[download]

You use Fork if you want each process to terminate after its block, or DumbFork if you don't.

I'm not including the pod documentation, as it adds another hundred lines or so to the bottom of the script. If you want the source, including pod, e-mail me.

If nothing else, see it as a creative use of an anonymous hash.

Currently the only problem I have with it is that it doesn't croak if you forget the Parent or Child blocks, but I think that's pretty minor.

Here is an example where Foo and Bar are two abstract base classes and Baz inherits from them. This was (not surprisingly) my test example. First Foo.pm, which requires a method called foo:

package Foo;
use AbstractClass;
@ABSTRACT_METHODS = qw(foo);

sub foo {print "Subclasses are not allowed to use me\n";}

1;
[download]

package Bar;
use AbstractClass qw(bar);
use Foo;
@ISA = qw(Foo);

sub foo {print "I am an allowable foo\n";}

1;
[download]

use Bar;
@ISA = qw(Bar);

#sub foo {print "This is method foo\n";}

sub bar {print "This is method bar\n";}

1;
[download]

UPDATE
Taking into account comments from Dominus (in a post which I think did not really deserve deletion) I have changed the name to AbstractClass, edited the documentation, and allowed abstract classes that do not define any new methods of their own. (This to allow classes that merely override a few methods.) I did not attempt to override bless, and won't pending some discussion. On the whole I don't much like overriding as a concept, and I am not sure that the gain is worth the pain.

Oh, and I added a version number. :-)

UPDATE 2
After some thought and an email to Damian I decided to implement a restriction to make it harder to create objects in an abstract class. While it would not be hard to make the check far stronger, doing so involves overriding bless everywhere, which is something I don't like philosophically. Also it would slow down the creation of objects from every constructor slightly. (As opposed to just slowing down constructors in abstract classes.)

UPDATE 3
Improved the check that subclasses overrode methods. Now you can usefully have an abstract class that inherits from a normal class and lists methods in that class which will need to be overridden (presumably because you have changed the implementation in some basic way). I am not sure that anyone would want to do so, but this issue was bugging me.

Well the trick is called continued fractions and the following program shows how you do it. In practice you just do enough iterations that you get down to round-off error and stop with that.

I suggest trying out a few fractions, and after that some expressions. Two fun expressions are

4 * atan2(1,1)
(1 + 5**0.5)/2
[download]

For more on the iterator techniques I used, I suggest this article.

This version is pretty simple, the version that you get depends on an environment variable My test script is called test.pl and looks like this:

#! /usr/bin/perl
# See comments in Versioning about warnings
use strict;
require versioned_module;
tst(0);
tst(1);
tst(0);
tst(1);

sub tst {
  $ENV{IS_PROD} = shift;
  import versioned_module("report_version");
  report_version();
}
[download]

package versioned_module;
use Versioner;
@ISA = qw(Versioner);
[download]

use strict;
use vars qw(@EXPORT_OK);
@EXPORT_OK = qw(report_version);

sub report_version {
  my $ver = __PACKAGE__;
  print "Got version $ver\n";
}
[download]

This idea can, of course, be made more complex. :-)

UPDATE
A few improvements. It now works smoothly for OO modules as well without a custom import, see later post.

Suggestions are not only welcomed, but wanted!

Thanks to jcwren, jlp, BlaisePascal, and merlyn's Programming Perl for helping me out.

Update: This was completely redone with a new interface and information stored in MySQL and the like.

The simplest and most common use is:

my $lock = Get Lock(lock_file => "foo.lock");
[download]

Just drop the variable when you want to drop the lock. (What could be easier?) Look at the Get function to see what other useful options there are. For debugging or interactive use you may want to set $Lock::verbose to a true value.

Oops, a security hole. I made the following rather important edit:

--- lock1.pm    Thu Aug 17 11:38:20 2000
+++ lock2.pm    Thu Aug 17 11:41:04 2000
@@ -108,12 +108,15 @@
   unless  (-e $lockfile) {
     print STDERR "$lockfile not found!  Creating\n";
     local *FH;
-    open (FH, "> $lockfile") or confess("Cannot create $lockfile! $!"
+);
+    open (FH, ">> $lockfile") or confess("Cannot create $lockfile! $!
+");
      close(FH);
     sleep 1;
   }
 
   open ($fh, "+< $lockfile") or confess("Cannot open $lockfile! $!");
+  if (-l $fh) {
+    confess("Refusing to use symlink '$lockfile' as a lockfile.");
+  }
   if ($obj->{no_block}) {
     # test_only
     unless( flock ($fh, LOCK_EX | LOCK_NB)) {
[download]

The point of this code is to allow programmers to test and develop their skill at writing AI programs. The go-arena.pl program allows two AI programs to connect over a network and play a game of GO. This will allow programmers to compete and interact with other programmers AI's inorder to learn better how to write their own.

Hopefully we will see good perl AI's out of this. But since the server is fully networked, you could write your AI in any language.

Update: Fixed a small bug in go-client.pl's arguement processing.

This code processes a formatted text file into COBOL code. Ick. 8^) Running from the Web frontend (http://johnbintz.dragonfire.net/cobolkiller), it accepts one parameter - "cobolcode", a TEXTAREA input from HTML. The report format is pasted into the TEXTAREA then sent to the script. An example report file would look like this:

01234567890123456789
COBOL REPORT  999999
--------------------
CODE       COST
XXXXXXXXXX 999999999

TOTAL     9999999999

The first line of the report file is ignored. I use it to line up and measure across columns. After that, the file is processed word by word in this way:

• If the word has two or more capital Xs, the number of Xs is counted and a PIC clause for X(length) is returned
• If the word has two or more 9s, the number of 9s is counted and a PIC clause for 9(length) is returned.
• If neither of these two occur, the word is placed into a FILLER (kinda like a constant) and the FILLER is assigned a PIC clause of X(length)

I also wrote a version to work with CICS BMS macros, which are even more longwinded. Enjoy!

Do you get sick of sorting through all those conditional compilation statems of the form:

   #ifdef DEBUG
   /* C code here *.
   #endif

This short script will strip them out, making your C code more legible. Use input redirection to run your *.c files through this filtering program.

This writes COPYRIGHT files for me. Sometimes we give clients code with a very specific license. This lets me set the policies. It spits out the license statement on standard out.

Call it like this

I'll probably make changes to this code based on your comments, so check back later if you want a more flexible version

 usage:
   use importopt (namespace=>"NS",
                  options=>{opt1=>"type",  
                            opt2=>"type[]", 
                            opt3=>"=opt1"});

 
 types: i (integer)  /^[+-]?[0-9]+$/
        f (float)    /^[+-]?[0-9.]+(e[+-]?[0-9]+)?$/
        s (string)   /./ 
        v (void)     /^$/
 
 new types can be defined by simply adding their regexp in %type.

 name=>"i[]" will define @NS::name holding all the values for all
 instances of --name.
 name=>"i" will define $NS::name holding the last given value if there
 are multiple instances (no error/warning given).
 name=>"=other" will make the option "name" an alias for the option
 "other". if "other" is defined to be an array (other=>"i[]"), then  
 @NS::name will be an alias for @NS::other, else $NS::name will be an
 alias for $NS::other. your script won't be able to tell which one
 was used on the command line.

 options syntaxes (equivalent):

   -option[=value]
   --option[=value]
[download]

 if value is ommited, 1 is assumed (for boolean options).
 all non-option @ARGV's will be copied to @NS::_args.

 if there are any errors (unknown option or invalid value), $NS::_err
 will be set to an error code and an error message will be displayed.

 error codes:

   1:   invalid value (didn't match regexp for type)
   2:   unknown option
   3:   reference to nonexistent option (aliasing)