The Tel Aviv Open Source Developers Club (OSDClub) (formerly the Tel Aviv
Linux Club and other clubs such as Perl-Israel) will hold a meeting on
21/September (next Sunday). Ori Idan will deliver a presentation about
the Semantic Web.

Ori is the director of the Israeli branch of the World-Wide-Web
Consortium (W3C), and is a very good presenter, so it is recommended to
attend.

The meeting will take place at 18:30 in the Schreiber Maths and Computer
Science building of Tel Aviv University, room 008. Attendance is free of
charge and everyone are welcome.

Read more from Perlsphere.

NAME

“Perl 5 to 6″ Lesson 20 - A grammar for (pseudo) XML

SYNOPSIS

grammar XML {
token TOP { ^ $ };
token xml { [ ]* };
token plain { <-[<>&]>* };
rule tag {
‘<'(\w+) *
[
| '/>' # a single tag
| '>''' # an opening and a closing tag
]
};
token attributes { \w+ ‘=”‘ <-["<>]>* ‘”‘ };
};

DESCRIPTION

So far the focus of these articles has been the Perl 6 language,
independently of what has been implemented so far. To show you that it’s
not a purely fantasy language, and to demonstrate the power of grammars,
this lesson shows you the development of a grammar that parses basic XML,
and that runs with rakudo todo. I used revision 30633 for this, so in
order to reproduce it reliably, you should check out the same revision.

On a Unix like OS, this might look like this:

svn co -r 30633 https://svn.perl.org/parrot/trunk parrot
cd parrot
perl Configure.pl && make
cd languages/perl6/ && make perl6

Windows users have to build perl6.exe in the last step instead.

Now run make spectest_regression, and if you get any failures, please
send a mail to rakudobug@perl.org.

Our idea of XML

For our purposes XML is quite simple: it consists of plain text and
nested tags that can optionally have attributes. So here are few tests
for what we want to parse as valid “XML”, and what not:

my @tests = (
[1, 'abc' ], # 1
[1, '' ], # 2
[1, '..foodd' ], # 3
[1, 'c' ], # 4
[1, 'c'], # 5
[1, 'c' ], # 6
[1, 'c' ], # 7
[0, '<' ], # 8
[0, 'b' ], # 9
[0, 'b [0, 'b' ], # 11
[1, '' ], # 12
[1, '' ], # 13
);

$ ./perl6 xml-01.pl
not ok 1 - ‘abc’
ok 2 - ‘‘
not ok 3 - ‘..foodd’
not ok 4 - ‘c‘
not ok 5 - ‘c‘
not ok 6 - ‘c‘
not ok 7 - ‘c‘
ok 8 - ‘<'
ok 9 - 'b‘
ok 10 - ‘b ok 11 - 'b‘
not ok 12 - ‘‘
not ok 13 - ‘‘

$ ./perl6 xml-03.pl
ok 1 - ‘abc’
not ok 2 - ‘‘
(rest unchanged)

Why in the seven hells did the second test stop working? The answer is
that Rakudo doesn’t do longest token matching yet, but matches
sequentially. matches the empty string (and thus always), so

Eric Wilhelm asked the mentors of the Google Summer of Code projects 2008
to share their thoughts on the program and their project, so here is my
blah.

I mentored Adrian Kreher’s project Flesh Out the Perl 6 Test Suite, and
overall I’m very pleased.

After being talked into becoming a mentor by Jerry “particle” Gay I was a
a little nervous and not really sure if I was up to the task. So I did
what my student would be doing later on: write new tests, review old
ones, move them to the “official” part of the test suite, and adapt them
so that Rakudo can run them (which basically means selectively disabling
tests).

On The perl soc mentor’s list I found a few links to guides on how to be
a good mentor, which I read and which boil down to “communicate with your
student, run his code and give him some feedback”.

So we (my student and I) made contact, scheduled regular meetings on IRC,
I answered a few questions of his, and thus the project began.

Adrian’s work was very good in terms of quality, and after a few minor
corrections and nits from my part I made myself mostly superfluous, he
worked on his own. I continued to monitor his commits, filled out the mid
term and end of term surveys, and thusly passed the project for me.

Assessing the work on the test suite is a bit harder than with other
project, because most projects had rather clear goals, whereas in this
project the goal was “clean up the test suite as much as possible”. It
was clear from the beginning that Adrian wouldn’t be able to make it
through the whole test suite (roughly 900 files, 20k+ tests), so the
quantitative goal was to create and mofify 1000 tests, which was met, as
far as measurable.

As stated before I am very pleased both with Adrian’s work (which
actually helped the Rakudo developers a lot), and with the whole
infrastructure; there was very little administrative work to do and
everybody I dealt with was friendly and helpful.

So if all works well (enough free time, and proposals which fit my
abilities) I’ll surely offer to mentor again.

Read more from Perlsphere.

NAME

“Perl 5 to 6″ Lesson 11 - Changes to Perl 5 Operators

SYNOPSIS

# bit wise operators
5 +| 3; # 7
6 +^ 3 # 6
5 +& 3; # 1
“b” ~| “d” # ‘f’

# string concatenation
‘a’ ~ ‘b’ # ‘ab’

# file tests
if ‘/etc/passwd’ ~~ :e { say “exists” }

# repetition
‘a’ x 3 # ‘aaa’
‘a’ xx 3 # ‘a’, ‘a’, ‘a’

# ternary op
$a == $b ?? 2 * $a !! $b - $a

# chained comparisons
if 0 <= $angle < 2 * pi { ... }

DESCRIPTION

All the numeric operators (+, -, /, *, **, %) remain unchanged.

Since |, ^ and & now construct junctions, the bit wise operators have a
changed syntax. They now contain a data prefix, so for example +| is bit
wise OR with numeric context, and ~^ is one's complement on a string. Bit
shift operators changed in the same way.

String concatenation is now ~, the dot . is used for method calls.

File tests are now formulated in Pair notation, Perl 5 -e is now :e. If
something other than $_ should be used as the file name, it can be
supplied via $filename ~~ :e.

The repetition operator x is now split into two operators: x replicates
strings, xx lists.

The ternary operator, formerly $condition ? $true : $false, is now
spelled $condition ?? $true !! $false.

Comparison operators can now be chained, so you can write $a < $b < $c
and it does what you mean.

MOTIVATION

Many changes to the operators aim at a better Huffman coding, ie give
often use things short names (like . for method calls) and seldomly used
operators a longer name (like ~& for string bit-wise AND).

The chaining comparison operators are another step towards making the
language more natural, and allowing things that are commonly used in
mathematical notation.

SEE ALSO

http://perlcabal.org/syn/S03.html#Changes_to_Perl_5_operators

Read more from Perlsphere.

NAME

“Perl 5 to 6″ Lesson 07 - Junctions

SYNOPSIS

if $x eq 3|4 {
say ‘$x is either 3 or 4′
}
say ((2|3|4)+7).perl # (9|10|11)

DESCRIPTION

Junctions are superpositions of unordered values. Operations on junctions
are executed for each item of the junction separately (and maybe even in
parallel), and the results are assembled in a junction of the same type.

The junction types only differ when evaluated in boolean context. The
types are any, all, one and none.

Type Infix operator
any |
one ^
all &

1 | 2 | 3 is the same as any(1..3).

my Junction $weekday = any Thursday Friday Saturday Sunday>
if $day eq $weekday {
say “See you on $day”;
}

In this example the eq operator is called with each pair $day, ‘Monday’,
$day, ‘Tuesday’ etc. and the result is put in an any-Junction again. As
soon as the result is determined (in this case, as soon as one comparison
returns True) it can abort the execution of the other comparisons.

This works not only for operators, but also for subs:

if 2 == sqrt(4 | 9 | 16) {
say “YaY”;
}

To make this possible, junctions stand outside the normal type hierarchy
(a bit):

Object
/ \
Any Junction
/ | \
All other types

If you want to write a sub that takes a junction and doesn’t autothread
over it, you have to declare the type of the parameter either as Object
or Junction

sub dump_yaml(Object $stuff) {
# we hope that YAML can represent junctions ….
}

A word of warning: Junctions can behave counter-intuitive sometimes. With
non-junction types $a != $b and !($a == $b) always mean the same thing.
If one of these variables is a junction, that might be different:

my Junction $b = 3 | 2;
my $a = 2;
say “Yes” if $a != $b ; # Yes
say “Yes” if !($a == $b); # no output

2 != 3 is true, thus $a != 2|3 is also true. On the other hand the $a ==
$b comparion returns a single Bool value (True), and the negation of that
is False.

MOTIVATION

Perl aims to be rather close to natural languages, and in natural
language you often say things like “if the result is $this or $that”
instead of saying “if the result is $this or the result $that”. Most
programming languages only allow (a translation of) the latter, which
feels a bit clumsy. With junctions Perl 6 allows the former as well.

It also allows you to write many comparisons very easily that otherwise
require loops.

As an example, imagine an array of numbers, and you want to know if all
of them are non-negative. In Perl 5 you’d write something like this:

# Perl 5 code:
my @items = get_data();
my $all_non_neg = 1;
for (@items){
if ($_ < 0) {
$all_non_neg = 0;
last;
}
}
if ($all_non_neg) { ... }

Or if you happen to know about List::MoreUtils

use List::MoreUtils qw(all);
my @items = get_data;
if (all { $_ >= 0 } @items) { … }

In Perl 6 that is short and sweet:

my @items = get_data();
if all(@items) >= 0 { … }

SEE ALSO

http://perlcabal.org/syn/S03.html#Junctive_operators

Read more from Perlsphere.

A bunch of threads on the perl5-porters mailing list made me aware of a
rather obscure perl 5 feature.

I was quite familiar with the basic form, which goes like this:

while ( <> ) {
print;
}

This either reads from all files in turn that were given on the command
line, or from STDIN if no file name was provided.

Now <> actually uses open internally, specifically the 2 argument form.
Which means that anything that is valid as the second argument to open
also works in @ARGV:

local @ARGV = (’fortune |’);
priint while <>;

Instead of trying to open a file called fortune |, it actually executes
the command fortune and uses it output for the <> “diamond operator”.

This feature can be used for quite some tricky and shiny stuff, but it’s
also dangerous. If your perl program uses <>, it is vulnerable to the
command line argument rm -rf * | and similar things, also known as
“arbitrary code execution”.

Therefore the perl porters are discussing about disabling this feature,
and making the old, magic behaviour available with a command line switch
or a pragma.

For me the consequence is “don’t use <> with possibly untrusted input”.

Read more from Perlsphere.

15 months ago I wrote a blog post about Building a Huffman Tree with Perl
6 (German). Back then I used pugs to test it.

Now I tried it with Rakudo Perl revision 29736, and to my delight I
discovered that it worked nearly without modification.

(Actually it needed a small modification because I made a mistake in the
testing originally, I compared hashes with string semantics. That works
in pugs even though it is not specified; in rakudo it doesn’t).

I updated my script a bit to do the testing correctly, and used a few
more typical Perl 6 idioms:

use Test;
plan 6;
# number of occurencesmy @fr = (
['a', 45],
['b', 13],
['c', 12],
['d', 16],
['e', 9 ],
['f', 5 ],
);
# That’s what we expectmy %expected = (
a => ‘0′,
b => ‘101′,
c => ‘100′,
d => ‘111′,
e => ‘1101′,
f => ‘1100′);
my @c = @fr;
# build the huffman treewhile @c > 1 {
@c = sort { $^a[1] <=> $^b[1] }, @c;
my $a = shift @c;
my $b = shift @c;
unshift @c, [[$a[0], $b[0]], $a[1] + $b[1]];
}
my %res;
# recursively traverse the tree to build the codesub traverse ($a, Str $code = “”){
if $a ~~ Str {
%res{$a} = $code;
} else {
traverse($a[0], $code ~ ‘0′);
traverse($a[1], $code ~ ‘1′);
}
}

