Boxing lessons are becoming an ever more popular fitness choice. This fast-paced yet methodical exercise touches on elements of cardio, endurance and strength training to create a comprehensive workout... Some popular motivations for taking boxing lessons are increasing endurance, strengthening punching power, and getting fit. The intensity of a boxing workout can also help relieve stress. Do you want to pursue boxing as a career? Then boxing lessons are yet again a good choice. A boxing instructor can teach you how to hone and improve your boxing techniques. That way if tournaments and competitions are something you would like to pursue, you will be at the top of your game!
See more| Price | Hours |
|---|---|
| 39 $ | 10 h |
| 35 $ | 35 h |
| 32 $ | 70 h |
Want to lose weight ? Increase your muscle mass? Improve your fitness? Or do you especially need someone to motivate you? Regardless of your personal goals, a personal trainer can help you reach them.
See more| Price | Hours |
|---|---|
| 19 $ | 2 h |
| 17 $ | 8 h |
| 15 $ | 15 h |
Jogging is a form of trotting or running at a slow or leisurely pace. The main intention is to increase physical fitness with less stress on the body than from faster running, or to maintain a steady speed for longer periods of time. Performed over long distances, it is a form of aerobic endurance training.
See more| Price | Hours |
|---|---|
| 27 $ | 15 h |
| 24 $ | 40 h |
| 19 $ | 100 h |


Hi everyone this is me suad
shire,welcome to my page this is my first website ever.
There will be a lot more to come by the will of God in other words "my journey to be a wed developer has just started and am so excited about it. "to everybody out there believe in your abilities of doing everything ,by working hard towards our goals we succeed in this life.
i will make some good project using all the languages that am learning now and i will do the best i can


Timecode (2000) 97m.
In the 60s Andy Warhol was responsible for producing a number of experiments in cinema. It wasn't so much the films themselves than the audiences that Warhol found interesting - by showing static, lengthy opuses he was actually encouraging his viewers to get bored and talk to their neighbors. His experiments with simultaneous projection were pretty much cut of the same cloth: cinematic narrative is arbitrary and you watch what you want when it suits. Bring on WOODSTOCK. Bring on Brian De Palma. Split-screen perspective was less about narrative deconstruction than it was of gimmickry - even Able Gance knew that when he made NAPOLEON in 1927. End of story, you might think, but not quite. Developments in digital technology have once again allowed us to throw a fresh coat of paint on the old split-screen wagon. In TIMECODE, director Mike Figgis uses the new lightweight Sony DSR-I to synchronize not two, but four narrative divisions on the cinema screen. You want more? The separate narratives have all been filmed simultaneously on one Friday afternoon. Improvised. In unbroken 93-minute takes.
Let's put aside the storyline - or storylines - for a moment and address a more obvious issue: how do you watch something like this? More pertinently, how do you watch four screens when one of them always focuses on Salma Hayek in a snug-fitting top? Figgis knows ahead of time which screen his viewers are going to be drawn to, and this is the most impressive aspect of his film. The fast-tracking digital countdowns in the title credits point the way to the logistical feat that he has accomplished. Although his actors and camera operators improvise around a preset framework of circumstances, they are each given a 'timecode' to follow - a sort of time clock which must be punched at intervals throughout the film. This most noticeably occurs during periodic earth tremors, but also effectively in moments where all frames are simultaneously filled with close-ups of faces, telephone conversations, characters in restrooms, or contemplative scenes that allow the musical soundtrack to engage with the action.
You would think the theme underlying Figgis' work would be one of unification, but he takes the opposite tack, and it works just as well. TIMECODE is set in and around a small-time film studio, where we see actors, producers, writers, and directors sifting through the bric-a-brac that passes for their daily management. It seems an amusingly perfect setting for TIMECODE's sensibilities: the studio execs' juggling act is in symmetry with Figgis' own deployment of images on screen, but there the similarity ends. Instead of harmony we find duplicity. The multiple screens become testament to untruths, causing us to debunk one character's assertion that the tyranny of montage (as per Eisenstein) has resulted in 75 years of manipulation and lies. If the implication is that the opposite must be true, then TIMECODE rejects that also: unedited footage does not prescribe integrity, as evidenced by the continual deceptions perpetrated in real-time before our eyes. But that's okay. Figgis has undertaken his project with humor, and tips us a self-referential wink every now and then without coming across as smug. His orchestrated synchronicities are not designed to dazzle us into an oh-gosh appreciation of his technical skill, they are there to elicit grins. You smile because it's cute, because it all seems made up even though you know it isn't. TIMECODE is a confidence that we have been taken into, and we enjoy participating in the director's game.
It takes a confident film-maker to place his work so heavily in the hands of his actors and camera operators (essentially second and third unit directors), and it's heartening to see another contemporary talent trying to mess around in the mainstream. See this in a theater if you can, otherwise make sure you've got a big screen TV if video is your only option (those four divisions could get mighty small). And don't touch that pause button. You know Mike wouldn't want you to.
<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


About journalIT
journalIT is a free website to manage your private journal. All the features are free to use. All the user data is encrypted. JournalIT keeps your journals protected with password protection and military strength encryption so you can rest easy knowing that your entries are secure with JournalIT.
future updates will include Bullet Journal,Task Manager, Habit Tracker . Don't miss a precious moment, Idea. Note it now.


Greek PM: EU treats us like parking spot for migrants
ATHENS, Nov 19 — Greece’s prime minister has accused the European Union of treating countries on the bloc’s external frontiers as convenient places to park migrants, in a newspaper interview published today.
Kyriakos Mitsotakis told German newspaper Handelsblatt that the EU “ignores the problem” of rising numbers of arrivals in Greece.
Roughly 1,350 people arrived on Greece’s Aegean islands between Friday and Monday, according to the Greek coastguard, adding to more than 32,000 people already living in miserable conditions in Lesbos, Samos, Leros, Chios and Kos—camps with a combined capacity of just 6,200.
“It cannot go on like this,” said Mitsotakis, who won power in July.
“Europe regards arrival countries such as Greece as a convenient parking spot for refugees and migrants. Is that European solidarity? No! I will no longer accept this.”
Mitsotakis also singled out Turkey for criticism, saying President Recep Tayyip Erdogan was “trying to use migration as a lever to pressure Europe and achieve concessions”.
In early November Erdogan said he would “open the gates” for millions of refugees held in camps in Turkey if the EU criticised his offensive against Kurdish-held areas of northern Syria—the latest in a series of similar threats.
“I frankly told President Erdogan that he cannot abuse migrants and refugees as instruments if he wants to have good neighbourly relations with Greece,” Mitsotakis told the newspaper.
At the beginning of October, Mitsotakis announced that 20,000 people would be relocated from the Greek islands to the mainland by the end of December to relieve congestion in the camps. — AFP


Progress Indicator
External Documents
-
Document 0001
-
Document 0002
-
Document 0003
A progress indicator shows up about 5 seconds before a view content is displayed.
After you move to other views, you should also be able to navigate through the views with browser's back and forward buttons. Also, views should be bookmarkable. Note that you can pass parameters (e.g. ?myParam=001) to a destination view.


A Cantor Ribbon is a horizontal or vertical ribbon that extends off the screen infinitely in both directions and can be smoothly dragged via click & drag.
Here we use a ribbon with animated elements to show how resizing child elements works:


Been playing for several time with this representation in my free time. This time i wanted to move some interfaces i used at home to web and make some extensions.
Language is a closure over a three float element vector. Each one of these will be mapped to R, G, B values. Common arithmetical operations are supported (performing these for each component of each argument) and some trascendental functions (cos, sin, tan, ...) which are applied for each float value separately. Also sqr, sqrt and createvector for building vector leaf's. Basic variables are x and y, going from 0 to 1. Checkout definition here.
In these examples max-size was always from 30 to 40.
(VECCOS (VECADD (VECSIN (VECTAN (VECTAN (CREATEVECTOR X 0.5745977 0.26398724)))) (VECDIV (VECSQR (CREATEVECTOR X 0.17096399 X)) (VECMULTIPLY (VECCOS (CREATEVECTOR X Y Y)) (VECCOS (VECABS (CREATEVECTOR Y X X)))))))


Upon start first box will start animating, followed by transitions of box two and three.
Box animations and transitions chained using onAnimationEnd() and onTransitionEnd() methods.
For browsers that don't support CSS3 animation or transition, faux end callbacks will be fired by cssanimevent.js.
View browser developer console for further debug output.
http://github.com/magnetikonline/cssanimevent


Some mapping and spatial data manipulation tools - in particular drawing choropleth maps with nice looking legends, and aggregation of point data to polygons.
| Version: | 0.7-4 |
| Depends: | R (≥ 2.15.0), maptools, sp, RColorBrewer, MASS, rgeos |
| Published: | 2014-10-06 |
| Author: | Chris Brunsdon and Hongyan Chen |
| Maintainer: | Chris Brunsdon <christopher.brunsdon at nuim.ie> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| NeedsCompilation: | no |
| Materials: | ChangeLog |
| CRAN checks: | GISTools results |
| Reference manual: | GISTools.pdf |
| Package source: | GISTools_0.7-4.tar.gz |
| Windows binaries: | r-devel: GISTools_0.7-4.zip, r-release: GISTools_0.7-4.zip, r-oldrel: GISTools_0.7-4.zip |
| OS X binaries: | r-release: GISTools_0.7-4.tgz, r-oldrel: GISTools_0.7-4.tgz |
| Old sources: | GISTools archive |
| Reverse depends: | aoristic |
| Reverse suggests: | tbart |
Please use the canonical form https://CRAN.R-project.org/package=GISTools to link to this page.


