masterweb: Forum Komunitas: Hosting murah & domain gratis Indonesia

saat ini sumber dari Planet Perl Six, Rakudo.org.

Waktu asli posting blog: Wed, 17 Dec 2008 05:24:08 +0000

On behalf of the Parrot team, I'm proud to announce Parrot 0.8.2
"Feliz Loro." Parrot (http://parrotcode.org/) is a virtual machine aimed
at running all dynamic languages.

Parrot 0.8.2 is available via CPAN (soon), or follow the download
instructions at http://parrotcode.org/source.html. For those who
would like to develop on
Parrot, or help develop Parrot itself, we recommend using Subversion on
the source code repository to get the latest and best Parrot code.

Parrot 0.8.2 News:
- Implementation
+ fixed lexical semantics
+ added the 'capture_lex' opcode
+ added automatic resume for nonfatal exceptions
+ added multidispatch cache
+ applied miscellaneous performance improvements, including startup time
+ fixed several bugs and leaks found by Coverity Scan
+ removed race conditions from parallel testing
- Compilers
+ IMCC
- removed undocumented .param int <stringc> => <ident> syntax
- .line directive now only takes an integer argument
- new .file directive to specify the file name being compiled
+ PCT
- properly handles lexical generation and closure semantics
- uses :subid instead of name lookups to reference PAST::Block nodes
- added PAST::Control node type (exception handlers)
+ PGE
- add support for <? ... > and <! ... > assertions
- Match objects use Capture PMC instead of Capture_PIR
+ PIRC
- add macro handling to PASM mode
- disable vanilla register allocation in PASM mode, but do allow
optimization
- add tests and bug fixes
- first bits of bytecode generation. No sub calling/returning yet.
- Languages
+ Rakudo
- fixed lexical handling and recursion
- refactored subtypes implementation
- support for quotes with multi-character delimiters
- implemented list slices (Positional role)
- list assignment
- reduction meta operators
- hyper meta operators
- cross meta operators
- more builtin functions
- added Nil type
- basic support for protos
- iterator on filehandle objects
- basic support for exception handlers
- warn
+ Lua
- added complex & mathx libraries
- merged LuaClosure & LuaFunction PMC
+ Pipp
- added support for a return value from user defined functions
- added incomplete implemention of 'require_once'
+ Ecmascript
- parser fixes, parses spidermonkey's top level test/shell.js
- Deprecations
+ PARROT_API is now PARROT_EXPORT
+ PIR
- :lexid is now :subid
- .arg is now .set_arg
- .result is now .get_result
- .yield (in .begin/end_yield) is now .set_yield
- .return (in .begin/end_return) is now .set_return
- .namespace x / .endnamespace x syntax is removed
+ Capture_PIR (runtime/parrot/library/Parrot/Capture_PIR.pir)


Many thanks to all our contributors for making this possible, and our sponsors
for supporting this project. Our next scheduled release is 20 January 2009.

Enjoy!

--Andrew Whitworth


http://www.nntp.perl.org/group/perl.per ... sg594.html

Waktu asli posting blog: Fri, 19 Dec 2008 01:03:50 +0000

Verbosity of syntax and semantics is a persistent criticism of Java. Why,
look at the concepts you have to understand (or ignore) to write "Hello,
world!" in Java:<blockquote><div> <tt>public class hello

&nbsp; &nbsp; public static void main(String args[])
&nbsp; &nbsp;
&nbsp; &nbsp; &nbsp; &nbsp; System.out.println("Hello, world!");
&nbsp; &nbsp;
</tt></div> </blockquote>By rough count, you have to understand (or ignore) the connection between a
class and its file, how to invoke the Java compiler, visibility of methods,
methods, the distinction between class and instance methods, array syntax,
typed arrays, and particular details of Java's internal class library before
you can give a cheery greeting. Compare that to Perl's simplicity:<blockquote><div> <tt>say "Hello, world!";</tt></div> </blockquote>Even that trailing semicolon is optional. Those poor Java programmers don't
know how great life can be -- except that we're deluding ourselves to think
that Java programmers spend their days writing "Hello, world!" over and over.
Perl programmers don't. Why would Java programmers?What <em>do</em> Java programmers do all day? They write classes, for one. Maybe we should compare like to like. In Java:<blockquote><div> <tt>public class Foo extends Bar

&nbsp; &nbsp; ...
</tt></div> </blockquote>Hm, that's not too bad. You have to understand what a class is and Java's
syntax for inheritance, as well as visibility modifiers, but syntactically
speaking that's not overtly complex and it reveals the intent of the code
fairly well. Now let's consider Perl 5:<blockquote><div> <tt>
&nbsp; &nbsp; package Foo;
&nbsp; &nbsp; use vars '@ISA';
&nbsp; &nbsp; push @ISA, 'Bar';
&nbsp; &nbsp; ...
</tt></div> </blockquote>Hm. That could be clearer. You have to understand packages (and that
classes in Perl are packages, but not vice versa, except sometimes), package
scoping rules, global variables, the <code>vars</code> pragma, a magic package
global, and the order of inheritance in the face of open classes. How
about:<blockquote><div> <tt>
&nbsp; &nbsp; package Foo;
&nbsp; &nbsp; push @Foo::ISA, 'Bar';
&nbsp; &nbsp; ...
</tt></div> </blockquote>Hm. That obviates the need to understand the <code>vars</code> pragma, but
it's still syntactically noisy. Maybe:<blockquote><div> <tt>
&nbsp; &nbsp; package Foo;
&nbsp; &nbsp; use base 'Bar';
&nbsp; &nbsp; ...
</tt></div> </blockquote>That's slightly better, but it introduces the need to understand yet another
pragma and its implications if you don't have a file in <code>@INC</code> (yet
another magic global) named <em>Bar.pm</em>.Of course, the default Perl 5 syntax can't ever change because <a href="http://www.catb.org/esr/writings/taoup/html/ch15s04.html#id2986827">we
don't want to screw up our embedded base</a>. Oh dear. This may be the sound of a wall against which I <em>am</em> beating my head.(Before you tell me all I have to do is to use Moose/Mouse/Squirrel/Wombat/Ferret/Nematode/Whatever, allow me to indulge in one more list: the existence of CPAN, how to configure <a href="http://search.cpan.org/perldoc?CPAN::FirstTime">CPAN::FirstTime</a>, how to set up a development environment on your box, how to use a CPAN module, reading the documentation of a CPAN module, installing modules and distributions locally, .... If you're really good, I'll tell you the story of how a feature deprecated fourteen years, two months, and one day ago made the semi-doomed class patch more difficult to write.)