traverse(@c[0][0]);
# now compare with the expected code:#say %res;#say %expected;for %res.keys -> $k {
is %res{$k}, %expected{$k}, “Huffman code for letter $k”;
}

Read more from Perlsphere.

NAME

“Perl 5 to 6″ Lesson 10 - Containers and Values

Synopsis

my ($x, $y);
$x := $y;
$y = 4;
say $x; # 4
if $x =:= $y {
say ‘$x and $y are different names for the same thing’
}

DESCRIPTION

Perl 6 distinguishes between containers, and values that can be stored in
containers.

A normal scalar variable is a container, and can have some properties
like type constraints, access constraints (for example it can be read
only), and finally it can be aliased to other containers.

Putting a value into a container is called assignment, and aliasing two
containers is called binding.

my @a = 1, 2, 3;
my Int $x = 4;
@a[0] := $x; # now @a[0] and $x are the same variable
@a[0] = ‘Foo’; # Error ‘Type check failed’

Types like Int and Str are immutable, ie the objects of that type can’t
be changed; but you can still change the variables (the containers, that
is) which hold these values:

my $a = 1;
$a = 2; # no surprise here

Binding can also be done at compile time with the ::= operator.

You can check if two things are bound together the =:= comparison
operator.

MOTIVATION

Exporting and importing subs, types and variables is done via aliasing.
Instead of some hard-to-grasp typeglob aliasing magic, Perl 6 offers a
simple operator.