| CONTENTS |
Perl[1] is an ecclectic, interpreted language with deep roots in Unix. It was originally written by Larry Wall, creator of other Unix staples such as patch and rn, to help with system administration tasks. Because many of its variables are prefixed with $, Perl often looks like an awk program or even a Bourne shell script. Like all appearances, this too can be deceiving. Perl is a complete programming language that supports both structured and object oriented programming. Getting started with Perl is easy, since many of the Bourne shell tricks you've seen will work (after a fashion) under Perl. As your knowledge grows, you'll find that Perl will help you scratch increasingly obscure itches. Because Perl has been ported to many different platforms, it brings a Unix-like API to whichever operating system is hosting it. Perl makes cross-platform programming a reality.
The complete guide to Perl is O'Reilly's Programming Perl, a book that weighs in at over 1500 pages. Therefore, only the barest of essentials can be presented here to help you identify your Perl installation, tinker with existing scripts, and install new modules. Luckily, Perl always comes with documentation that can be accessed through the perldoc (Section 41.10) system.
— JJ
Go to http://examples.oreilly.com/upt3 for more information on: perl
Before presenting the details of Perl syntax, it would be prudent to check whether or not Perl is on your system and learn how to install it if it isn't. Perl is an interpreted language whose interpreter is called perl. It is this program that reads, compiles and runs Perl source code. Normally, perl will be in your shell's path. It can often be found lurking in /usr/bin or /usr/local/bin. Use your system's find or locate command to track down perl if it doesn't appear in your command path. To see what version of Perl you have, use the -v flag like this:
$ perl -v This is perl, v5.6.1 built for i686-linux Copyright 1987-2001, Larry Wall Perl may be copied only under the terms of either the Artistic License or the GNU General Public License, which may be found in the Perl 5 source kit. Complete documentation for Perl, including FAQ lists, should be found on this system using `man perl' or `perldoc perl'. If you have access to the Internet, point your browser at http://www.perl.com/, the Perl Home Page.
This Perl is the latest stable version, 5.6.1. Perl is under very active development and newer versions may soon be available. As with all software projects, there is an unstable, developer's version of Perl that currently is 5.7.3. The version number scheme follows the pattern:
These change only when the language is substantially redefined.
Even numbers indicate a stable, production-quality release. Odd numbers should only be used by Perl developers and the curious. Version numbers indicate an important change in the language that may affect scripts written to run under a previous version of Perl. Be sure to check out the perldelta manpage for details.
This number is better thought of as the patch level for a given version. Only bug fixes will appear with each new patch level release. of perl.
Local configuration information about perl can be obtained with the -V flag. A slightly abbreviated version of that command's output appears below.
$ perl -V Summary of my perl5 (revision 5.0 version 6 subversion 1) configuration: Platform: osname=linux, osvers=2.4.2-2, archname=i686-linux uname='linux marian 2.4.2-2 #1 sun apr 8 20:41:30 edt 2001 i686 unknown ' config_args='' hint=recommended, useposix=true, d_sigaction=define ... Compiler: cc='cc', ccflags ='-fno-strict-aliasing ...' optimize='-O2', cppflags='-fno-strict-aliasing' intsize=4, longsize=4, ptrsize=4, doublesize=8, byteorder=1234 ... Characteristics of this binary (from libperl): Compile-time options: USE_LARGE_FILES Built under linux Compiled at Oct 1 2001 16:15:45 @INC: /usr/local/lib/perl5/5.6.1/i686-linux /usr/local/lib/perl5/5.6.1 /usr/local/lib/perl5/site_perl/5.6.1/i686-linux /usr/local/lib/perl5/site_perl/5.6.1 /usr/local/lib/perl5/site_perl .
The sections followed by ellipses have been truncated. What's important to note here is that the configuration, compiler, and linker options are available (and are used by the perlbug program if you need to file a bug report about Perl). Of more practical use is the section beginning with @INC. This lists the directories in which perl will look for library modules, described later in Section 41.11.
— JJ
If you don't have Perl already or you'd like to install the latest version, you have a few options. The first is to get a precompiled version for your platform. This is an option of last resort, since you lose the opportunity to configure Perl for your system. Most Unix systems will compile the Perl source code cleanly.
To compile Perl, you will need to fetch the latest Perl source for the Comprehensive Perl Archive Network (CPAN) (Section 41.11). You can find the gzipped tar archive of the source code at http://www.cpan.org/src/stable.tar.gz. The archive is several megabytes, so those on a slow modem link need to plan accordingly. Unpack the archive with the following command:
$ gzip -dc stable.tar.gz | tar xvf -
You should now have a new subdirectory called perl-X.Y.Z (whatever the current version of Perl is). Change into this directory and you will be be ready to configure the build process for perl.
Like many Unix utilities, compiling Perl requires configuring a Makefile and then executing make. The Perl source comes with a robust Configure shell script that will prompt you to confirm information it finds about your system. Often, all the defaults are fine so you can tell the Configure not to prompt you for confirmation by passing the -de flag. If all goes well with the configuration stage, you'll want to start compiling the source with make. These steps can be effectively combined into to following idiom:
$ ./Configure -de && make test
Recall that the double ampersand is a kind of flow control operator in the shell that allows the make to happen only if the Configure succeeds. The Perl source comes with a test suite that attempts to verify that the build went according to plan. Since the test suite needs perl to be built, this command is similiar to typing:
$ ./Configure -de && make && make test
The configuration stage may report missing libraries (like those needed to make NDBM files or read shadowed password files). Generally, these messages are harmless. If an important dependency is missing, the Configure script will halt. You will need to read the error message to figure out what's missing from your system that Perl requires. Generally, Perl will configure and compile without much intervention from you.
If the make test command succeeds, you are ready to install your new Perl. Typically, installation requires administrative privileges since you'll be writing files in /usr/local (the default installation root). One way to do this is to use the su command like this:
$ su -c 'make install'
This will prompt you for root's password. During the installation process, you will be asked if you want Perl installed as /usr/bin/perl. On a system that didn't have Perl to begin with, you can safely answer yes to this question. On a system that already had Perl, you might wish to answer no here. The new Perl interpreter will still be installed in /usr/local/bin/perl. You should now have the latest version of Perl on your system. Use /path/to/newly_installed/perl -v to verify this.
— JJ
It is impossible to present a complete guide to programming Perl in this one small section, but you can glean enough information here to be able to modify existing Perl scripts and evaluate whether you'd like to learn more about this incredibly handy language.
Perl scripts bare a passing resemblence to Bourne shell scripts. Example 41-1 a script called writewav.pl that comes with the Perl module Audio::SoundFile. It converts a given sound file into WAV format. The details of what it's doing aren't important, but it does demonstrate some common Perl structures that you should understand at a high level.
#!/usr/bin/perl -w =head1 NAME writewav - Converts any sound file into .wav format =cut use Audio::SoundFile; use Audio::SoundFile::Header; my ($buffer, $length, $header, $reader, $writer); my $BUFFSIZE = 16384; my $ifile = shift @ARGV || usage( ); my $ofile = shift @ARGV || usage( ); $reader = Audio::SoundFile::Reader->new($ifile, \$header); $header->{format} = SF_FORMAT_WAV | SF_FORMAT_PCM; $writer = Audio::SoundFile::Writer->new($ofile, $header); while ($length = $reader->bread_pdl(\$buffer, $BUFFSIZE)) { $writer->bwrite_pdl($buffer); } $reader->close; $writer->close; sub usage { print "usage: $0 <infile> <outfile>\n"; exit(1); }
The first line of Example 41-1 should be familiar to shell hackers; it's the shebang line. When the first two bytes of a file are the characters #!, the shell uses the rest of that file's first line to determine which program should be used to interpret the rest of the file. In this case, the path to the Perl interpreter is given. Command line arguments can be given to the interpreter. Here -w instructs Perl to print warning messages when it finds code that is likely to be incorrect. This includes such common gaffes as trying to write to a read-only file handle, subroutines that recurse more than 100 times, and attempts to get the value of a scalar variable that hasn't been assigned a value yet. This flag is a new Perl programmer's best friend and should be used in all programs.
All lines that start with = in the left margin are part of Perl's Plain Old Documentation (POD) system. Everything between the directives =head1 and =cut are documentation and do not affect how the script runs. There are Perl tools like pod2text and pod2man that will format the POD found in a script into the particular output format given in the command's name. There's even a pod2man program used during the Perl installation procedure that creates all the Perl manpages on the target system.
The next two lines begin with actual Perl code. To use Perl library files called modules (Section 41.10), scripts invoke the use module statement. Perl searches the paths listed in the global variable @INC (Section 41.2) for these modules, which typically have the extension .pm.
In Perl, variables don't need to be declared before being used. Although this behavior is convenient for small scripts, larger scripts can benefit from the disciplined approach of declaring variables. Perl 5 — that is, Perl revision 5 — introduced the my operator as a way of declaring a variable. Declaring variables allows the -w flag to help catch misspelled variable names, which are a common source of bugs in Perl scripts.
A variable that holds a single value is called a scalar and is always prefixed with a $ (even in assignments), unlike variables in the Bourne shell. The = is the assignment operator (when it's not appearing as a POD directive). Another kind of variable, called an array, can be used to hold many scalar values. Array variables begin with @. One example of a global array variable is @ARGV, which holds the list of command-line arguments passed into the Perl script.
Continuing with Example 41-1, the two variables $ifile and $ofile get values from the command line. The shift operator removes values from the beginning of the @ARGV array. If there aren't enough values on the command line, the user defined subroutine usage( ) is called.
Perl supports object oriented programming (OOP). The hallmark of OOP is that both the data and the subroutines (called methods in OOP jargon) for processing that data are accessed through an object. In traditional procedural programming, data structures are stored separately from functions that manipulate them. Fortunately, using object oriented Perl modules is often straightforward. In Example 41-1, the scalar $reader is a new Audio::SoundFile::Reader object. Unlike other OOP languages, Perl's objects are not opaque: the user can set or get values internal to the object. This is what is happening on the next line. The -> dereferencing operator is used both to get at values that are pointed to by references (Section 41.5.4) and to make method calls. Here, the key format is set to a value that is created by the bitwise or of the values returned by the subroutines SF_FORMAT_WAV and SF_FORMAT_PCM. Another object, $writer, is created on the following line.
The heart of the program is the while loop which, in English, reads, "While reading more chunks of the source file, translate that chunk into WAV data and write it to the outfile." When the loop finishes, those objects are no longer needed, so the close( ) method is called on each of them to release any resources used by those objects. This is the end of the program's execution, but there's a bit more to this script.
Perl allows for user defined subroutines. Although they can be anywhere in the file, subroutine definitions typically come after the main block of code. Here, a subroutine called usage( ) is defined that simply prints some help to the user and quits. Inside of double quoted strings, Perl interpolates scalar and array values. This is a fancy way of saying that Perl replaces variables with their values. Because Perl tries to do the right thing with interpolation, there may be occasions when Perl's rules surprise you. Take a look at the perldata manpage for the definitive rules governing variable interpolation and a peek at the perltrap manpage for common interpolation mistakes. You can prevent interpolation by putting a backslash in front of the variable name (e.g. \$foo is $foo) or use single quotes, which never interpolate variables. Finally, the exit(1) function halts the script before the subroutine can return to the caller and returns the value 1 to the operating system.
That's the 50,000-foot view of a Perl script. To confidently modify existing Perl scripts, it is necessary to understand some of the basic components of Perl better.
— JJ
Data types are the kinds of values Perl supports. Common data types include arbitrarily long strings (e.g., "hi, bob"), intergers (e.g., 42) and floating point numbers (e.g., 3.14). Perl is a loosely typed language, which means that Perl works hard to let you forget about what kind of data you're dealing with. For the most part, you will be dealing with strings, which plays to Perl's strengths. To manipulate data, variables are employed. Table 41-1 lists the most common variable types in Perl. For the full story on Perl data types, read the perldata manpage.
|
Name |
Example |
Description |
|---|---|---|
|
scalar |
$lastname, $PI |
Holds single values |
|
array |
@people, $peple[0] |
Holds an ordered sequence of scalar values |
|
hash |
%cgi_params, $cgi_params{'action'} |
Holds a set of key-value pairs |
When you want to store single values, like any of those given in the previous paragraph, you will use a scalar variable. Scalars are labeled with a $ followed by a letter and any sequence of letters, numbers, and underscores. Scalars defined at the top of scripts are often used as constants. You may need to tweak some of them, particularly those containing filesystem paths, to get third-party scripts to run on your system.
Of course, values can be compared to each other or added together. Perl has relational operators that treat values as numbers and other relational operators that treat values as strings. Although Perl has different operators for numbers and strings, Perl makes scalar values do the right thing most of the time. For example, you want to create a series of filenames like mail_num. The following code does this.
foreach my $num (1..10) { print "mail_" . $num . "\n"; }
Even though $num is a number, the string concatenation operator is able to use it as a string. Table 40-2 shows string operators, and Table 41-3 shows the numerical ones. See the perlop manpage for the full story.
|
Operator |
Example |
Description |
|---|---|---|
|
. |
$saluation . " Jones" |
String concatenation |
|
eq |
$foo eq $bar |
String equality test |
|
ne |
$bar ne $baz |
String inequality test |
|
gt |
$name gt "Bob" |
True if left string comes after right in ASCII |
|
lt |
$name lt "Xavier" |
True if left string comes before right in ASCII |
|
cmp |
$name cmp "Wilson" |
Return -1 if left operand ASCII-sorts before the right; 0 if right and left are equal; 1 if right sorts before left |
|
lc |
lc "Bob" |
Return an all-lowercase copy of the given string |
|
uc |
uc "lorrie" |
Return an all-uppercase copy of the given string |
|
Operator |
Example |
Description |
|---|---|---|
|
+ |
$a + 1 |
Numerical addition |
|
- |
$c - 2 |
Numerical subtraction |
|
* |
3 * $b |
Numerical multiplication |
|
/ |
4/$non_zero |
Numerical division |
|
++ |
$a++ |
Autoincrement; adds one to a number |
|
== |
$a == $b |
Numeric equality test |
|
!= |
$p != $q |
Numeric inequality test |
|
< |
$diff < 32 |
Numeric less-than test |
|
> |
$sum > 64 |
Numeric greater-than test |
|
<=> |
$sum <=> 64 |
Return -1 if left is numerically less than right; 0 if left equals right; 1 if right is less than left |
|
<= |
$sum <= 64 |
True if left operand is numerically less than or equal to right |
|
>= |
$sum >= 64 |
True if left is numerally greater than or equal to right |
You may have notice that some of the operators in the previous tables were described as returning true or false values. A true value in Perl is any value that isn't false, and there are only 4 kinds of false values in Perl:
values that are numerically zero
values that are empty strings
values that are undef
empty lists
Like many other languages, Perl supports Boolean operators (see Table 41-3) that return true or false values. Typically, you encounter these in if statements like the following:
if ($temp < 30 && $is_rainy) { print "I'm telecommuting today\n"; }
Another common use of Boolean operators is to short-circuit two expressions. This is a way to prevent the right operand from executing unless the left operand returns a desired truth value. Consider the very ordinary case of opening a filehandle for reading. A common idiom to do this is:
open (FH, "filename") || die "Can't open file";
This short-cut operation depends on the open function returning a true value if it can open the requested file. Only if it cannot is the right side of the || operator executed (die prints whatever message you provide and halts the program).
|
Operator |
Example |
Description |
|---|---|---|
|
&& |
$a && $b |
True if both $a and $b are true |
|
|| |
$a || $b |
True if either $a or $b is true |
|
! |
!$a |
True if $a is false |
|
and |
$a and $b |
Same as &&, but with a lower precedence |
|
or |
$a or $b |
Same as ||, but with a lower precedence |
|
not |
not $a |
Same as !, but with a lower precedence |
Looking at Table 41-4, you will notice that there appear to be redundant operators. The operators that are English words have a lower precedence that the symbolic ones. Precedence is simply the order in which Perl executes expressions. You are probably familiar with precedence rules from mathematics:
1 + 2 * 3 + 4 = 11 (1 + 2) * (3 + 4) = 21
Similarly, Perl's operators have precedence as well, as shown in Example 41-2.
lc $a || "BB" # like (lc $a) || ("BB") lc ($a || "BB")
Because || has a lower precedence that the lc operator, the first line of Example 41-2 is a Boolean test between two expressions. In the second line, the Boolean || operator is used to create a default argument to lc should $a be a false value.
Because Perl doesn't require parentheses around built-in operators and functions, you will often see code like:
open FH, "> " . "filename" or die "Can't open file"; print FH "[info]: disk write error\n";
Precedence ambiguities can be resolved by using parentheses where doubt occurs.
Although Perl has many special variables, the one you'll encounter most is $_. Many operators and functions, such as lc and print, will operate on $_ in the absence of an explicit parameter, as in Example 41-3.
while(<>){ print }
In this example, every line read from standard input with the <> operator is available inside the while (Section 41.7) loop through $_. The print function, in the absence of an explicit argument, echoes the value of $_. Note that $_ can be assigned to (e.g., $_ = "Hello, Perl") just like any other scalar.
When you want to collect more than one value into a variable, you have two ways to go in Perl. If you need an ordered set of values, you will choose to use a Perl array. These variables start with @ and are followed by a label that follows the same convention as a scalar. Two global arrays have already been mentioned: @INC and @ARGV. Since arrays hold multiple values, getting and setting values is a little different from scalars. Here's an example of creating an array with values, looking at one, and assigning a new value to that array index.
@things = ('phone', 'cat', 'hard drive'); print "The second element is: ", $things[1], "\n"; $things[1] = 'dog'; print "The second element is now: ", $things[1], "\n";
In the first line, the array @things is initialized with a list of three scalar values. Array indexes begin with zero, so the second element is accessed through the index value of 1. Arrays will grow as needed, so you could have added a fourth element like this:
$things[3] = 'DVD player';
Why is a $ used here and not @? Use @ only when referring to the whole array variable. Each element is a scalar whose name is $things[index]. This rule comes up again when dealing with hashes.
Typically you will want to iterate through all the values in an array, which is done with loops (Section 41.7). Although there are several looping constructs, the most common idiom to examine all the values in an array sequentially is shown in Example 41-4.
print "Paths Perl checks for modules\n"; foreach my $el (@INC) { print $el, "\n"; }
Lists are a data type that is closely related to arrays. Lists are sequences of scalar values enclosed in parentheses that are not associated with an array variable. They are used to initialize a new array variable. Common array operators are listed in Table 41-5.
my @primes = (1,3,5,7,9,11); my @empty_list = ( );
|
Name |
Example |
Description |
|---|---|---|
|
pop |
$last = pop @array; |
Return last element of array; remove that element from array |
|
push |
push @array, @new_elements; |
Add the contents of @new_elements to the end of target array |
|
shift |
$first = shift @array; |
Return the first element of array; shift all elements one index lower (removing the first element) |
|
unshift |
unshift @array, @new_elements; |
Add @new_elements to the beginning of target array |
Associative arrays, or hashes, are a collection of scalar values that are arranged in key-value pairs. Instead of using integers to retrieve values in a hash, strings are used. Hashes begin with %. Example 41-5 shows a hash variable in action.
my %birthdays = ( 'mom' => 'JUN 14', 'archie' => 'JUN 12', 'jay' => 'JUL 11', ); print "Archie's birthday is: ", $birthdays{'archie'}, "\n"; $birthday{'joe'} = 'DEC 12'; print "My birthday is: ", $birthdays{'joe'}, "\n";
Hashes are a funny kind of list. When initializing a hash with values, it is common to arrange the list in key-value pairs. The strange-looking => operator is often called a "fat comma" because these two lines of Perl do the same thing:
%birthdays = ( 'jay' => 'JUL 11' ); %birthdays = ( 'jay', 'JUL 11');
Use the fat comma when initializing hashes since it conveys the association between the values better. As an added bonus, the fat comma makes unquoted barewords on its left into quoted strings.
Example 41-6 shows some quoting styles for hash keys.
my %baz = ( foo => 1, 'bar', 2, 'boz' => 3);
Unlike arrays, hashes use strings to index into the list. So to retrieve the birthday of "jay", put the key inside curly braces, like this:
print "Jay's birthday is: ", $birthday{'jay'}, "\n";
Because Perl assumes that barewords used as a key when retrieving a hash value are autoquoted, you may omit quotes between the curly braces (e.g., $birthday{jay}). Like arrays, hashes will grow as you need them to. Whenever you need to model a set or record the number of event occurrences, hashes are the variable to use.
Like arrays, you will often need to iterate over the set of key-value pairs in a hash. Two common techniques for doing this are shown in Example 41-7. Table 41-6 lists common Perl hash functions.
my %example = (foo => 1, bar => 2, baz => 3); while (my ($key, $value) = %example) { print "$key has a value of $value\n"; } foreach my $key (keys %example) { print "$key has a value of $example{$key}\n"; }
|
Name |
Example |
Description |
|---|---|---|
|
delete |
delete $hash{{key"} |
Delete the key-value pair from hash that is indexed on key |
|
each |
($key, $value) = each %hash |
Return the next key-value pair in hash; the pairs aren't usefully ordered |
|
exists |
print "key found" if exists $hash{"key"} |
Return true if hash has key, even if that key's value if undefined |
|
keys |
@keys = keys %hash |
Return the list of keys in the hash; not ordered |
|
values |
@values = values %hash |
Return the list of values in the hash; values will be in the same order as keys fetched by keys %hash |
As odd as it may first seem, it is sometimes necessary to have variables for variables. A funny kind of scalar, a reference is a sort of IOU that promises where the original variable's data can be found. References are primarily used in cases. First, because hashes and arrays store only scalar values, the only way to store one multivalued data type in another is to store a reference instead (see the perldsc manpage for more details). Second, when the size of a data structure makes a variable inefficient to pass into subroutines, a reference is passed instead. Third, because arguments passed into subroutines are really just copies of the original, there's no way to change the original values of the arguments back in the calling context. If you give a subroutine a reference as an argument, it can change that value in the caller. Consult the perlref and perlreftut manpages for more details on references.
Taking a reference to a variable is straightforward. Simply use the reference operator, \, to create a reference. For example:
$scalar_ref = \$bob; $array_ref = \@things; $hash_ref = \%grades;
You can even create references without variables:
$anonymous_array = [ 'Mojo Jo-Jo', 'Fuzzy Lumpkins', 'Him' ]; $anonymous_hash = { 'pink' => 'Blossom', 'green' => 'Buttercup', 'blue' => 'Bubbles', };
The square brackets return a reference to the list that they surround. The curly braces create a reference to a hash. Arrays and hashes created in this way are called anonymous because there is no named variable to which these references refer.
There are two ways of deferencing references (that is, getting back the original values). The first way is to use {}. For instance:
print "Your name is: ", ${$scalar_ref}; foreach my $el ( @{$anonymous_array} ) { print "Villian: $el\n"; } while (my ($key, $value) = each %{$anonymous_hash}) { print "$key is associated with $value\n"; }
The second way, using ->, is useful only for references to collection types.
print "$anonymous_hash->{'pink'} likes the color pink\n"; # 'Blossom' print "The scariest villian of all is $anonymous_array->[2]\n"; # 'Him'
— JJ
To do any interesting stuff with data, Perl needs to be able to branch and loop. Perl supports the C-like if-then-else construct, as the following shows:
if ( $password eq 'secret' ) { print "Come on in\n"; } else { print "Incorrect password\n"; }
You can also invert simple tests that only have one statement in the then block.
print "Don't I know you?\n" if $user eq 'joe';
You can invert the logic of if by using unless:
print "Please supply command line arguments\n" unless @ARGV;
The print happens only if @ARGV is empty.
Sometimes you need to iterate through each element of a list. This can be done with the foreach loop:
foreach my $thing (@my_room) { print "dusting $thing\n"; dust($thing); }
A synonym for foreach is for. Bourne shell hackers (or those who don't like typing) may feel more comfortable using for rather than then foreach.
Each time through the loop, $thing is aliased to the next element in @my_room. Any change to $thing will change that element in the array, so be careful. If you don't supply a scalar variable like $thing, Perl will set $_ for you each time through the loop. The previous example could also be written:
foreach (@my_room) { print "dusting $_\n"; dust($_); }
Sometimes you need to continue looping while an event is happening, like reading input from standard input:
while ( my $line = <STDIN> ) { print "I got: $line"; }
Each line of input a user provides is stored in $line, including the newline at the end. When the user hits the end-of-file control key (CTRL-D), the loop exits. Like the foreach loop, you can leave off the scalar variable while reading from a filehandle,[2] and $_ will be set to the next line of input each time through the loop.
while (<>) { print "I got: $_"; }
Sometimes you need to interrupt the execute flow of your loop. Perl gives you three operators to do that (see Table 41-7).
|
Operator |
Example |
Description |
|---|---|---|
|
next |
while(<>){ next if $_ ne "continue\n"; } |
Jump to the top of the loop and iterate normally |
|
last |
while(<>){ last if $_ eq "quit\n" } |
Jump out of the loop to the next line of the program |
|
redo |
for $url (@urls){ unless( $content = get($url) ){ print "couldn't fetch page - retrying\n"; redo; } } |
Jump to the top of the loop, but don't evaluate the loop condition |
— JJ
Perl is excellent at finding patterns in text. It does this with regular expressions, similar to the ones used by grep and awk. Any scalar can be matched against a regular expression with the matching binding operator, =~. For example:
if( $user =~ /jjohn/ ){ print "I know you"; }
Without the matching binding operator, regular expressions match against the current value of $_. For example:
while (<>) { if (/quit/i) { print "Looks like you want out.\n"; last; } }
In this code, each line of input is examined for the character sequence quit. The /i modifier at the end of the regular expression makes the matching case-insensitive (i.e., Quit matches as well as qUIT).
As with regular expressions in other utilities, Perl attempts to find the leftmost and longest match for your pattern against a given string. Patterns are made up of characters (which normally match themselves) and special metacharacters, including those found in Table 41-8.
|
Operator |
Description |
|---|---|
|
^ |
Pattern must match at the beginning of the line. |
|
$ |
Pattern must match at the end of the line. |
|
. |
Match any character (expect the newline). |
|
pat1|pat2 |
Alternation: match the pattern on either the left or right. |
|
(pattern) |
Group this pattern together as one (good for quantifiers and capturing). |
|
[ synbols] |
Define a new character class: any of the symbols given can match one character of input (e.g. /[aeiou]/ matches a string with at least one regular vowel). |
|
\w |
Match a letter, number and underscore. |
|
\d |
Match a number. |
|
\s |
Match a whitespace character: space, tab, \n, \r. |
|
pattern* |
Match 0 or more consecutive occurences of pattern. |
|
pattern+ |
Match 1 or more consecutive occurrences of pattern. |
|
pattern? |
Optionally match pattern. |
A very common task for which regular expressions are used is extracting specific information from a line of text. Suppose you wanted to get the first dotted quad that appears in this ifconfig command:
$ ifconfig eth0 eth0 Link encap:Ethernet HWaddr 00:A0:76:C0:1A:E1 inet addr:<IP_ADDRESS> Bcast:<IP_ADDRESS> Mask:<IP_ADDRESS> UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 RX packets:365079 errors:0 dropped:0 overruns:0 frame:0 TX packets:426050 errors:0 dropped:0 overruns:0 carrier:0 collisions:3844 txqueuelen:100 Interrupt:9 Base address:0x300
The output of a command can be captured into an array using the backtick operator. Each line of the command's output will be an element of the array. One way to extract the IP address from that line is with the following code:
my @ifconfig = `/sbin/ifconfig eth0`; for (@ifconfig) { if ( /(\d+\.\d+\.\d+\.\d+)/ ) { print "Quad: $1\n"; last; } }
This regular expression looks for one or more digits (\d+) followed by a literal dot (rather than the regular expression metacharacter), followed by two more digit/dot pairs, followed by one or more digits. If this pattern is found in the current line, the part that was matched is captured (thanks to the parentheses) into the special variable $1. You can capture more patterns in a regular expression with more parentheses. Each captured text appears in a sequential higher scalar (i.e., the next paren-captured match will be $2).
Sometimes, you need to find all the matches for your pattern in a given string. This can be done with the /g regular expression modifier. If you wanted to find all the dotted quads in the ifconfig output, you could use the following code:
my @ifconfig = `/sbin/ifconfig eth0`; for (@ifconfig) { while( /(\d+\.\d+\.\d+\.\d+)/g ){ print "Quad: $1\n"; } }
Here, the if block is replaced with a while loop. This is important for /g to work as expected. If the current line has something that looks like a dotted quad, that value is capture in $1, just as before. However, the /g modifier remembers where in the string it made the last match and looks after that point for another one.
Perl's regular expression support has set the standard for other langauges. As such, it is impossible to give a comprehensive guide to Perl regular expressions here, but see O'Reilly's Mastering Regular Expressions or the perlre manpage.
— JJ
There are many built-in Perl operators that mimic Unix system calls and standard utilities, as are partially listed in Table 41-9. Those that aren't hardcoded into the language are often available through modules (Section 41.9). In fact, there are too many Unix-like operators to describe here, but this sampling should give you a good start.
|
Function |
Example |
Description |
|---|---|---|
|
chmod |
chmod 0775, filenames |
Change file permission on given file or list of files; same as the system command. |
|
chown |
chown UID, GID, filenames |
Change owner and group on given list of filenames; same as the system command. |
|
rename |
rename oldname, newname |
Change a file's name; similiar to mv. |
|
unlink |
unlink filenames |
Unlink given filenames; deletes files that aren't hard linked elsewhere. |
|
system |
system(executable) |
Create a subshell to execute an external command whose ouput isn't accessible to Perl. |
|
qx() |
@output = qc(executable) |
Create a subshell to execute external command and return lines of output as an array to Perl; same as ''. |
One advantage Perl has over shell scripting is that Perl has filehandles. In Perl, files can only be created, edited, or read through special variables called filehandles. These variables have no funny punctuation prefixing them. It is customary to make filehandles all uppercase. The code below shows a typical way to read an existing file and echo its contents to the screen:
my $file = "your_filename"; open (IN, $file) || die "can't open $file: $!"; while (<IN>) { print; } close (IN);
In this simple code, the open function is used to associate the filehandle IN with whatever filename you choose. If the open fails, the expression to the right of the logical OR will execute. The die function halts the program with the string provided. Here, that string includes the special variable $!, which contains the error message from the last failed system call (which here is open). If the open succeeds, IN can be read from with the <> operator. As noted earlier, this operator populates $_ with the next line of input each time through the loop until there are no more lines to read. The print function will use $_ if no other argument is passed to it. Although Perl will free all filehandles when the script exits, it's a good habit to close all filehandles you open.
Writing to files is almost as easy as reading from them. Consider this code:
my $file = "your_filename"; open (OUT, "> ". $file) || die "can't make $file: $!"; print OUT "<html><body><h1>hello, world</h1></body></html>\n"; close(OUT);
This snippet starts in a familiar way, but the open call is a little different. To tell Perl you want to create a new file or overwrite an existing one, simply prefix the filename with a >. If you wanted to append to an existing file, use >> instead. Now you can print to that file by passing the filehandle to print (notice there's no comma after the filehandle). Here, a simple HTML file is being created.
You can also read directories in Perl. The following code looks in the current directory and describes each file as a directory, symbolic link, or regular file.
opendir (DIR, ".") || die "error: $!"; while (my $file = readdir(DIR)) { print "$file -> "; if ( -d $file ) { print "directory\n"; } elsif ( -l $file ) { print "symlink\n"; } else{ print "file\n" } } closedir (DIR);
To read directories, use the opendir function, which has a similiar interface to open's. Unfortunately, the <> operator won't work on directory handles, so use the readdir command to iterate over each file in the directory. Perl provides file test operators, like those in the Bourne shell, to determine what kind of file its argument is. The -d operator tests whether a file is a directory, while the -l operator tests whether a file is symbolic link. Perl doesn't have a switch operator like C, but you can tack on as many elsif blocks as you need. What's not shown here is how to create a directory. Just as you would at the shell prompt, Perl provides a mkdir function that takes an octal number (which must start with zero!) and the name of the directory to create. Pretty simple.
In /etc/passwd and in password files for CVS and Apache, user passwords are stored as a string that has been passed through a one-way hashing algorithm (such as DES), usually using the system's crypt(3) system call. Perl provides access to this system call with a function of the same name. The following code prompts users for a new password for a fictional program and creates its own password file.
print "Username: \n"; my $user = <>; print "Password: \n"; my $pass = <>; chomp($user, $pass); my $crypt = crypt($pass, substr($user, 0, 2)); open (OUT, ">>passwd") || die "error: $_"; print OUT "$user;$crypt;". localtime( ) . "\n"; close (OUT);
After collecting the username and password from the user, the chomp function removes the trailing newline from the input just collected. The crypt function expects the string to be hashed and a random two-character salt. Here, the first two characters of the username are used, via the substr function. The line written to the password file consists of a semicolon-separated list of the username, the hashed password, and a date stamp of when the account was added. Here, the localtime function call is used in scalar context because of the concatenation operator. This produces a human-readable string like Sat Mar 16 21:17:44 2002. Used in list context, localtime returns a nine element list that's not easily consumed by human eyes (see Programming Perl, published by O'Reilly, for more details on scalar versus list context).
This section hardly scratched the surface of using Perl as a system administration tool. Many books have been written on this very topic, including O'Reilly's Perl for System Administration.
— JJ
Modules are Perl's way of extending functionality, in the same way C has library files. Modules can be used to encapsulate a set of related function calls (the way Data::Dumper does), implement pragmas (like use strict), or create object classes (like HTML::TokeParser). Whatever a module does, it must first be installed on your system (Section 41.11) before you can use it.
Using a module in Perl is often straightforward. For example, the Data::Dumper module has a function called Dumper that takes a reference to a variable and deconstructs the entire structure into a printable string. This is an invaluable debugging tool. The following code shows Data::Dumper in action:
use Data::Dumper; print "The current environment is: ", Dumper(\%ENV), "\n";
An abbreviated version of the output from this code is this:
The current enviroment is: $VAR1 = { 'DISPLAY' => ':0', 'COLORTERM' => 'gnome-terminal', 'QTDIR' => '/usr/lib/qt-2.3.0', 'PVM_RSH' => '/usr/bin/rsh', 'OSTYPE' => 'linux-gnu', 'PWD' => '/home/jjohn/docs/unix_powertools/upt', 'EDITOR' => 'emacs -nw', 'LOGNAME' => 'jjohn', 'MACHTYPE' => 'i386-redhat-linux-gnu', 'SHELL' => '/bin/bash', 'MAIL' => '/var/spool/mail/jjohn', '_' => '/usr/local/bin/perl', 'HISTSIZE' => '1000', 'CVS_RSH' => 'ssh1', 'HOSTNAME' => 'marian', 'TERM' => 'xterm', ... };
In this code, the Data::Dumper is made available to your script with the use statement. You should be aware that use happens at the script's compile time, meaning that you can't use this statement to dynamically load modules at runtime (but this is possible; see Programming Perl for details). Data::Dumper automatically makes the function Dumper available to your script. Here the global hash %ENV, which contains all your shell's environment variables, is deconstructed. Dumper can take multiple variables, so when looking at a hash or array, be sure to prefix the variable with the reference operator (Section 41.5.4) \. Without a passed reference, the output of Dumper won't exactly what you expect.
Many Perl modules are object oriented. Although writing object classes may not be trivial, using them is. Here, the CGI module is used to create a very simple HTML page.
use CGI; $q = CGI->new; print $q->header, $q->start_html, $q->h1("hello, world!"), $q->end_html;
There's no difference in how object classes are brought into your script with use. New objects are created through a method traditionally called new (new is not an operator, as it is in other languages). Sometimes, new will require arguments. Once the object ($q) is created, all method access must be made through it, using the -> operator. That's all there is too it. Of course every module is different, so you will need to use perldoc modulename (Section 41.10) to the module's documentation.
Infrequently, you may need to find the module files on your system. Modules are usually files that have the extension .pm and are found in one of the directories listed in the @INC array. Every module should declare its own namespace, so that its variables and functions don't overwrite the ones you define in the scripts that use the modules. These namespaces are hierarchical, so so that the module Data::Dumper belongs to the Data module group.[3] When the Data::Dumper module is installed on your system, it is placed somewhere with the rest of your Perl modules in a directory called Data, in which a file called Dumper.pm will be copied. Generally, :: in a module name translates to a / on the filesystem. You can also use perldoc -l modulename to list the module's filesystem path.
There are many good reasons to learn Perl, but the ace up a Perl programmer's sleeve is the Comprehensive Perl Archive Network (Section 41.11) (CPAN), which is the central repository for Perl modules. There are hundreds of modules on CPAN, ranging from the essential (IO::Socket) to the useful (LWP, DBI, mod_perl), to the frivolous (Acme::Buffy). The main CPAN server is accessible on the web at http://www.cpan.org. CPAN is mirrored all over the world, so look for a mirror near you.
— JJ
We all need a little help sometimes, and it's at those times that perldoc comes in handy. Normally, core Perl and module documentation is accessible through your system's manpage system, but you can also use the perldoc program, which has a few convenient features that you should be aware of. Like man, perldoc takes the name of a module or core Perl document as an argument.
Your system's perl comes bundled with hundreds of pages of very readable documentation. The top of the document tree can be accessed with either perldoc perl or man perl. This page is little more than a table of contents[4] for the rest of the perl documentation. There are over 40 documents listed there, but there are a couple that will be immediately useful to novice Perl programmers, as Table 41-10 shows.
|
Name |
Description |
|---|---|
|
perlsyn |
The complete guide to Perl syntax |
|
perldata |
Perl's data types explained |
|
perlop |
Perl's operators and their precedence |
|
perlfunc |
The complete guide to all of Perl's built-in functions |
|
perlre |
The complete guide to Perl's regular expressions |
In many cases (such as the ones above), perldoc doesn't do anything man can't. However with perldoc, you can easily look up built-in Perl functions with the -f flag (-t formats any POD elements for a text console). For instance, to see the entry on print, try this:
$ perldoc -tf print
You'll get back something like the following (which has been abbreviated):
print FILEHANDLE LIST print LIST print Prints a string or a list of strings. Returns true if successful. FILEHANDLE may be a scalar variable name, in which case the variable contains the name of or a reference to the filehandle, thus introducing one level of indirection. ...
Perl has quite a large FAQ. You can read each of the nine sections (perlfaq1 through perlfaq9) to find the answer to your question or you can use the -q flag to keyword search all of the FAQ.
$ perldoc -q fork Found in /usr/local/lib/perl5/5.6.1/pod/perlfaq8.pod How do I fork a daemon process? If by daemon process you mean one that's detached (disas- sociated from its tty), then the following process is reported to work on most Unixish systems. Non-Unix users should check their Your_OS::Process module for other solu- tions. ...
Do take advantage of the copious documentation already on your system: you will be reward many times over.
— JJ
The Comprehensive Perl Archive Network (CPAN), whose URL is http://www.cpan.org, is the place to get modules, scripts, and the Perl source code. This system is mirrored all over the world, so consult http://www.cpan.org/SITES.html or http://mirror.cpan.org for the server nearest you. There is a really complete CPAN FAQ that can be found at http://www.cpan.org/misc/cpan-faq.html.
This section covers obtaining and installing modules from CPAN. If your installation of Perl is up to date, module installation is trivial. If you've got a "unique" system, you may need to take matters into your own hands.
In a fit of inspired genius (or madness), the CPAN module was created to automate the task of fetching and installing modules. If you want to install the Text::AutoFormat suite, it's as easy as becoming superuser on your system and typing:
# perl -MCPAN -e 'install Text::AutoFormat'
Perl has many command-line switches. Here, -M (equivalent to use module) and -e (execute the next argument as perl code) are used. If you've never run the CPAN module before, be prepared to answer a lot of questions about your network setup and where certain system binaries are. Luckily, you can usually accept the defaults safely. Once that's done, the CPAN module will go to the CPAN mirror you specified; find the latest version of the module you asked for; and download, unpack, configure, and install it for you with no additional typing. Now that's twenty-first-century library management! If your module depends on other modules not installed on your system, CPAN will attempt to fetch and install the missing modules. In fact, you can update the CPAN module itself with:
# perl -MCPAN -e 'install Bundle::CPAN'
The CPAN module also has an interactive shell you can access like this:
$ perl -MCPAN -e shell
Why bother with the interactive shell? Sometimes you want to install several unrelated modules at once. This is done more conveniently in the CPAN shell. Alternately, you may want only to download module archives without actualling installing them. The entire range of shell options can be found with the h command inside the shell. One of the most useful shell functions, the search function, can be used to look up available CPAN modules. For instance:
$ sudo perl -MCPAN -e shell cpan shell -- CPAN exploration and modules installation (v1.59) ReadLine support enabled cpan> i /Text/ CPAN: Storable loaded ok Going to read /usr/local/cpan/Metadata Module AddressBook::DB::Text (D/DL/DLEIGH/AddressBook-0.16.tar.gz) Module AnyData::Format::Text (J/JZ/JZUCKER/AnyData-0.05.tar.gz) Module Apache::PrettyText (C/CH/CHTHORMAN/Apache-PrettyText-1.03... ... 401 items found cpan> quit
Here, we use the i command to search for the regular expression /Text/ in all the module names.
When you first run the CPAN module, you will be asked a series of configuration questions. The first question you'll be asked when configuring CPAN is to name a CPAN build and cache directory (where CPAN unpacks fetched module archives and builds them). Put this in a sensible place where you and other users can can get to it, such as /usr/local/cpan. You'll be asked to name the maximum size for the cache directory (the default is 10MB). The next question will ask when to perform size checks on the cache, atstart or never. Unless you have a compelling reason not to remove old module builds, accept the default of atstart. You then be asked whether CPAN metadata should be cached, and again, accept the default of yes.
The next question asks about what character set your terminal expects. Again, you should accept the default of yes. The configuration then asks what it should do when unfulfilled dependencies are encountered during a module installation. CPAN can automatically fetch the missing modules (follow), ask for confirmation before downloading them (ask), or do nothing (ignore). If you are on a fast Internet connection, you may want to set the policy to follow. The safest policy, and one that guards against runaway module fetching sessions, is ask.
The next several questions ask for the location of certain binaries (like lynx, make, gzip, etc.). Answer these appropriately. The next set of questions ask for additional make parameters. Again, accept the defaults. You will then be asked about your network setup. If you are behind a firewall that uses SOCKs or proxy servers for FTP and HTTP, you will need to enter those server names. CPAN will ask you to pick a CPAN mirror closest to you, by asking you for continent and country information. You'll be presented with a list of CPAN mirrors, and you can enter the numbers of the URLs in which you are interested. Generally, you'll only need to give one or two mirrors. The last question is about the WAIT system, to which you can safely accept the default. This concludes the CPAN configuration.
Most modules on CPAN are gzipped tar archives that have some common files in them that makes installing them fairly simple. To install a CPAN module, unpack your archive and cd to the new directory that was just created. Now type:
$ perl Makefile.PL && make test
This is a similiar configure and compile idiom to the one shown in Section 41.3. If the tests all succeed, change to root and install the module with:
# make install
The module is now available to your system.
There's something to be said for browsing the CPAN archive with a web browser. In fact, there are all kinds of ancillary tidbits that are available only on the web site. However, CPAN's main purpose is to store and serve modules.
Modules on CPAN are arranged by author name, module name, category, and recentness. Of these, module name and category are perhaps the most useful for CPAN newbies. The full Perl documentation is linked to from CPAN, but you should have this on your system already. Of course, no serious web site these days is missing a search engine, and CPAN is no exception. In fact, the search engine has its own URL: http://search.cpan.org. This is an excellent resource for quickly finding modules that may solve your problem.
CPAN is an ocean of code that awaits your exploration.
— JJ
All of the various grep-like utilities perform pretty much the same function, with minor differences — they search for a specified pattern in some or all of a file and display that pattern with varying amounts of surrounding context.
As you use Unix more and more, you will find yourself wanting to do an increasing number of grep-like tasks, but no particular Unix utility will quite suit them all (hence the need for the various grep utilities discussed earlier). You'll start accumulating C programs, awk scripts, and shell scripts to do these different tasks, and you'll be craving one utility that can easily encompass them all so you don't have to waste the disk space for all of those binaries. That utility is Perl (Section 41.1), the "Practical Extraction and Report Language" developed by Larry Wall. According to the documentation accompanying Perl, it is "an interpreted language optimized for scanning arbitrary text files, extracting information from those text files, and printing reports based on that information."
For example, to search for a pattern in the header of a Usenet message:
perl -ne 'exit if (/^$/); print if (/pattern/);' filename
[This works because mail and Usenet (Section 1.21) messages always use a blank line — indicated by ^$ in regular expression syntax — to separate the header from the body of the message. — TOR]
[The -n flag tells perl to wrap the contents of -e into the body of a while(<>){ ... } loop. — JJ]
To do a search for a pattern and print the paragraphs in which it appears:
perl -ne '$/ = "\n\n"; print if (/pattern/);' filename
[This assumes that paragraphs are delimited by a double linefeed — that is, a blank line. You'd have to adjust this script for a troff or TEX document where paragraphs are separated by special codes. — TOR]
Searching through files is one of Perl's strengths, but certainly not its only strength. Perl encompasses all the functionality of sed, awk, grep, find, and other Unix utilities. Furthermore, a Perl program to do something originally done with one or more of these utilities is usually faster and easier to read than the non-Perl solution.
— JIK
Because Perl supports Berkeley sockets, all kinds of networking tasks can be automated with Perl. Below are some common idioms to show you what is possible with Perl and a little elbow grease.
The suite of classes that handle all the aspects of HTTP are collectively known as LWP (for libwww-perl library). If your Perl installation doesn't currently have LWP, you can easily install it with the CPAN module (Section 41.11) like this:
# perl -MCPAN -e 'install Bundle::LWP'
If you also included an X widget library such as Tk, you could create a graphic web browser in Perl (an example of this comes with the Perl Tk library). However, you don't need all of that if you simply want to grab a file from a web server:
use LWP::Simple; my $url = "http://slashdot.org/slashdot.rdf"; getstore($url, "s.rdf");
This example grabs the Rich Site Summary file from the popular tech news portal, Slashdot, and saves it to a local file called s.rdf. In fact, you don't even need to bother with a full-fledged script:
$ perl -MLWP::Simple -e 'getstore("http://slashdot.org/slashdot.rdf", "s.rdf")'
Sometimes you want to process a web page to extract information from it. Here, the title of the page given by the URL given on the command line is extracted and reported:
use LWP::Simple; use HTML::TokeParser; $url = $ARGV[0] || 'http://www.oreilly.com'; $content = get($url); die "Can't fetch page: halting\n" unless $content; $parser = HTML::TokeParser->new(\$content); $parser->get_tag("title"); $title = $parser->get_token; print $title->[1], "\n" if $title;
After bringing in the library to fetch the web page (LWP::Simple) and the one that can parse HTML (HTML::TokeParser), the command line is inspected for a user-supplied URL. If one isn't there, a default URL is used. The get function, imported implicitly from LWP::Simple, attempts to fetch the URL. If it succeeds, the whole page is kept in memory in the scalar $content. If the fetch fails, $content will be empty, and the script halts. If there's something to parse, a reference to the content is passed into the HTML::TokeParser object constructor. HTML::TokeParser deconstructs a page into individual HTML elements. Although this isn't the way most people think of HTML, it does make it easier for both computers and programmers to process web pages. Since nearly every web page has only one <title> tag, the parser is instructed to ignore all tokens until it finds the opening <title> tag. The actual title string is a text string and fetching that piece requires getting the next token. The method get_token returns an array reference of various sizes depending on the kind of token returned (see the HTML::TokeParse manpage for details). In this case, the desired element is the second one.
One important word of caution: these scripts are very simple web crawlers, and if you plan to be grabbing a lot of pages from a web server you don't own, you should do more research into how to build polite web robots. See O'Reilly's Perl & LWP.
Often, you may find it necessary to send an email reminder from a Perl script. You could do this with sockets only, handling the whole SMTP protocol in your code, but why bother? Someone has already done this for you. In fact, there are several SMTP modules on CPAN, but the easiest one to use for simple text messages is Mail::Sendmail. Here's an example:
use Mail::Sendmail; my %mail = ( Subject => "About your disk quota" To =><EMAIL_ADDRESS><EMAIL_ADDRESS>From =><EMAIL_ADDRESS>Message => "You've exceeded your disk quotas", smtp => "smtp-mailhost.hostname.com", ); sendmail(%mail) or die "error: $Mail::Sendmail::error"; print "done\a\n";
Since most readers will be familiar with the way email works, this module should be fairly easy to adapt to your own use. The one field that may not be immediately clear is smtp. This field should be set to the hostname or IP address of a machine that will accept SMTP relay requests from the machine on which your script is running. With the proliferation of email viruses of mass destruction, mail administrators don't usually allow their machines to be used by unknown parties. Talk to your local system administrator to find a suitable SMTP host for your needs.
What Perl chapter would be complete without some mention of CGI? The Common Gateway Interface is a standard by which web servers, like Apache, allow external programs to interact with web clients. The details of CGI can be found in O'Reilly's CGI Programming with Perl, but the code below uses the venerable CGI module to create a simple form and display the results after the user has hit the submit button. You will need look through your local web server's configuration files to see where such a script needs to be in order for it to work. Unfortunately, that information is very system-dependent.
use CGI; $cgi = CGI->new; $name = $cgi->param("usrname"); print $cgi->header, $cgi->start_html, $cgi->h1("My First CGI Program"); if( $name ){ print $cgi->p("Hello, $name"); } print $cgi->start_form, $cgi->p("What's your name: "), $cgi->textfield(-name => "usrname"), $cgi->submit, $cgi->end_form, $cgi->end_html;
CGI scripts are unlike other scripts with which you are probably more familiar, because these programs have a notion of programming state. In other words, when the user first accesses this page, $name will be empty and a blank form with a text box will be displayed. When the user enters something into that textbox and submits the form, the user's input will be stored under the key usrname. After the user presses the form's submit button, the values of that form are available through the CGI method param. Here, the desired value is stored under the key usrname. If this value is populated, a simple message is displayed before showing the form again.
Now you have nearly all the tools necessary to create your own Internet search engine. I leave the details of creating a massive data storage and retrieval system needed to catalog millions of web pages as an exercise for the reader.
— JJ
[1] A word on casing: "Perl" refers to the language as an abstract concept; "perl" refers to the program installed on your machine.
[2] STDIN is normally assumed here.
[3] Well, that's the theory anyway. In practice, modules that aren't written by the same group of people often have somewhat arbitrary top-level namespaces.
[4] There's actually a more complete table of contents available: man perltoc.
| CONTENTS |


--- layout: post date: 2010-05-06 time: "09:00:00" authors: ["Greg Wilson"] title: "Day 4: First Preliminary Alpha Test Etc. Screencast" tags: ["Content"] ---
Jon Pipitone and I have created a screencast showing the basics (and I really mean "the basics") of pulling data out of a database using SQL. It took about 4.5 hours in total to produce 7 minutes of video:
| Writing script: | 1.5 hours |
| Doing 3 takes: | 1.0 hours |
| Editing: | 1.0 hours |
| Transcribing: | 0.5 hours |
| Screenshots: | 0.5 hours |
This was the first time either of us had used Camtasia; I expect that we'll be able to cut the recording, editing, and screenshotting time in half with practice. Transcribing time is dictated by typing and editing speed, so it's unlikely to come down, and scripting time will probably be the same or greater for future topics (since some of them will require diagrams and other time-consuming prep). We're therefore looking at 3 hours of production for 5-7 minutes of screen time; if you figure a lecture is 50 minutes, and there are 25 of them in the course, that works out to... um... carry the six... 750 hours to get all of the existing material online. Pad by half to account for real-world effects, and that's 35-40 weeks — tight, but doable.
What we need now from you, dear reader, is feedback. Is the pace right? Do you want larger chunks, or smaller ones? Is the transcript useful? (I know we have to re-do the screenshots to make them more readable — we're thinking about exactly how to do that.) What else could/should we change, and why?
We look forward to your comments.


use Red::AST::Value; use Red::AST::Infix; use Red::Type::Json; #| Represents the operation to remove a json item unit class Red::AST::JsonRemoveItem does Red::AST::Infix; has Str $.op = "->"; method returns { Json } multi method new(::?CLASS $left, $right) { $left.clone: :right(ast-value [|$left.right, ast-value $right]) }


| Table 1 |
Estimated livestock population in Pakistan (in millions). |
| Table 2 |
Sample tehsil/village. |
| Table 3 |
Description of variables. |
| Table 4 |
Livestock inventory. |
| Table 5 |
Determinants of livestock ownership (Poisson regression). |
| Table 6 |
Climate-change coping strategies adopted by livestock owners ... |
| Table 7 |
Impact of climate-change risk-coping strategies on livestock ... |
| Table 8 |
Indicators of Covariates Balancing (before and after estimat ... |


my favorite top 10 Readers of the Holy Quran
- maher al mauqly
- mohammad al hedaan
- naser alqatemi
- ahmad alajemi
- mohammad al barak
- mahmud al husare
- abd al baset
- idrees abkar
- khalid aljaleel
- saad al gamide
my name is ahmad, iam a 28 years old ,i live in amman ,I graduated from university in 2018, I was eager to find work to help myself and my family, but unfortunately I did not find and searched and searched a lot, but to no avail, I was forced to work in stores as a cashier and then I worked on my own car as a delivery driver until I found an advertisement from Luminous College to give courses In programming, I applied to join this course and was accepted into it, and I am now in the second phase of the course


This directory is to be used to store (resp. load) configuration of machine algorithm, inheriting from the trait, Config into (resp. from) a file.
For instance the configuration for the Multi-layer perceptron is defined by the class org.scalaml.supervised.nnet.MLPModel and can be stored into the configs/MLPModel.
The persistency design is presented only for the sake of illustrating the concept and is not currently implemented for any of the machine learning algorithms.
The reader is invited to create a robust, generic implementation for all the models presented in the book.
trait Config { protected def write(content: String): Boolean = FileUtils.write(content, Config.RELATIVE_PATH, getClass.getSimpleName) // Save these configuration parameters into a file configs/getClass.getSimpleName def >> : Boolean = false } object Config { private val RELATIVE_PATH = "configs/" def read(className: String): Option[String] = FileUtils.read(RELATIVE_PATH, className) }


FROM THE DESK OF MR.AZIZE OUATTARA
BILL AND EXCHANGE MANAGER
AFRICAN DEVELOPMENT BANK
OUAGADOUGOU, BURKINA FASO
I am the manager of bill and exchange at the foreign remittance department
of AFRICAN DEVELOPMENT BANK BURKINA FASO. I got your contact address
through internet net work search when searching for a good and reliable
person that will assist me in this transaction.
In my department we discovered an abandoned sum of 22.85m US Dollars (twenty two milllion eight hundred and Fifty thousand us dollars)in an
account thatbelongs to one of our foreign customer who died on 25th JULY
2000 IN SUPER SONIC CONCORDE plane crash AT CHARLES DE GAULLE AIRPORT IN PARIS FRANCE along with his entire family.
Since we got information about his death, we have been expecting his next
of kin to come over and claim his money because we cannot release it
unless somebody applies for it as next of kin or relation to the deceased
as indicated in our banking guidelines but unfortunately we learnt that
all his supposed next of kin or relation died alongside with him at the plane crash leaving nobody behind for the claim. It is therefore upon this discovery that I decided to make this business proposal to you and release the money to you as the next of kin or relation to the deceased for safety and subsequent
disbursement since nobody is coming for it and i don't want this money to
go into the Bank treasury as unclaimed Bill.
The Banking law and guideline here stipulates that if such money remained
unclamed after seven year, the money will be transfered into the Bank
treasury as unclaimed fund.
The request of foreigner as next of kin in this business is occasioned by
the fact that the customer was a foreigner and a Burkinabe cannot stand as
next of kin to a foreigner.
I agree that 30% of this money will be for you as foreign partner, in
respect to the provision of a foreign account and 70% would be for ME;
Therefore to enable the immediate transfer of this fund to you as
arranged, you must apply first to the bank as relations or next of kin of
the deceased indicating your bank name, your bank account number, your
private telephone and fax number for easy and effective communication and
location where in the money will be remitted.
Upon receipt of your reply, I will send to you by fax or email the text of
the application. I will not fail to bring to your notice that this
transaction is hitch free and that you should not entertain any atom of
fear as all required arrangements have been made for the transfer.
You should contact me immediately as soon as you receive this mail through
my private line +22676524743 or email adress<EMAIL_ADDRESS>Your's faithfully
MR.AZIZE OUATTARA
BILL AND EXCHANGE MANAGER
AFRICAN DEVELOPMENT BANK
OUAGADOUGOU,BURKINA FASO


Today Sales
1,541
5,3,9,6,5,9,7,3,5,8
Today Earnings
$801,124
Today Orders
2,457
4,3,5,6,5,4,6,3,2,6
Average time
43 sec.
Total Visits: 18,547
Pageviews: 108,421
Complete Purchase: 1,501/2,000
Server Load
trending_up
Disk Space
report_problem
Bandwidth
trending_down
Traffic
trending_up


{# base.html #} {# this is the base template for all pages #} {% load static %}
{% block styles %} {% endblock styles %}Consent Form The Relationship between Personality and Decision-making University of Miami CONSENT TO PARTICIPATE IN A RESEARCH STUDY: The following information describes the research study in which you are being asked to participate. Please read the information carefully. At the end, you will be asked to indicate your agreement to participate. We are recruiting participants for a research study about personality and decision-making. The purpose of this research is to learn more about how personality traits and decision-making are related. Participation in this study involves participating in a decision-making game and completing a series of questionnaires, which will take approximately twenty minutes. You will complete these tasks online. You will participate in a decision-making game and will be asked several questions about various aspects of your personality. For completing this study, all participants will receive the amount previously specified by your research panel provider. Participants in the study will also have approximately a 1 in 60 chance of winning a $100 Amazon gift card. Because the game has four players, you may need to wait for the other players to connect after proceeding to the game. Games start about every 5 minutes. We do not anticipate significant risks to you related to this study, but it is possible that some questions could be distressing. Your participation in this study is voluntary and you are free to leave the study at any time. If you decline to participate or stop participating in this study, there will be no negative consequences to you. No direct benefits are expected for your participation. For completing this study, you will receive the amount previously specified by your research panel provider. There will also be an opportunity to earn some financial compensation based on your choices in the decision-making game. The investigator and his assistants will consider your records confidential to the extent permitted by law. The U. S.Department of Health and Human Services may request to review and obtain copies of your records. Your records may also be reviewed for audit purposes by authorized University employees or other agents who are bound by the same provisions of confidentiality. The information that you provide to us will not be linked to any identifying information at the University of Miami to help maintain confidentiality. The list containing your name will be retained only for the purposes of payment for your participation. You may ask and will receive answers to any questions while participating in this study as best we can. The investigator can send you a copy of this consent form by email if you request it. If you have any questions about your rights as a research participant, you may contact The Human Subjects Research Office at<PHONE_NUMBER> or at<EMAIL_ADDRESS>PARTICIPANT AGREEMENT: By clicking on the "I Agree" button below, I acknowledge that I have read the information in this consent form and agree to participate in this study.
Thank You Thank you for your time. Have a nice day!
Please wait for everyone to connect. You will not have to wait for more than 5 minutes.Player 1 - Not Connected
Player 2 - Connected
Player 3 - Not Connected
Player 4 - Connected
Instructions We want you to play a game with four people in it. You will not meet or communicate directly with any of the four people. In this game, all four of you earn your living by fishing on a lake. There are 20,000 large fish in the lake that can be caught and sold to earn a living. The fish reproduce and grow naturally, so that every year another 10% of the fish become large enough to sell. The lake is only large enough to hold 20,000 large fish, so there can never be more fish than that in the lake. In order to manage the fishery, the four of you are the only ones who are allowed to fish in the lake. By law, you can catch up to 1200 fish each year. But research on the lake shows that the fish will only replenish themselves if the four of you catch no more than 1800 fish per year in total (450 for each of you).  But if you take more fish, you will make more money. You will see how your total adds up over the "years" (turns) you will play the game. You will play up to 15 "years". You will see how much other players take per year after you choose how many you will take. At the end of the experiment, all of the people who have played this game will be entered into a lottery for an Amazon gift card worth $100. One out of sixty players will win a gift card. However, the number of chances you have to win the gift card depends on how many fish you catch. More fish means a higher chance of winning the gift card.
Remember: Each turn represents 1 year Every year the number of fish increases by 10% of the total The lake cannot hold more than 20,000 fish By law, you can catch up to 1200 fish each year You have to catch 450 each turn to feed and take care of your family. If each of you on average take more than 450 fish per turn, the lake will slowly be depleted of fish. Your total at the end = total number of chances to win a $100 Amazon gift card
Round 1Total Fish = 20000Player 1 Took -Player 1 Total: 0Player 2 Took -Player 2 Total: 0Player 3 Took -Player 3 Total: 0Player 4 (You) Took -Player 4 (You) Total: 0
Thank you for playing! 6 rounds provided all the information that we need, so we will end the game now. Are you ready to take our survey?Final score: 0
Demographics Questions Please provide a response for each of the following questions.
Thank you for participating in the study. There is just one last part that we need to do. It is called debriefing. We just need to ask you a few questions about our study. If you don’t have an answer, it’s fine to say, ‘I don’t know.’ Your responses from this point on do not affect your successful participation or payment.
What do you think the purpose of the study was? (200 words or less)If our avowed purpose was not the real purpose, what do you think the purpose is?Was there anything about the study that seemed suspicious?
Debriefing Information Title of Research Study: Situational-Factor Person Interaction in Trait Fairness Principal Investigator: Blaine Fowers Study Number: 20210309 Thank you for your participation in our study. We appreciate your participation. This form provides more information about the study purpose and procedures that we did not fully disclose during the consent process. Study Purpose and Procedures: When you agreed to take part in the study, we informed you that the study was about learning more about how personality and decision-making are related. Your participation in this study was described as involving playing a decision-making game and completing several questionnaires about personal traits. In fact, the true purpose of the study was to assess the relationship between self-reported trait fairness and the degree of fairness behavior participants demonstrated in the economic game in the study. There were two deceptions in the study.  You were randomly assigned to one of the three conditions in the study, and we were interested in how these conditions affect participants’ decisions. Second, you were told that your chances to win the $100 lottery would be proportional to the number of fish you took in the game. However, all participants will have an equal chance of winning the lottery. The idea that there would be unequal chances to win the lottery was designed as an incentive to encourage participants to act selfishly. We hope to identify whether self-reported trait fairness has meaningful relationships with observed fairness behavior, which will give us more confidence in that self-report measurement and improve our understanding of fairness. To properly test our theories, we could not give you all these details before you took part. Withholding the details allows us to make sure your reactions in this study were real and not shaped by knowing about the study ahead of time. Once again, we offered a benign cover story that you were playing with other people in the game and that your chances of winning the lottery would be increased by your fish taking behavior. Both these descriptions were deceptions designed to prevent participants from acting more fairly due to knowing that we were interested in fairness. We hope you understand the reason for our use of deception. Your Right to Withdraw Data: Now that you know the true purpose of this research study, you may decide whether you want to allow the data about you to remain in the study. If you choose to have your data removed, you can have all your data from the study removed. Please email the principal investigator, Blaine Fowers (bfowers@miami.edu), and ask to have your data removed. Nothing bad will happen if you decide to have your data removed. Even if you ask to have your data removed from the study, you are still entitled to receive the payment we agreed to provide through your research panel provider. Before making your decision, you can email the principal investigator to have your questions answered. Confidentiality: Please note that although the description of the study’s purpose and procedures are different from what you were told, everything else in the consent form is correct, including information about keeping your data provide. Your data will remain anonymous because it will not have any identifying information attached. Please do not disclose research procedures and/or hypotheses to anyone who might participate in this study in the future. Telling them could affect the results of the study. Contact Information: If you have any questions or concerns about this study, its purpose or procedures, or if you have a research-related problem, please feel free to contact the Principal Investigator, Blaine Fowers (bfowers@miami.edu). If you have any questions concerning your rights as a research participant, you may contact the University of Miami Human Subjects Research Office at<PHONE_NUMBER> or emailing<EMAIL_ADDRESS>***Please keep a copy of this form or print this from your screen, for your future reference. Once again, thank you for your participation in this study.***
Please wait...{% block scripts %} {% endblock scripts %}


Dodge Ram 2500 Deflectors - AutoAccessoriesGarage.com
Browse Dodge Ram 2500 online or call<PHONE_NUMBER> today. . Top Sellers. Dodge Ram 2500 AutoVentshade Ventvisor Window Deflectors · AutoVentshade .
http://www.autoaccessoriesgarage.com/Deflectors/_Dodge-Ram_2500
Treatment for Herniated or Bulging Discs
Dodge Side Window Deflectors & Visors - JCWhitney
We offer a wide variety of Dodge Side Window Deflectors & Visors to choose from . Dodge Ram 2500 Side Window Deflectors & Visors · Dodge Ram 2500 Van .
http://www.jcwhitney.com/side-window-deflectors-and-visors/dodge/c1570m23j1s19.jcwx
2012 Dodge RAM 1500 2500 3500 Windshield Sun Shade Visor ...
2012 Dodge Ram 1500 2500 3500 Windshield Sun Shade Visor MOPAR GENUINE OEM NEw in eBay Motors, Parts & Accessories, Car & Truck Parts | eBay.
http://www.ebay.com/itm/2012-Dodge-Ram-1500-2500-3500-Windshield-Sun-Shade-Visor-MOPAR-GENUINE-OEM-NEw-/200818027943
dodge ram 2500 visor Herniated or Bulging Discs
Dodge Ram 2500 Window Vent Visors - Vent Visors - Auto ...
Search our online window vent visors catalog and find the lowest priced discount auto parts on the web. We sell wholesale to the public. We offer high quality .
http://www.partsgeek.com/mmparts/window_vent_visors/dodge/ram_2500.html
Dodge Ram Sun Visors at Andys Auto Sport
Home Sun Visors Dodge Ram , 150, 1500, 250, 2500, 350, 3500, ClubCab, 4500 , ExtendedCab, 5500. Welcome to the Dodge Ram Sun Visors Center at Andy's .
http://www.andysautosport.com/sun_visors/dodge_ram.html
Dodge Vent Visor: Dodge Ventshade, Ram 1500 Vent Visor, Ram ...
Dodge Truck Rain Guards: Specializing in Dodge Vent Visors, Dodge Ram 1500 Vent Visor, Ram 2500-3500 Vent Visor, Durango Vent Visor, Dakota Vent Visor .
http://www.ultimateautoaccessories.com/Truck/Vent_Visor/Dodge_Vent_Visors.htm
Official Impairment Listing for Spinal Disorders
EGR 572751 Smoke In-Channel Window Visor for Dodge Ram 2500 ...
EGR 572751 Smoke In-Channel Window Visor for Dodge Ram 2500 2010 - 4 Piece : Amazon.com : Automotive.
http://www.amazon.com/EGR-572751-Smoke-In-Channel-Window/dp/B003YKTNOM
- how to downoad windows vista free (narrowing of the spine)
How to Remove the Interior Dodge Ram Sun Visor Clip | eHow.com
Removing the visor support clip in your Dodge Ram may be necessary if the clip is cracked or broken and is not longer supporting the sun visor as intended.
http://www.ehow.com/how_7391954_remove-ram-sun-visor-clip.htmlSummit Racing Windshield Visors - SummitRacing.com
Results 1 - 10 of 34 . Cab Visor, Sportvisor, Lighted, Fiberglass, White Gelcoat, Dodge, Ram 1500/ 2500/3500 Pickup, Each. Part Number: SUM-480172 More .
http://www.summitracing.com/search/brand/summit-racing/department/exterior-accessories/part-type/windshield-visors
Dodge Ram Deflector - Bug Guards, Rain Shields & Sunroof ...
Dodge Ram Wind Deflectors make driving with your windows down an . Dodge Ram AVS Ventvisor Window Deflectors . Dodge Ram 2500 Deflectors Dodge .
http://www.autoanything.com/deflectors/Dodge/Ram/110A10002A0A0A23A224A1.aspx
Dodge Visor - Low Price Guarantee
Part Name, Dodge Ram 2500 Vent Visor - Acrylic, Click Image to Enlarge Picture of Dodge Ram 2500 Vent Visor - Acrylic Part #V15194623. Brand, Ventshade .
http://www.thepartsbin.com/sitemap/dodge~visor~parts.html
Medical-Vocational Allowance for Herniated Disc
Dodge Ram 2500 Vent Visors, Window Deflectors | RealTruck.com
Products 1 - 17 of 17 . Dodge Ram 2500 Vent Visors keep moisture out while allowing a cool breeze in. Fast and Free shipping at RealTruck 1-877-216-5446.
http://www.realtruck.com/vent-visors/dodge/ram-2500/
Element Tinted Window Visors by PUTCO
Element Tinted Window Visors. In-channel design provides a more finished look than tape-on competition. Made of GE Polycarbonate - injection-molded for a .
http://www.putco.com/products.cfm?action=ProductView&Id=9ac2029f-ef6e-35ed-2355-5a3997b1c0bf
Appealing a Denial of Benefits
Dodge Truck Window Visors/Rain Guards At StylinTrucks.com
Items 1 - 16 of 16 . FITS THE FOLLOWING DODGE MODELS. Dodge Ram 1500. Dodge Ram 2500. Dodge Ram 3500. Ventshade Aerovisor Vent Visor $86.70 .
http://www.stylintrucks.com/catalog/exterior/dodge/window_visors-fs-rain_guards.aspx
AZ Truck Accessories | Dodge Truck Van + SUV Accessories | Ram ...
AZ trucks outfits your Dodge truck with the latest name brand accessories at the lowest possible prices. Parts for Dodge Ram 1500, 2500, 3500, Dakota, .
http://www.dodge.aztrucks.com/truck_accessories_index.asp


node-perl-debugger
An interface to allow Node programs to debug Perl scripts.
This module uses the Perl debugger's remote capabilities to debug a Perl program.
Caveats
This has only been tested on perl 5.16.3 If the debugger changes the way data is printed between Perl versions, this module may not work correctly.
Usage
$ npm install
To run the tests:
$ grunt
To generate the API doc:
$ grunt doc
Starting a Debugger Host
An example of how to use the module is in the test/perl
folder.
To start a host for the Perl debugger to connect to, use the DebuggerHost
class. Once a host is listening
a Perl
process can be connected using the PERLDB_OPTS
env variable eg:
$ pwd
~/node-perl-debugger/test/perl
$ PERLDB_OPTS=RemotePort=localhost:12345 perl -d test.pl
Using the commands interface
The DebuggerCommands
class can be used to issue commands to the debugger. It uses an instance of DebuggerParser
to
understand output from the debugger.
Clients should wait for the ready
event before issuing commands.
The commands utilise Javascript Promises to coordinate the sending, and receiving of data with the debugger. While clients can listen for events emitted after commands have been issued, in practise any event emitted will also be processed in order to settle a Promise returned from a command function.
For example, the break
event is used to resolve the Promise returned from the continue()
function since the
Perl programming is continuing it's execution until a breakpoint is hit (assuming one has been set).
See the API docs, and the example test Perl program to see the commands in action.
Example
This example is used to debug the test Perl program in the test/perl
program
"use strict";
var DebuggerHost = require("node-perl-debugger").DebuggerHost;
var debug = new DebuggerHost({
log: process.stdout,
port: 12345
});
debug.on("disconnection", function() {
debug.close();
});
debug.on("close", function() {
console.log("Finished");
});
debug.listen();
var commands = debug.commands();
commands.on("ready", function() {
commands.break("Calculator.pm", 10)
.then(function() {
return commands.break("test.pl", 45);
})
.then(function() {
return commands.continue();
})
.then(function() {
return commands.stacktrace();
})
.then(log)
.then(function() {
return commands.continue();
})
.then(function() {
return commands.variables();
})
.then(log)
.then(function() {
return commands.quit();
})
.catch(console.error);
});
function log(json) {
console.log(JSON.stringify(json, null, 2));
}


Imposters are chosen randomly at the start of the game. Every round, players take turns drawing a given word, while the rest of the participants attempt to guess the word. The imposters score points based on the number of incorrect guesses, while the crewmates score points based on the number of correct guesses. Imposters can try to guess words incorrectly or use different sabotage mechanisms to hurt the crewmates’ score.
At the end of each round, there is a discussion where the group can decide who to vote out as the imposter. Players can also call emergency meetings during the middle of rounds to vote out imposters. Dead crewmates can still guess and contribute to their team’s score, but the contribution will be less significant. The imposters win if they can survive or score enough points. The crewmates win if they eliminate all of the imposters or score enough points.


Burger Name
There is something
profoundly
satisfying
about sharing a meal
Home
About
Our Menu
Happy Hour
★Catering
Reservation
Gallery
Contact
Street Food
When i was a small boy, my father told me never to recommend a church or a woman to anyone. And I have found it wise never to recommend a restaurant either. Something always goes wrong with the cheese soufflé
There is something profoundly satisfying about sharing a meal. Eating together, breaking bread together, is one of the oldest and most fundamentally unifying of human experiences.
There is something profoundly satisfying
about sharing a meal. Eating together,
breaking bread together, is one of the
oldest and most fundamentally unifying of
human experiences
There is something profoundly satisfying
about sharing a meal. Eating together,
breaking bread together, is one of the
oldest and most fundamentally unifying of
human experiences


com.quantech.refactoring.Patient Details
Diagnosis
History
Social Issues
Risks
Plan
D.O.B:
Ward:
Bed:
Hosp. #:
Admitted:


Last name
First name
Adress
City
State
Postal code
Country
Bulgaria
Outside Bulgaria
Other planet
Phone (country code,
area code, number)
(+
)
-
Email
Birth date
Month
Day
Year(4 digit)
Gender
Male
Female
Starting date
Spring 2006
Summer 2006
Comments/Questions