http://use.perl.org/~chromatic/journal/38118?from=rss

Waktu asli posting blog: Sat, 20 Dec 2008 18:34:25 +0000

Here's a little pattern I've discovered while hacking away at <a href="http://use.perl.org/~masak/journal/37885">a board game implementation</a> in Perl 6.I had a subroutine called <code>input_valid_move</code>, whose job it was to read a move from <code>$*IN</code>, and return the move <em>if it was valid</em> according to the rules of the game. Easy enough.<blockquote><div> <tt>repeat
&nbsp; &nbsp; print "\n", $player, ': ';
until my $move = input_valid_move(...);</tt></div> </blockquote>Now, there are several ways a move can be illegal, and I found myself printing and returning a lot from the sub:<blockquote><div> <tt>unless $row_diff == 2 &amp;&amp; $column_diff == 0
&nbsp; &nbsp; $row_diff == 0 &amp;&amp; $column_diff == 2

&nbsp; &nbsp; say 'Must be exactly two cells apart';
&nbsp; &nbsp; return;


unless @heights[$row_1][$column_1]
&nbsp; &nbsp; == @heights[$row_2][$column_2]

&nbsp; &nbsp; say 'Must be supported at both ends';
&nbsp; &nbsp; return;
</tt></div> </blockquote>Notice the repetition? There were many (7) such tests for move correctness, and all of them made a boolean test, printed something and then returned from the sub:<blockquote><div> <tt>if ( ... ) # or 'unless'; depends
&nbsp; &nbsp; say '...';
&nbsp; &nbsp; return;
</tt></div> </blockquote>Repetition is a sign that there there is an abstraction just waiting to be created. I wanted to make an abstraction <code>flunk_move</code> that closed over the <code>say '...'; return</code> part of the above pattern, parametrizing the message printed. That way, I could just write this instead:<blockquote><div> <tt>&nbsp; &nbsp; flunk_move 'Must be exactly two cells apart'
&nbsp; &nbsp; &nbsp; &nbsp; unless $row_diff == 2 &amp;&amp; $column_diff == 0
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; $row_diff == 0 &amp;&amp; $column_diff == 2;

