<?xml version="1.0" encoding="iso-8859-1"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:content="http://purl.org/rss/1.0/modules/content/">

<channel>
<title>Perl - Web Developer Tutorials</title>
<link>http://www.devshed.com</link>
<!-- PubSubHubbub Discovery -->
<link rel="hub"  href="http://devshednet.superfeedr.com/" xmlns="http://www.w3.org/2005/Atom" />
<link rel="self" href="http://www.devshed.com/rss-feeds-10.xml" xmlns="http://www.w3.org/2005/Atom" />
<!-- End Of PubSubHubbub Discovery -->
<atom:link href="http://www.devshed.com/rss-feeds-10.xml" rel="self"/>
<description>Perl Tutorials at Dev Shed.  DevShed is a community focused on both beginner and advanced tutorials in Java, C, PHP, Python, MySQL and Ruby-on-rails...amongst others.</description>
<language>en-us</language>
<lastBuildDate>Sun, 19 May 2013 18:47:16 -0400</lastBuildDate>
<pubDate>Sun, 19 May 2013 18:47:16 -0400</pubDate>
<item><title>Perl Turns 25</title>
<pubDate>Mon, 07 Jan 2013 16:48:09 -0500</pubDate>
<link>http://www.devshed.com/c/a/Perl/Perl-Turns-25-82606/</link>
		<description><![CDATA[Last month, not long before all the holiday excitement set in, the programming language Perl quietly turned 25. The language has grown and changed a great deal since Larry Wall unveiled version 1. But so has the programming world in general. Is there still a place for this versatile yet infuriating open source creation?]]></description>
		<content:encoded><![CDATA[As the Register pointed out, when Wall first posted the source code to the Usenet newsgroup comp.sources.misc on December 18, 1987, he probably never envisioned what it would turn into. At the time, he was working as a programmer at Unisys, and saw it as a Unix scripting language. It quickly became much more, however. By 1994, the language was up to its fifth version, and supported objects, references, modules, and regular expressions. It became one of the earliest languages used for developing web applications. As an interpreted language, programmers appreciated the speed with which they coul...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/Perl-Turns-25-82606/</guid>
</item>
<item><title>Lists and Arguments in Perl</title>
<pubDate>Tue, 08 May 2012 12:00:06 -0400</pubDate>
<link>http://www.devshed.com/c/a/Perl/Lists-and-Arguments-in-Perl/</link>
		<description><![CDATA[In this conclusion to a six-part article series on subroutines and functions in Perl, you'll learn more about lists and arrays, and take a look at default argument values. This article was excerpted from chapter six of the book Beginning Perl, Second Edition, written by James Lee (Apress; ISBN: 159059391X).]]></description>
		<content:encoded><![CDATA[Lists Are One Dimensional  Recall that all lists and all arrays are one dimensional. If we have this list:   (@a, @b)   it becomes a one-dimensional list containing the contents of @a followed by the contents of @b . This is an important rule when it comes to passing arrays into functions, since they will be passed in as a one-dimensional list. This is illustrated in the following example:   #!/usr/bin/perl -w # passarrays.pl  use strict;  my(@nums1, @nums2); @nums1 = (2, 4, 6); @nums2 = (8, 10, 12);  process_arrays(@nums1, @nums2);  sub process_arrays     This program creates two 3-element ar...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/Lists-and-Arguments-in-Perl/</guid>
</item>
<item><title>Variables and Arguments in Perl</title>
<pubDate>Wed, 02 May 2012 12:30:06 -0400</pubDate>
<link>http://www.devshed.com/c/a/Perl/Variables-and-Arguments-in-Perl/</link>
		<description><![CDATA[In this fifth part to a six-part article series on subroutines and functions in Perl, you'll learn about lexical variables, and how passing arguments works. This article was excerpted from chapter six of the book Beginning Perl, Second Edition, written by James Lee (Apress; ISBN: 159059391X).]]></description>
		<content:encoded><![CDATA[Lexical Variables (aka Local Variables)  The range of effect that a variable has is called its scope, and lexical variables declared with my() are said to have lexical scope. This is also known as local scope. That is, they exist from the point where they're declared until the end of the enclosing block. The name  lexical  comes from the fact that they're confined to a well-defined chunk of text.    my $x; $x = 30;   print $x; # This $x is, and always has been, 30.   Great. We can now use variables in our subroutines in the knowledge that we're not going to upset any behavior outside them. Let...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/Variables-and-Arguments-in-Perl/</guid>
</item>
<item><title>Understanding Scope and Packages in Perl</title>
<pubDate>Mon, 23 Apr 2012 11:30:05 -0400</pubDate>
<link>http://www.devshed.com/c/a/Perl/Understanding-Scope-and-Packages-in-Perl/</link>
		<description><![CDATA[In this fourth part of a six-part article series on subroutines and functions in Perl, you will learn about two different types of variables (global and lexical) and their scopes. You will also learn what a package is. This article was excerpted from chapter six of the book Beginning Perl, Second Edition, written by James Lee (Apress; ISBN: 159059391X).]]></description>
		<content:encoded><![CDATA[Understanding Scope  It's now time to have a look at what we're doing when we declare a variable with my() . The truth, as we've briefly glimpsed it, is that Perl has two types of variable. One type is the global variable (or package variable), which can be accessed anywhere in the program, and the second type is the lexical variable (or local variable), which we declare with my() .  Global Variables  All variables in the program are global by default. Consider this code:   #!/usr/bin/perl -w  $x = 10;  $x is a global variable. It is available in every subroutine in the program. For instance, ...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/Understanding-Scope-and-Packages-in-Perl/</guid>
</item>
<item><title>Arguments and Return Values in Perl</title>
<pubDate>Wed, 11 Apr 2012 09:00:05 -0400</pubDate>
<link>http://www.devshed.com/c/a/Perl/Arguments-and-Return-Values-in-Perl/</link>
		<description><![CDATA[In this third part of a six-part article series on subroutines and functions in Perl, you'll learn about passing arguments into functions, and implicitly and explicitly getting return values. This article was excerpted from chapter six of the book Beginning Perl, Second Edition, written by James Lee (Apress; ISBN: 159059391X).]]></description>
		<content:encoded><![CDATA[Passing Arguments into Functions  As well as being set pieces of code to be executed whenever we need them, we can also use our user-defined functions just like Perl's built-in functions-we can pass arguments (aka parameters) to the subroutine and expect an answer back.  Just like with Perl's built-ins, we pass parameters by placing them between the parentheses:   my_sub(10,15);   What happens to them there? Well, they end up in one of Perl's special variables, the array @_ , and from there we can get at them. We'll illustrate this with a subroutine that takes a list of values, adds them up, a...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/Arguments-and-Return-Values-in-Perl/</guid>
</item>
<item><title>Invoking Perl Subroutines and Functions</title>
<pubDate>Wed, 29 Feb 2012 13:00:05 -0500</pubDate>
<link>http://www.devshed.com/c/a/Perl/Invoking-Perl-Subroutines-and-Functions/</link>
		<description><![CDATA[In this second part of a six-part article series on subroutines and functions in Perl, you will learn how to invoke a subroutine and a function. This article was excerpted from chapter six of the book Beginning Perl, Second Edition, written by James Lee (Apress; ISBN: 159059391X).]]></description>
		<content:encoded><![CDATA[Invoking a Subroutine  The conventional way to invoke a function is to follow the function name with parentheses. This invokes the example_subroutine() function:    example_subroutine();   If the function takes arguments (more on passing arguments later in this chapter), then drop them within the parentheses:   example_subroutine('Perl is', 'my favorite', $language);   Let's look at a complete example. It's traditional for programs to tell you their version and name either when they start up or when you ask them with a special option. It's also convenient to put the code that prints this infor...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/Invoking-Perl-Subroutines-and-Functions/</guid>
</item>
<item><title>Subroutines and Functions in Perl</title>
<pubDate>Fri, 10 Feb 2012 09:00:05 -0500</pubDate>
<link>http://www.devshed.com/c/a/Perl/Subroutines-and-Functions-in-Perl/</link>
		<description><![CDATA[Subroutines and functions save time by letting you reuse code. This six-part series will show you how to create and use them in Perl. This article was excerpted from chapter six of the book Beginning Perl, Second Edition, written by James Lee (Apress; ISBN: 159059391X).]]></description>
		<content:encoded><![CDATA[When programming, there will naturally be activities we will want to do again and again: adding up the values in an array, stripping extraneous blank spaces from a string, getting infor mation into a hash in a particular format, and so on. It would be tedious to write out the code for each of these little processes every time we need to use one, and maintaining each code segment would be horrific: if there's a bug in the way we've coded the activity, we'll have to go through and find each one of them and fix it. It would be better if we could define a particular process just once, and then be ...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/Subroutines-and-Functions-in-Perl/</guid>
</item>
<item><title>Perl Basics: Writing and Debugging Programs</title>
<pubDate>Wed, 18 Jan 2012 12:00:05 -0500</pubDate>
<link>http://www.devshed.com/c/a/Perl/Perl-Basics-Writing-and-Debugging-Programs/</link>
		<description><![CDATA[In this third part of a three-part article series on the basics of Perl programming, you'll learn how to use escape sequences in your programming, and how to use the Perl debugger. This article is excerpted from chapter one of the book Beginning Perl, Second Edition by James Lee (Apress; ISBN: 159059391X).]]></description>
		<content:encoded><![CDATA[Escape Sequences  UTF8 gives us 65536 characters, and ASCII gives us 256 characters, but on the average keyboard, there's only a hundred or so keys. Even using the shift keys, there will still be some characters that you aren't going to be able to type. There'll also be some things that you don't want to stick in the middle of your program, because they would make it messy or confusing. However, you'll want to refer to some of these characters in strings that you output. Perl provides us with mechanisms called escape sequences as an alternative way of getting to them. We've already seen the us...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/Perl-Basics-Writing-and-Debugging-Programs/</guid>
</item>
<item><title>Structure and Statements in Perl</title>
<pubDate>Wed, 11 Jan 2012 12:00:06 -0500</pubDate>
<link>http://www.devshed.com/c/a/Perl/Structure-and-Statements-in-Perl/</link>
		<description><![CDATA[In this second part of a three-part series on Perl programming, you'll learn how to structure your programs, and how to use statements. This article is excerpted from chapter one of the book Beginning Perl, Second Edition by James Lee (Apress; ISBN: 159059391X).]]></description>
		<content:encoded><![CDATA[Program Structure  One of the things we want to develop throughout this book is a sense of good programming practice. Obviously this will not only benefit you while using Perl, but in almost every other programming language too. The most fundamental notion is how to structure and lay out the code in your source files. By keeping this tidy and easy to understand, you'll make your own life as a programmer easier.   Documenting Your Programs   As we mentioned earlier, a line starting with a hash, or pound sign ( # ), is treated as a comment, and ignored. This allows you to provide comments about ...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/Structure-and-Statements-in-Perl/</guid>
</item>
<item><title>First Steps in Perl</title>
<pubDate>Thu, 05 Jan 2012 11:30:04 -0500</pubDate>
<link>http://www.devshed.com/c/a/Perl/First-Steps-in-Perl/</link>
		<description><![CDATA[In this first part of a three-part series, you'll learn the fundamentals of programming in Perl. This article is excerpted from chapter one of the book Beginning Perl, Second Edition by James Lee (Apress; ISBN: 159059391X).]]></description>
		<content:encoded><![CDATA[Every programming language has a number of things in common. The fundamental concepts of programming are going to be the same, no matter what language in which you do them. In this chapter, we'll investigate the things you need to know before you start writing any programs at all. For instance:    What is programming anyway? What does it mean to program?     How do we structure programs, and make them easy to understand?     How do computers see numbers and letters?     How do we find and eliminate errors in our programs?  Of course, we'll be looking at these from a Perl perspective, and we'll...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/First-Steps-in-Perl/</guid>
</item>
<item><title>Completing Regular Expression Basics</title>
<pubDate>Thu, 10 Jun 2010 10:00:08 -0400</pubDate>
<link>http://www.devshed.com/c/a/Perl/Completing-Regular-Expression-Basics/</link>
		<description><![CDATA[In this conclusion to a four-part series on parsing and regular expression basics in Perl, we finish our study of regular expressions; you'll even learn how to create your own. This article is excerpted from chapter one of the book Pro Perl Parsing, written by Christopher M. Frenz (Apress; ISBN: 1590595041).]]></description>
		<content:encoded><![CDATA[Regexp::Common::Comments  This module generates regular expressions that match comments inserted into computer code written in a variety of programming languages (currently 43). The syntax to call these regular expressions is as follows, where   refers to the base comment matching functionality and   provides the descriptor that indicates the particular programming language:    $RE     For example, to match Perl and C++ comments, you can use the following:   $RE   $RE    Regexp::Common::Delimited  This base module provides the functionality required to match delimited strings. The syntax is si...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/Completing-Regular-Expression-Basics/</guid>
</item>
<item><title>Modifiers, Boundaries, and Regular Expressions</title>
<pubDate>Thu, 03 Jun 2010 10:00:09 -0400</pubDate>
<link>http://www.devshed.com/c/a/Perl/Modifiers-Boundaries-and-Regular-Expressions/</link>
		<description><![CDATA[In this third part to a four-part series on parsing and regular expressions in Perl, you will learn about cloistered pattern modifiers, boundary assertions, troubleshooting regular expressions, and more. This article is excerpted from chapter one of the book Pro Perl Parsing, written by Christopher M. Frenz (Apress; ISBN: 1590595041).]]></description>
		<content:encoded><![CDATA[Cloistered Pattern Modifiers   In the previous section, you saw how to apply pattern modifiers to an entire regular expression. It is also possible to apply these modifiers to just a portion of a given regular expression; however, the syntax is somewhat different. The first step is to define the subpattern to which you want the modifier to apply. You accomplish this by placing the subpattern within a set of parentheses. Immediately after the open parenthesis, but before the subpattern, you add ?modifiers: . For example, if you want to match either ABC or AbC , rather than using alternation, yo...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/Modifiers-Boundaries-and-Regular-Expressions/</guid>
</item>
<item><title>Quantifiers and Other Regular Expression Basics</title>
<pubDate>Thu, 27 May 2010 10:00:11 -0400</pubDate>
<link>http://www.devshed.com/c/a/Perl/Quantifiers-and-Other-Regular-Expression-Basics/</link>
		<description><![CDATA[In this second part of a four-part series on parsing and regular expression basics in Perl, you'll learn about quantifiers, modifiers, and more. This article is excerpted from chapter one of the book Pro Perl Parsing, written by Christopher M. Frenz (Apress; ISBN: 1590595041).]]></description>
		<content:encoded><![CDATA[Quantifiers   As you saw in the previous section, you can create a simple regular expression by simply putting the characters or the name of a variable containing the characters you seek to match between a pair of forward slashes. However, suppose you want to match the same sequence of characters multiple times. You could write out something like this to match three instances of Yes in a row:    /YesYesYes/   But suppose you want to match 100 instances? Typing such an expression would be quite cumbersome. Luckily, the regular expression engine allows you to use quantifiers to accomplish just s...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/Quantifiers-and-Other-Regular-Expression-Basics/</guid>
</item>
<item><title>Parsing and Regular Expression Basics</title>
<pubDate>Thu, 20 May 2010 10:00:10 -0400</pubDate>
<link>http://www.devshed.com/c/a/Perl/Parsing-and-Regular-Expression-Basics/</link>
		<description><![CDATA[Parsing helps us to extract the information we need from the mounds of data available. Regular expressions assist us in the hunt. This four-part article series will show you how to use Perl with regular expressions to accomplish your parsing tasks. It is excerpted from chapter one of the book Pro Perl Parsing, written by Christopher M. Frenz (Apress; ISBN: 1590595041).]]></description>
		<content:encoded><![CDATA[The dawn of a new age is upon us, an information age, in which an ever-increasing and seemingly endless stream of new information is continuously generated. Information discovery and knowledge advancements occur at such rates that an ever-growing num ber of specialties is appearing, and in many fields it is impossible even for experts to master everything there is to know. Anyone who has ever typed a query into an Internet search engine has been a firsthand witness to this information explosion. Even the most mundane terms will likely return hundreds, if not thousands, of hits. The sciences, e...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/Parsing-and-Regular-Expression-Basics/</guid>
</item>
<item><title>Hash Functions</title>
<pubDate>Thu, 06 May 2010 10:00:10 -0400</pubDate>
<link>http://www.devshed.com/c/a/Perl/Hash-Functions/</link>
		<description><![CDATA[In this second part of a two-part series on hashes in Perl, you'll learn about hash functions and hashes in different contexts. This article is excerpted from chapter five of the book Beginning Perl, written by James Lee (Apress; ISBN: 159059391X).]]></description>
		<content:encoded><![CDATA[Hash in List Context  When we discussed lists and arrays, we spent a lot of time talking about the difference between list and scalar context. Let's look at what happens when we evaluate a hash in list context. This is demonstrated with the following program:   #!/usr/bin/perl -w # listcontext.pl  use strict;  my %person = (     name  = gt; 'John Doe',     age   = gt; 39,     phone = gt; '555-1212',     city  = gt; 'Chicago'  );  my @data = %person;  print  quot;list context:  quot;, join( quot;| quot;, @data),  quot;\n quot;; print  quot;another way:  quot;, %person,  quot;\n quot;;   This pr...]]></content:encoded>
<category>Perl</category>
<guid isPermaLink="true">http://www.devshed.com/c/a/Perl/Hash-Functions/</guid>
</item>
</channel>
</rss>
