Although this one's not too bulky. ;)
Image of BODY section: 
.
Image of EXTENDED section: 
Problem: You have a number of sets and you want all the combinations when choosing one element from each set.
In mathematics, these combinations are called the Cartesian products. They are also known as cross-products. In the database world, they are sometimes called cross-joins.
Although this one's not too bulky. ;)
Image of BODY section: .
Image of EXTENDED section:
The first one is easy: Perl uses braces to delimit blocks of
code.
This may be to provide isolation. For example to slurp a file:
open my $fh, '<', $some_file or die $!;# have to declare lines outside of the block
# or it will be dropped at the end
my $lines;{
# set the input record separator to undef,
# see `perldoc perlvar`
# and search for /INPUT_RECORD_SEPARATOR/
local $/;$lines = <$fh>;
}
close $fh or die $!;
Blocks must be used with the compound statements like
"http://perldoc.perl.org/perlsyn.html#Compound-Statements" class=
"podlinkurl">if,
"http://perldoc.perl.org/perlsyn.html#Compound-Statements" class=
"podlinkurl">while, and
"http://perldoc.perl.org/perlsyn.html#Compound-Statements" class=
"podlinkurl">for. They are also used with commands
like
"podlinkurl">map and
"http://perldoc.perl.org/functions/grep.html" class=
"podlinkurl">grep.
Braces are used with a hash to access the value.
print $hash{$key};
Braces are used to create anonymous hashes.
my $hash_ref = { foo => 'bar' };
Braces are used in de-referencing, especially for arrays and
hashes.
for my $item ( @{ $obj->{list} } ){
# ...
}for my $key ( sort keys %{ $obj->{config} } ){
# ...
}
Braces are used to to isolate a file handle.
print {STDERR} "Error detected.\n";
This is the only way to use a file handle in a data structure.
print {$object->{out_fh}} "Error detected.\n";
"http://perldoc.perl.org/perlop.html#Quote-and-Quote-like-Operators"
class="podlinkurl">Generic quotes can be delimited with braces.
my $SPACE = q{ };
my $NL = qq{\n};s{ \A \s+ }{}msx;
s{ \s+ \z }{}msx;
Braces are use in string interpolation to create special characters
and to delimit them from the rest of the text.
"\o{033}"
"\x{1b}"
\N{ESC}""\x{2022}"
"\N{U+2022}"
They are also used to separate a variable name from other
alphanumerics.
print "Using temporary file ${src_file}_tmp";
In regular expressions, braces are used for specifying quantifiers
of matches.
# look for two or more underscores
if( m{ _{2,} }msx ){
# ...
}
Code can be embedded in regular expressions in the newer versions of
Perl.
perl -nE'm{ ( [aeiou] ) (?{ say "$1" }) }msx'
Perl's built-in datatype, array, is a multi-purpose tool which can be used for many things. It's primary purpose is to preserve the order of data. But it comes with a powerful set of tools to make manipulating it easy. This article is to show how to use these tools by implementing a linked list.
Linked lists were originally created for languages like C which only had simple datatypes. They are a technique for using the system's memory allocation to create a data structure that allows unlimited expansion, that is, until it runs out of memory. They use a simple datatype called a pointer that records a position in memory. Without pointers, linked list would be impossible.
Perl has a datatype similar to pointers, the reference. Like pointers, it records a memory location and it can be used link them. But using references to implement a linked list the same way one would do in C, needlessly complicates the code. Linked lists can be implemented using just arrays. Here's how.
]]> The Difference Between an Array and a ListPerl makes a distinction between an array and a list. An array is a datatype and has permanent storage for its contents. This allows a reference to be made to it. A list is a temporary structure and cannot be referenced. Lists are used both as parameters to a subroutine and their returned values. And lists can be assigned to arrays and hashes to store their values.
Simply declare an array using my or our.
my @list = ();
Clear the array by assigning the empty list to it.
@list = ();
Use the push command to addend the item to the end of
the array.
push @list, $item;
The unshift command will insert the item at the
beginning of the array.
unshift @list, $item;
The pop command will remove an item from the end
of the array.
$item = pop @list;
The shift command will remove an item from the
beginning of the array.
$item = shift @list;
To check if an item is in a list, use first from List::Util. List::Util is a
standard Perl module and is installed with Perl. For a list of all the
standard modules and pragmatics, see perlmodlib.
use List::Util qw( first );
$found = defined( first { $_ eq $item } @list );
The test inside the block may be replaced with a match. Any valid pattern may be used.
$found = defined( first { /^$item$/i } @list );
To count the occurrences of an item in a list, use grep.
$count = grep { $_ eq $item } @list;
The test inside the block may be replaced with a match. Any valid pattern may be used.
$count = grep { /^$item$/i } @list;
A list can be reversed with the reverse command.
@list = reverse @list;
An array can be rotated by combining the shift and
push commands.
push @list, shift @list;
An array can be rotated backward by combining the pop and
unshift commands.
unshift @list, pop @list;
Extracting a single item from a list can be done by indexing the position in the list.
$item = $list[$i];
An item can be replacing with indexing.
$list[$i] = $item;
To extract a list of items from the i-th to j-th position
inclusive, use a slice.
@items = @list[ $i .. $j ];
Items can be replaced by assigning them to a slice.
@list[ $i .. $j ] = @items;
The range of items from the i-th to the j-th position
inclusive will be replaced. If @items is longer than the
range, those left over will be ignored. If it is shorter,
undef will be place in @list.
spliceAlthough slices can be used to replace items in a list, it will not
remove them. Use Perl's splice command for this.
Removing a number of items starting in the i-th position of list. The list will shrink in size by the number of items removed.
@removed_items = splice( @list, $i, $number );
Inserting a number of items starting in the i-th position of list. The list will grow in size by the number of items inserted.
splice( @list, $i, 0, @items );
Replacing a number of items with others starting in the i-th position. The list will grow or shrink to accommodate the new items. The removed items can be saved.
@saved_items = splice( @list, $i, $number, @new_items );
Perl's array datatype has powerful tools that can be used for many tasks.
]]>Because of deadlines, many programmers create Quick & Dirty
(Q&D) code rather than doing things The Right Way. This
leads to many problems.
• Deadlines cause bugs
When programmers write Q&D, they often ignore edge cases. This means the code reject things it should process and process things that is should reject.
• Deadlines cause delays
Because of the bugs, the code doesn't work when the deadline arrives and the deadline has to be extended.
• Deadlines undermine the confidence of the programmers
IBM sets its sales quote so that 80% of its sales force will meet them. When was the last time you heard of a manager setting the deadlines so that 80% of his programmers meet them? In fact, many managers set their deadlines so that their programmer can't possible meet them. They assume that this will make their programmers work harder. And it does. They work harder but are less productivity in their work. That's because repeats failures undermine their confidence which increases stress and reduces productivity.
• Deadlines undermines any sort of company spirit
Because programmers repeatedly fail to meet their deadlines, they lose any interest in their work and this undermines any loyalty or team spirit they might have.
• Deadlines causes turnover
Because of the programmers' low morale, they often switch jobs to find more interesting work.
In summary, deadlines are just a bad idea.