&nbsp; &nbsp; flunk_move 'Must be supported at both ends'
&nbsp; &nbsp; &nbsp; &nbsp; unless @heights[$row_1][$column_1]
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; == @heights[$row_2][$column_2];</tt></div> </blockquote>Each move correctness test now became a single statement, instead of an <code>if/unless</code> statement containing two statements. As an added bonus, the most important part of the statement (the disqualification of the move) is now leftmost in the statement, something Damian Conway talks about in his book "Perl Best Practices".But a new subroutine would not do as a repetition-reducing abstraction. The <code>return</code> statement in such a new sub, having moved from its original environment would be a no-op. I wanted to eat the cake and have it, too.S06 states that the <code>return</code> function <a href="http://perlcabal.org/syn/S06.html#The_return_function">throws a control exception that is caught by the current lexically enclosing <code>Routine</code>,</a> and this fact turned out to be just what I needed. To decipher the Perl 6 designese, the <code>return</code> in a <code>sub</code> returns from that <code>sub</code>, but the <code>return</code> in a bare block returns from the <code>sub</code> (or whatever) it was called from.<blockquote><div> <tt>&nbsp; # not what I want -- the return does nothing
&nbsp; sub flunk_move($reason) say $reason; return ;

&nbsp; # what I want, using pointy block
&nbsp; -&gt; $reason say $reason; return ;

&nbsp; # what I want, using placeholder variables
&nbsp; say $^reason; return ;</tt></div> </blockquote>Think of it in biological terms: a <code>sub</code> is like a <a href="http://en.wikipedia.org/wiki/Eukaryote">"eukaryote</a>: a little more complex, handles advanced things like <code>return</code> when necessary. A bare block doesn't have all that advanced piping, and has to delegate its <code>return</code> calls to its surrounding host cell. In other words, a bare block is a bit like an <a href="http://en.wikipedia.org/wiki/Endosymbiont">endosymbiont</a> <a href="http://en.wikipedia.org/wiki/Prokaryote">prokaryote</a>, a simple organism that in the course of evolutionary history ended up in a symbiotic relationship inside a larger eukaryotic cell.Biological analogies aside, what it meant to me was that I could do this in my <code>sub input_valid_move</code>:<blockquote><div> <tt>my &amp;flunk_move = say $^reason; return ;</tt></div> </blockquote>(There's the endosymbiont, right there! It can't return from itself, because it's just a humble code block, so it returns from its surrounding subroutine instead, which happens to be <code>input_valid_move</code>.)
After that, I could use <code>&amp;flunk_move</code> just as I wanted, as if it were a <code>return</code> statement with side effects. (Same code as above.)<blockquote><div> <tt>&nbsp; &nbsp; flunk_move 'Must be exactly two cells apart'
&nbsp; &nbsp; &nbsp; &nbsp; unless $row_diff == 2 &amp;&amp; $column_diff == 0
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; $row_diff == 0 &amp;&amp; $column_diff == 2;

&nbsp; &nbsp; flunk_move 'Must be supported at both ends'
&nbsp; &nbsp; &nbsp; &nbsp; unless @heights[$row_1][$column_1]
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; == @heights[$row_2][$column_2];</tt></div> </blockquote>Some Smalltalk people extol the power in being able to define things like <a href="http://pozorvlak.livejournal.com/94558.html">the if statement</a> from within the language, without any magical trickery to make it work. The pattern I discovered above uses the same kind of strengths, the ability to define my own slightly fancy return statement, and have it look like a built-in in subsequent code.That kind of power is what makes Perl 6 a joy to use.

http://use.perl.org/~masak/journal/38123?from=rss

Waktu asli posting blog: Mon, 22 Dec 2008 08:26:22 +0000