SEE ALSO

http://perlcabal.org/syn/S03.html#Item_assignment_precedence

Read more from Perlsphere.

NAME

“Perl 5 to 6″ Lesson 15 - Twigils

SYNOPSIS

class Foo {
has $.bar;
has $!baz;
}

my @stuff = sort { $^b[1] <=> $^a[1]}, [1, 2], [0, 3], [4, 8];
my $block = { say “This is the named ‘foo’ parameter: $:foo” };
$block(:foo);

say “This is file $?FILE on line $?LINE”

say “A CGI script” if %*ENV.exists(’DOCUMENT_ROOT’);

DESCRIPTION

Some variables have a second sigil, called twigil. It basically means
that the variable isn’t “normal”, but differs in some way, for example it
could be differently scoped.

You’ve already seen that public and private object attributes have the .
and ! twigil respectively; they are not normal variables, they are tied
to self.

The ^ twigil removes a special case from perl 5. To be able to write

# beware: perl 5 code
sort { $a <=> $b } @array

the variables $a and $b are special cased by the strict pragma. In Perl
6, there’s a concept named self-declared positional parameter, and these
parameters have the ^ twigil. It means that they are positional
parameters of the current block, without being listed in a signature. The
variables are filled in lexicographic (alphabetic) order:

my $block = { say “$^c $a $^b” };
$block(1, 2, 3); # 3 1 2