For some unknown reason I woke up at 3am on Saturday morning and couldn't
get back to sleep. So, I decided I might as well use the time for some
productive Rakudo hacking.
I decided to start by reviewing the spectest
suite a bit. In the past couple of days I've noticed
that although we've been increasing the number of spectests that Rakudo
passes, we didn't seem to be shrinking the number of tests that are
in the spectest suite but don't attempt to run (the grey area
in the graphs). So, I decided to review the test files that we
<em>don't</em> run, instead of the ones we do. I also reviewed the RT
queue for patches to apply.
By 23:59 on Sunday, we had 526 more passing tests than we started
with on Saturday. In fact, in the past two weeks Rakudo has increased
its count of passing spectests by over 1,000. We're now at 5,790
total passing tests.
Here's some of what was accomplished this weekend:
<ul> <li>recognize the difference between array and hash subscripting.
</li><li>align with a change to S02 that now uses \c for decimal character encoding
</li><li>added the .kv method to Pair, to enable the pair.t spectests
</li><li>recognize more unicode codepoints (though still not all) as alphabetic
</li><li>enable the various unicode bracketing characters for quotes
</li><li>added the unicode versions of the infix hyperops we added last week
</li><li>added the <code>p5=&gt;</code> "fat comma" operator
</li><li>cleaned up the readline method on IO
</li><li>recognize radix conversions in strings
</li><li>add +Inf, -Inf, and NaN processing
</li><li>add some workarounds so that Complex numbers work again (they broke with mmd)
</li><li>implement the use of the "whatever star" in list and array slices
</li></ul>Getting the "whatever star" to work was a nice surprise -- thunking
the arguments to postcircumfix:&lt;[ ]&gt; turned out to be quite a bit
easier than I had expected. Rakudo can now do things like
<code> @a[*-10 .. *-1] </code> to get the last ten elements of an array.
Over the weekend Cory Spencer submitted several incredibly useful
patches to fix array initialization in my() lists and properly refactor
many of the list builtins. He has two more patches in the queue that I
plan to review and likely apply tomorrow morning.
Overall, I'm very satisfied with the progress Rakudo contributors
have made over the past couple of weeks. In addition to getting
new features to work, there's also been a lot of internal
refactoring and cleanup that will make things more efficient and
help with the next phases of development. So, although I'm not
sure that we'll be able to repeat the past couple of weeks, things
still look very good for ongoing improvements to Rakudo.
Don't forget: we have a <a href="http://twitter.com/rakudoperl">Rakudo Perl Twitter feed</a> if you want to be notified of all of the new updates to Rakudo Perl.
Pm


http://use.perl.org/~pmichaud/journal/38130?from=rss

Waktu asli posting blog: Tue, 23 Dec 2008 06:35:58 +0000

Are you interested in playing with Perl 6 and Rakudo Perl but
can't figure out what to do? Here's an idea that came up
during Jon Allen's talk "<a href="http://www.yapceurope2008.org/ye2008/talk/1365">The Camel and the Snake</a>" at YAPC::EU in Copenhagen.
For the past few years Microsoft has sponsored an annual <a href="http://www.microsoft.com/technet/scriptcenter/funzone/games/default.mspx">Scripting Games competition</a>, where they publish problems of varying difficulty levels to be solved using Perl 5, VBScript, Python, or other languages. I think it might be very interesting and useful to see people develop and publish Perl 6 solutions to those problems.
So, here's my idea: If you're interested in learning more about Perl 6, select one or more problems from the Scripting Games website, develop solution(s) for them in Perl 6, and then publish your solutions somewhere along with a description of what you like, don't like, learned, didn't learn, etc. about Perl 6 and Rakudo Perl.
One of the things we've observed from our experience with the <a href="http://github.com/viklund/november/tree/master">November Wiki</a> and other similar projects is that having "running code examples" and "real problems" is one of the best drivers for compiler and language development. I'm thinking that having people craft solutions to the scripting problems might do more of the same for Rakudo, while also sparking discussion and reflection on Perl 6 itself.
So, where to start? Start by <a href="http://svn.perl.org/parrot/trunk/languages/perl6/README">obtaining and building a copy of Rakudo Perl</a>, write and test your solutions to one or more problems, and post the results and your experiences somewhere for others to see. You can post to use.perl.org, your private blog, the perl6-users mailing list, or anywhere else you find convenient. The point isn't to develop a centralized repository of solutions (although we can do that), but rather to use the problems as a way to spread discussion, feedback, and experience with Perl 6.
I should also make it plain that people are very likely to run into some of Rakudo Perl's "rough edges" -- places where we don't yet implement key features or where they don't work exactly as they're supposed to. But to the designers and implementors that's part of the point -- we need to know where those rough edges are. Overall, I'm hoping that with <a href="http://twitter.com/rakudoperl">the recent improvements to Rakudo Perl</a> there won't be so many rough edges as to make the effort more disappointing than enjoyable. And there are lots of people eager to answer questions and help out on the perl6-users mailing list, IRC #perl6 (irc.freenode.net), and other common Perl forums. It's all about learning and improving what we have with Perl 6.
I look forward to seeing your questions and answers.
Happy holidays,
Pm


http://use.perl.org/~pmichaud/journal/38134?from=rss

Waktu asli posting blog: Tue, 23 Dec 2008 07:06:10 +0000

Summarizing <a href="http://use.perl.org/~pmichaud/journal/38134">pmichaud</a>:<ul>
<li>There's this <a href="http://www.microsoft.com/technet/scriptcenter/funzone/games/default.mspx">competition</a> where you can solve problems using a variety of scripting languages.</li><li>Why not solve them in Perl 6?</li><li>Start by <a href="http://svn.perl.org/parrot/trunk/languages/perl6/README">getting a copy</a> of Rakudo Perl 6. (You've always wanted this anyway &#8212; now's the time.)</li><li>Rakudo has <a href="http://twitter.com/rakudoperl">improved</a> amazingly lately!</li><li>Questions? Ask at #perl6 or perl6-users.</li></ul>Now go write those crazy script solutions!

http://use.perl.org/~masak/journal/38135?from=rss

Waktu asli posting blog: Sat, 27 Dec 2008 10:41:11 +0000

<blockquote><div> <em>Freshmeat indicates that, relative to Python and other languages, Perl isn't seeing as much code released.</em></div> </blockquote>-- <a href="http://www.welton.it/davidw/">David N. Welton</a>, <a href="http://journal.dedasys.com/2008/12/07/python-surpasses-perl">Python "Surpasses" Perl?</a> Given that CPAN and perl.org provides announcement services, project history, bug tracking, documentation hosting, smoke testing, and download mirroring and all you have to do is upload a tarball to PAUSE, I wonder instead why a Perl developer would make an announcement on Freshmeat. I could likewise prove that there are no good writers on the Internet by surveying popular fan fiction sites, seeing as how that's exactly where they don't hang out.I enjoy a good rant as much as anyone, but if you're going to ruin it with research, at least make a puzzle out of how you propped up your conclusions.

http://use.perl.org/~chromatic/journal/38168?from=rss

Waktu asli posting blog: Sat, 27 Dec 2008 19:55:23 +0000

As I've <a href="http://use.perl.org/~masak/journal/37820">said before</a>, S29 needs a lot of attention. It's a good resource for the things it covers, but it's also sadly lacking in many places.Last night I found the time to skim through the synopses in one sitting, looking for functions and methods covered in other synopses but not in S29. My findings divide into "questions" and "omissions". Questions <ul>
<li>I see the sub version of <code>defined</code> declared in S29. Is the method version (used in S02:519) also in S29? I can't see it, but I might be missing something about how method signatures work.</li><li>Should the methods <code>.new</code> and <code>.clone</code> be covered by S29? They're slightly different beasts than <code>abs</code> or <code>push</code>, but they're still in a sense "builtin functions in Perl 6".</li><li>Same question for <code>BUILD</code> and <code>CREATE</code>.</li><li>What about metaclass methods, like <code>.HOW.methods</code>? Should they be covered in S29?</li><li>Should there be a way to extract information about a <code>Rat</code>'s numerator/denominator? What methods does a <code>Rat</code> have?</li><li>if <code>:exists</code> and <code>:delete</code> get honourable mentions as methods, maybe we should have <code>:p</code>, <code>:kv</code>, <code>:k</code> and <code>:v</code> too</li><li>what's the name of the class that method descriptor objects belong to?</li><li>ditto attribute descriptor objects.</li></ul> Omissions Things that no longer are omissions are marked in parentheses with a date and the wonderful person who added it.<ul>
<li> <code>isa</code>, <code>does</code>, <code>can</code> (moritz++ 2009-01-05)</li><li> <code>.perl</code> (moritz++ 2009-01-05)</li><li> <code>.succ</code>, <code>.pred</code> </li><li> <code>any</code>, <code>all</code>, <code>one</code>, <code>none</code>. these are also methods, on <code>Hash</code> for example.</li><li> <code>warn</code> </li><li>The <code>slice</code> contextualizer. (S03:1945)</li><li>The <code>hash</code> contextualizer.</li><li>The filetest operators. These are covered in S16, so maybe just mention them.</li><li> <code>true()</code>, <code>not()</code>, also methods</li><li> <code>Range</code> objects have <code>.from</code>, <code>.to</code>, <code>.min</code>, <code>.max</code> and <code>.minmax</code> methods</li><li>.<code>contains</code> on <code>Hash</code> and <code>Array</code> </li><li> <code>Code</code> has a <code>.sig</code> </li><li> <code>.ACCEPTS</code> and <code>.REJECTS</code> on most everything -- provided by the Pattern role. Likely a mistake to put one under each section, though. Perhaps put one under Object and put a reference to S03.</li><li>The <code>cat</code> contextualizer.</li><li> <code>Object</code> has <code>.print</code> and <code>.say</code>.</li><li> <code>Block</code> types have <code>.next</code>, <code>.last</code>, <code>.redo</code> and <code>.leave</code> on them. These are also functions, and need to be specced as such.</li><li> <code>Block</code> also has a <code>.labels</code> method.</li><li> <code>fail</code> and <code>.handled</code> (the former is in S29, but has no signature/summary).</li><li> <code>.match</code>, <code>.subst</code> and <code>.trans</code> from S05.</li><li> <code>Match</code> objects: <code>.from</code>, <code>.to</code>, <code>.chars</code>, <code>.orig</code> and <code>.text</code>.</li><li>Match state objects: <code>.pos</code>.</li><li> <code>context()</code>.</li><li> <code>.wrap</code>, <code>.unwrap</code> and <code>.assuming</code>.</li><li> <code>callsame</code>, <code>callwith</code>, <code>nextsame</code>, <code>nextwith</code>, <code>lastcall</code>.</li><li> <code>VAR()</code>, though a macro, could possibly get honourable mention.</li><li>Method descriptor objects: <code>.name</code>, <code>.signature</code>, <code>.as</code>, <code>.multi</code>, <code>.do</code>.</li><li>Attribute descriptor objects: .<code>name</code>, .<code>type</code>, .<code>scope</code>, .<code>rw</code>, .<code>private</code>, .<code>accessor</code>, .<code>build</code>, .<code>readonly</code>.</li></ul>I'll see if I can add these during the coming month. A helping tuit or two would be greatly appreciated.