So now you can write

@list = sort { $^b <=> $^a }, @list;
# or:
@list = sort { $^foo <=> $^bar }, @list;

Without any special cases.

And to keep the symetry between positional and named arguments, the :
twigil does the same for named parameters, so these lines are roughly
equivalent:

my $block = { say $:stuff }
my $sub = sub (:$stuff) { say $stuff }

The ? twigil stands for variables and constants that are known at compile
time, like $?LINE for the current line number (formerly __LINE__), and
$?DATA is the file handle to the DATA section.

Global variables can be accessed with the * twigil, so %GLOBAL::ENV can
be abbreviated to %*ENV, the command line arguments are stored in @*ARGS,
the current process number is in $*PID and so on.

A pseudo twigil is <, which is used in a construct like $, where
it is a shorthand for $/, which accesses the Match object after
a regex match.

MOTIVATION

When you read Perl 5’s perlvar document, you can see that it has far too
many variables, most of them global, that affect your program in various
ways.

The twigils try to bring some order in these special variables, and at
the other hand they remove the need for special cases. In the case of
object attributes they shorten self.var to $.var (or @.var or whatever).

So all in all the increased “punctuation noise” actually makes the
programs much more consistent and readable.

Read more from Perlsphere.

Sometimes people ask me what I’m doing right now, and I tell them “I’m
writing my diploma thesis on mesoscopic spin transport”, and they know
just as much as before. So here I want to explain what that means.

Mesoscopic systems
——————

A mesoscopic system is one that is larger than a few nanometers, but
still small enough that you have to care about quantum effects.

That’s not a very precise definition, so I’ll try again: Consider a
metallic wire. For macroscopic systems (ie the ones that we are used to
in day-to-day live) you might know that the electrical resistance of such
a wire increases linearly as you increase its length, and decreases
linearly if you increase its cross section.

This is very intuitive, because electrical resistance describes how hard
it is for an electron to travel through our wire. If the wire is longer,
it sees more obstacles, so the resistance is higher. If the wire has a
larger cross section, it’s easier for the electron to find a way that’s
not blocked, so the resistance is smaller. That’s called Ohm’s law.

These relations aren’t true anymore for rather small systems. If you have
a very thin wire, say 20 nanometers, and increase its diameter by another
nanometer, the resistance might not change at all. Then you increase its
diameter by another nanometer, the resistance suddenly jumps down by a
few percent.

All these systems that are too small for Ohm’s law to apply are called
mesoscopic. All mesoscopic effects have to be explained with quantum
physics, at least at some point.

Electron Spin
————-

Electrons have something called Spin. Everybody knows that it has a
charge, and it acts as if it rotated around its own axis very fast. So it
looks like a current which runs in a circle, and that creates a small
magnetic field.

If you try to measure the magnetic field of one electron, you will only
ever get two possible values, which we call spin up and spin down.

Topics of Interest
——————

It’s clear that my diploma thesis will either have to do with spin
optics, or with the Spin Hall Effect, so I’ll describe the two here.

Spin Optics

In a semiconductor, one can split up a beam of electrons into two beams
of spin-up and spin-down electrons, just like in optics with polarized
light. That splitting can be influenced by an external voltage, like a
classical transistor.

So one of my possible topics could very roughly be described as
“calculate some properties of a spin beam transistor”.

Spin Hall Effect

In the classic Hall effect a current is driven through a conductor, and a
magnetic field generates a voltage perpendicular to both the magnetic
field and the current, and a charge is accumulated.

Now through some complicated mechanism a similar setup can lead to a spin
charge, ie a region in the conductor where there are more spin-up
electrons than spin-down electrons.

That’s a pretty new effect, the first papers about it are from 1997 or
1998, and there’s a lot of things that can be calculated.

Read more from Perlsphere.