http://use.perl.org/~masak/journal/38170?from=rss

Waktu asli posting blog: Tue, 30 Dec 2008 10:22:27 +0000

Instead of futilely trying to sleep last night, I sat down and tried out an idea in Rakudo. Just a quick throwaway script, comprising a couple of arrays and a few for loops.Now, I <em>know</em> that as soon as you expand your repertoire into something new, you run into bugs in Rakudo. But this time I ran into 7 bugs in the course of an hour. That surprised even me.Actually, of those 7 "bugs", one was a TODO feature request, and one was a general question about syntax... but still, 5 bugs in an hour is a lot. This tells me three things:<ol>
<li> A lot has happened in Rakudo lately. And the last thing I want is for this to come through as a critique of the Rakudo development process, of which I'm constantly impressed. But the fact that I ran into those bugs tells me that I'm one of the very first people to actually try those features.</li><li> Tests are great, but they're no substitute for real programs. Rakudo has a lot of tests, and all of them pass most of the time. But actual programs tend to shake out slightly different kinds of bugs, it turns out. Even if the "actual program" happens to be a toy problem thrown together at one o'clock in the night, as in my case.</li><li> We need more people who love to throw together scripts in Perl 6. And who are eager to try them out in Rakudo, and who care enough when things break to report bugs to <code>rakudobug@perl.org</code>. I know you're out there.</li></ol>Rakudo has evolved at an amazing rate the last few months. You're likely to find Perl 6 features you've heard about already implemented in Rakudo, and most of the time, they work as specced! Did I mention that it feels great to be writing code in Perl 6, and then typing <code>perl6 code-in-perl6</code> on the command line, and seeing it run?We need more people who think it's great to write and run Perl 6 programs. With more eyeballs and hands, more bugs will be unearthed sooner, and Rakudo will be a stable, production-usable product sooner.If you want to get involved, check out eric256's <a href="http://github.com/eric256/perl6-examples/">Perl 6 examples repository</a>, and think of something you'd like to add to that. Or take pmichaud's <a href="http://use.perl.org/~pmichaud/journal/38134">challenge</a>. Or just come visit at #perl6 @ irc.freenode.net and try some quick Perl 6 one-liners on the eval bot hanging around, discussing the finer points of syntax with the regulars. Or just scratch a scripting itch of your own.Whatever you do, there's a small chance you might turn up what appears to be a bug. If you do, and if you submit that bug to <code>rakudobug@perl.org</code>, you're a hero, because you've made Rakudo Perl 6 a little bit more stable.I'm sure there's lots of that type of heroes out there, just waiting for some cool new piece of software to try. Try Rakudo.

http://use.perl.org/~masak/journal/38184?from=rss