2017.07 More Than One Zero

Ahoy-hoy! This week we’ve got a few nice fixes lined up for y’all:

  • the abs_n op in MoarVM now correctly turns -0e0 into 0e0 (Zoffix Znet)
  • closing an async socket now can’t cause the VM to crash. (jnthn)
  • fix a numeric overflow that could prevent a full collection from occurring (dogbert17)
  • on windows, MoarVM now correctly accepts unicode command line arguments and environment variables (thanks, nanis!)
  • the string repeat op will no longer cause the VM to panic if GC kicks in at just the right moment (samcv++, dogbert17++, and jnthn++)
  • smart matching char ranges against char ranges now works (MasterDuke17, Zoffix++)
  • a whole bunch of data races were fixed in precompilation-related code in rakudo (jnthn++)
  • smart matching a Str against a Numeric now no longer throws an exception if the Str can’t be coerced to a Numeric (Zoffix++)
  • the iterator used for implementing the rotor method used to violate the iterator protocol by pulling more values out after IterationEnd had been signalled, leading to strange exception messages (Zoffix++)
  • rational numbers used to normalize inconsistently between printing out and getting the numerator and denominator pulled out of ’em (Zoffix++)
  • a whole lot of useless coercions from int to num happened during even compiling the empty program in perl6. that number has been drastically reduced by MasterDuke17++
  • lizmat++ made Int.WHICH a bunch faster, which should make object hashes with Int keys in them faster, too.
  • I drafted a little op for MoarVM that’ll let you grab some statistics about the inner state of MoarVM. I’m intending to give info that might be interesting to have in a monitoring tool, for example if you’re running a server or web app. I’d love to hear some feedback on what pieces of data you might be interested in!

Ecosystem, Docs, and Bloggage

That’s it for now! Tune in again next week for more 🙂

Advertisements

2017.06 Fosdem After Math

This Weekend the FOSDEM conference happened in Brussels, Belgium. There was, like every time, a Perl table with lots of books, stickers, plush camels and camelias and other lovely stuff run by Liz and Wendy. There was also a Perl Programming Language Devroom where multiple Perl 6 related Talks took place.

You can get the video recordings from the fosdem server, but also have a look at the video status overview to see what videos still need to be processed.

Yours truly (timo this time) didn’t attend fosdem, but I heard good things about the conference from those Perl 6ers who did. And of course I watched a bit of the live stream. I enjoyed Dana Jacobsen talk about simple number theory in Perl 6. At the time of writing, the recording hasn’t been put up yet, though. (This is also where I took the inspiration for the title from).

Rakudo Progress

  • Jnthn fixed some trouble with handling connection errors from sockets, where an exception being thrown caused MoarVM to longjmp past a bunch of libuv frames that were supposed to clean up some stuff. Oops!
  • Zoffix Znet fixed the implementation of the native integer division op in MoarVM’s interpreter portion. Yours truly happened to implement it incorrectly very early on in MoarVM’s life and nobody ever checked that it handles numbers beyond 32bit correctly. Ouch!
  • Samantha McVey made MoarVM’s radix ops (i.e. parse a string that contains a number) a bunch faster by having it check for the unicode property “numeric type” rather than checking the general category.
  • Samantha McVey also made the East Asian Width property of unicode codepoints available.
  • Samantha McVey also did a bunch of work to make comparing/sorting unicode strings more featureful, by implementing Collations (four different levels that can individually be turned on and off) and a corresponding “coll” infix operator. There’s also a unicmp operator that isn’t configurable, but currently it’s hidden behind “use experimental :unicmp”.
  • MasterDuke17 made sure that not only nqp::radix_I would be accepted by the JIT, but that nqp::radix would also be considered for jitting.
  • There was some trouble with a very specific situation in Grammars would cause a bogus NFA to be generated that caused an out-of-bounds memory read when executed. Not only was the out-of-bounds read fixed (by giving an error much earlier) but the part of code that was responsible for creating the bogus NFA was also fixed to behave The Right Way™. Thanks, Jnthn!
  • pmurias did the usual assortment of work on nqp’s javascript backend, containing a bunch of test cases for nqp:: ops and QAST semantics, and a bunch of features required by rakudo on javascript.
  • lizmat landed a whole lot of array/list and iterator-related speedups:
    • @b = @a.map: { } about 10% faster
    • @b = do for @a { } about 20% faster
    • for @a { … } about 1% faster
    • my @b = @a.map: -> \a,\b { } about 15% faster
    • for @a -> \a, \b { } about 2% faster
    • gave List and Array their own tail method, where .tail is 8x as fast as [*-1], and .tail(N) is about 16x as fast as [*-N .. *-1]
    • Arrays that are already fully reified (i.e. there is no iterator to generate more values at the end any more) now have their own class of iterators that goes through the array a bunch faster, and also improves things like getting the number of elements.
  • Samantha McVey also did a few more nice things for performance, by giving the <ws> token a few improvements leading to about a 5% parse time improvement for our core setting, and also by making uniprop, unimatch, and unival up to 2x faster.
  • Zoffix Znet made Complex numbers smartmatch to Ranges, which only works if the imaginary part is close enough to 0 to not matter (i.e. artifacts of floating point arithmetic and such).
  • MasterDuke17 fixed a performance problem when you have “some constant string” x $a-very-big-constant-number in your code. It previously constant-folded the result of that operation, leading to a very big string being written out as a latin1 encoded buffer into the compilation result, just to immediately be read back out again when compile time transitioned into runtime.
  • MasterDuke17 also replaced a few occurrences of [*-1] in Rakudo’s source with the much faster .tail() method.
  • Thanks to Zoffix Znet, the REPL will now no longer complain at you and crash when some command you run evaluates to a Mu.
  • AlexDaniel improved the error you’d get when you write “return” instead of “returns” in a function signature.
  • Jonathan Stowe fixed a problem where multiple installed binaries in a CompUnitRepo could give you an older version rather than the latest one.
  • Larry Wall removed the dynamic variable $*ACTIONS that was used to hold the action class that’s being used to parse with a given grammar. It is now held as an attribute on the Cursor instead. This reduces the pressure on the already strained Dynamic Variable Cache a little bit.

Ecosystem Changes

Not very much happened to Perl 6′ module ecosystem last week:

  •  The Net::XMPP module was taken over by kalkin, who is engaged in the XMPP community.
  • nobodyinperson started working on a Fortran::Grammar.

Hacker News

Just about 10 hours ago, a topic entitled “Ask HN: Do you use it, how do you like it, what do you do with it?”, which already got 156 points and 129 comments on Hacker News. It’s well worth a read!

Signing Off

That’s my report for the last week. Liz is currently taking a vacation, so I’ve taken over for this week, and will also write the report next week. See you then!

2015.53: It is out!

Yes, you’ve read the title correctly! We now have a release of the Perl 6 language (the specification) that we commit to keep fixed for a long-ish time. Also, there’s a version of Rakudo that implements a very big chunk of that specification: 2015.12 (you can find the download on http://perl6.org/ now). Please note that we don’t have a Rakudo Star release yet, so you’ll be building from source for now. We are hoping to get a Rakudo Star release out in the coming days (perhaps with a little bug-fix release of Rakudo up front) and a bit later yet publish .msi installers for our Windows users.

The release notes are quite something. This time it contains an overview of what Perl 6 does in general, but also a list of changes since the last release. You can read the release announcement for Rakudo on the advent blog. The day before that release, TimToady wrote a nice and sort of poetic text on the same blog.

Even though the time leading up to the release has been quite exhausting, there’s been many changes before and after the release itself. Here’s a list of things I thought were notable in the last 7 days:

  • The DateTime, Date, and Dateish classes/role have seen a bunch of speedups to their methods including the constructor. (lizmat)
  • loop (…) loops can now return values! (TimToady)
  • METAOP_ASSIGN (which powers +=, -=, ~=, max=, …) now uses .DEFINITE instead of .defined, which gives us not only a speed improvement, but also makes Failure objects correctly explode. (timotimo & jnthn)
  • Precompiled files will now have the same base filename that the installed source files have.
  • Promise.anyof and Promise.allof will now not throw exceptions when one of the passed promises breaks. Instead, it’s now a combinator based solely on completion. (jnthn)
  • The “as Foo” coercion syntax has been thrown out, as it has been replaced by “Foo()” coercion type syntax some time ago. (jnthn)
  • “pack” and “unpack” are now marked experimental and thus you have to “use experimental :pack” if you want to use them as currently implemented. Here’s Juerd’s draft of a new more perl6ish API. (Juerd)
  • Multi-Dimension candidates for BIND-POS will no longer cause an infinite recursion when the object doesn’t actually implement binding (found by Zefram, fixed by timotimo)
  • When building and installing rakudo with an unprivileged user that doesn’t have access to the runtime paths nqp was installed to, RAKUDO_PREFIX in the environment shall help you. (flussence)
  • Rakudo now not only supports Linenoise, but also Readline (hoelzro, DrForr)
  • Creating Instant objects is now 8x faster, DateTime.now is 4x faster (lizmat)
  • pmurias has been adding many more tests for NQP ops and implemented a bunch of ops for the JS backend.
  • No longer infinitely recurse when trying to mkdir / (timotimo)

And here’s also some ecosystem additions:

With this, the ecosystem is at 485 modules. Neat, huh?

I must admit I’m a bit tired from the last few days, so I’m not going through the trouble of collecting every article that covered the Perl 6 release. Maybe you’ll even help me by linking to articles in the comments section under this post 🙂

Now I need to get to bed and rest up for tomorrow 🙂

See you in the new year, have a nice NYE celebration, and take care!

timotimo out.

2015.52: Closer and closer to the Release

Wow, the last week certainly flew past quickly. At least that’s how it feels to me. Or perhaps that’s just how cryo chambers work? Anyway, the Perl 6 IRC channel has been really, really busy and there’s been a whole lot of commits zipping past. Let’s see what’s in it for our users:

  • Multi methods in roles are now a whole lot more useful, as you can put multiple candidates with an implementation of { … } in a role to force classes that are supposed to do the role to implement them. (jnthn)
  • EVAL with non-literal strings is now loudly complained about unless you make your intention extremely clear by using the pragma “MONKEY-SEE-NO-EVAL” (to go with other pragmas like MONKEY-TYPING, MONKEY-GUTS (which used to be called “use nqp”), …). (TimToady)
  • Dependencies of precompiled modules are now directly found rather than searched for in the whole precompilation database, which causes a dramatic speed-up when a module with multiple dependencies are loaded. (nine)
  • Supply blocks now get a CLOSE phaser, which will fire when a tap is closed or the supply otherwise completes. (jnthn)
  • The annoying warning about using an undefined %ENV in string context is fixed! (ugexe)
  • NativeCall now understands an extra version parameter to its “is native” trait, which gets translated to per-platform naming. (Skarsnik)
  • Newline handling was changed again. Here’s jnthn‘s commit message for the change:
    Now, \n always means \x0A by default (the newline pragma currently is still available, pending a decision from TimToady++ on its future). We translate \r\n on file/pipe input to \n, and \n to \r\n on output. We don't perform any such translation on sockets, nor on explict .encode
    and .decode calls (providing an escape hatch). \r\n remains a single grapheme, though you're now much less likely to run in to one. This brings us in line with how the problem has commonly been tackled in other languages; logical \n turned out not to work out so well in real life, even if avoiding the cost of boundary translation was nice. Note that we translate at grapheme, not codepoint, level, so a \r\n will never accidentally become \r\r\n (as can happen in some translation layers).
  • We now have much more support for sized as well as signed/unsigned ints. That means you can now do my int8 $foo = -1; my uint8 $bar = -1; and get -1 and 255 respectively. 32bit floats are now also a thing with “num32”. Different native ints used to only make a difference when using NativeCall or in Buf and such. (jnthn)
  • Rakudo now understands × and ÷ operators for multiplication and division respectively. Thus, a WhateverCode that multiplies its two arguments can now be * × * instead of * * *. Also, if you accidentally paste a unicode “MINUS SIGN” instead of the commonly used “HYPHEN-MINUS” (any TeX users in the crowd tonight?), it’ll still give you the subtraction operator.  (TimToady)
  • Also, I think I’ve neglected to mention this, but Rakudo has supported unicodey numbers (only as single digits) for a while now (say ৪ + ૪ outputs “8”). On top of that, numeral unicode superscripts are also supported now (even with more than one digit!). So if you’re so inclined, you can write say 5⁸⁸ == 5 ** 88 and it’ll give “True”.
  • pre-increment and pre-decrement are now a bit faster yet. (TimToady)
  • Getting the .elems of a .combinations iterator is now blazing fast (grondilu)
  • IO::Handle::Seek now expects SeekFromBeginning, SeekFromEnd, or SeekFromCurrent as its whence argument. (lizmat)
  • We have a bool type based on stdbool.h now! (FROGGS)
  • X, Z, and roundrobin now understand itemization (this also fixes the metaop versions of X and Z – not only X, and Z,). (jnthn)
  • The xx operator now no longer gets rid of structure. (jnthn)
  • The JS backend of NQP now implements a whole bunch of mathematical operators. This includes a whole lot of tests for these operators. (pmurias)
  • MoarVM no longer throws an exception when trying to delete non-existing files. (cygx)
  • Thanks to ilmari, MoarVM now accesses unaligned values much less often.
  • UDP reads with length 0 (which libuv sometimes uses to signal a specific states) now no longer trip up MoarVM (hoelzro)

That’s all the interesting changes that immediately stood out to me from a cursory glance over the changelog.

More Adventing

Of course the advent calender didn’t sleep during the last 7 days:

(Yup, that’s 8. I’m giving you a little extra bonus. Because I like my viewers so much!)

Ecosystem catch-up

Since I forgot it last week, here’s the ecosystem additions of two weeks:

Not bad for “before the release”, eh? 🙂

 

Anyway, I’m pretty tired and it’s pretty late. That’s why I’ll end this post here. Thank you for reading! Be sure to follow Perl 6-related news channels later this week when Christmas hits and release-related things start happening!

2015.51: UPD, DUP, PUD, DPU, and other permutations

‘Sup everybody, it’s timotimo again with the weekly Perl 6 change recap! Before any of the nice changes this past week has to offer, I’ll link to all the lovely advent calendar posts that were published in that time:

Advent Calendar

Changes

  • Rakudo finally has support for UDP sockets via IO::Socket::Async (jnthn)
  • Also, you can now get the native descriptor behind an IO Handle (fileno on linux) (jnthn)
  • permutations is now multiple times faster and more improvements are already on the way (grondilu)
  • $foo++ and ++$foo on native ints can now become extra fast under many circumstances (TimToady)
  • This nasty case of precompilation issues is now no more (nine)
  • A whole bunch of operations – methods and subs – have been reviewed for their interaction with shaped and native shaped arrays (jnthn)
  • Pair.perl will now give the LHS parenthesis so that round-tripping works for things that look like identifiers (like undefined values/type objects) (zefram and lizmat)
  • Code-related objects (which users are very unlikely to want to override) like Code, Regex, Block are now looked up directly in the Setting by the compiler (jnthn)
  • Handling of “need to sink this” in the compiler has been refactored quite a bit (“Great Sink Refactor”, TimToady)
  • More methods on roles are now exempted from punning, which prevents a bunch of errors claiming you’d have to implement some methods because a role requires them (jnthn)
  • Native shaped arrays can now be used together with subs and operators that operate on natives arguments with “is rw” – notably ++ and — (timotimo)
  • CompUnit::RepositoryRegistry is the new CompUnitRepo and a bunch of things have been moved around (nine)
  • .hyper.map and .race.map work again (though .hyper.grep and .race.grep are still broken) (timotimo)
  • “fail” now reliably gives an error when used outside any routine (jnthn)
  • Many metaops (reduce ops, Z and X metaop) will now respect and inherit thunkyness (like the xx op re-evaluating its LHS every time, or short-circuiting behavior of && and friends) (TimToady)
  • A few features that won’t be properly specified in time for christmas have been marked experimental and now require “use experimental” statements: macros and “is cached” (jnthn)
  • Installing distributions that have more than one binary now locates the corresponding scripts properly (hoelzro)

I think that’s about everything. But even if I forgot to mention something, you can clearly see that there’s some nice progress going on here! 🙂

Starting today, The Perl Foundation is looking for feedback from the community to see if Jonathan’s grant should be extended to pay for another 110 hours.

And with that I’ve already reached the finish line of todays advent calendar weekly post!

See you again next week!

2015.50: Adventing Commences

With this Christmas being The Christmas™, there was no way we’d pass up the opportunity to bring you daily blog posts until Christmas on the Perl 6 Advent Calendar! If you’re unfamiliar with the Perl 6 Advent Calendar, feel free to have a look through each Table of Contents post for each previous year. There is quite a lot of really good content in there, even though some of the older posts may be outdated by now. On a similar note, a page called “Advent of Code” has been mentioned multiple times on the Perl 6 IRC channel. It offers a little programming puzzle every day. Could be great to try out Perl 6 with 😉

Advent Posts So Far

Perl 6 In The News

Blog Posts

Ecosystem Additions

On top of the additions, Math::Tau got thrown out of the ecosystem, as rakudo now ships tau in core.

Notable Changes

After the curli branch merge, module loading, installing and precompilation wasn’t quite perfect yet, so nine++ put in a lot more work to fix bugs found after people finally started testing the code. If you experience more trouble with latest rakudo/nom — which is not unlikely — you’re welcome to report them on #perl6 on irc.freenode.net or via mail to rakudobug@perl.org. Perhaps deleting the folder your Rakudo is installed to (for example, using rakudobrew nuke) helps you, though.

Array subscripting with listy objects is now more consistent. When you have a lazy thing (like an infinite range or something marked with “lazy”), the current size of the array will be used to cut off the subscripting, whereas anything non-lazy will give you assignable containers past the end. In other words, my @a; @a[^2] = 1, 2; will now work.

The ** operator (exponentiation) now throws errors in case an under- or overflow happens. (TimToady)

When making a socket listen, the backlog parameter can now be passed. (JimmyZ)

The “earliest” syntax is now gone. The much simpler to understand supply/react blocks have taken its place. On that note, Channel now has a proper Supply implementation, so Channel objects can be used inside supply/react blocks. Inside “earliest” blocks, trying to multiplex multiple channels forced busy waiting. (jnthn)

For more lovely things jnthn has done you can read his blog post, too (find the link in the “Blog Posts” section above.)

Parameters to MAIN that have a .WHY attached will now show it in the auto-generated USAGE. (donaldh)

NativeCall now supports arguments of type Pointer with an “is rw” attached. (FROGGS)

pmurias has been working on nqp-js for a long time and I’m sure he hasn’t been given enough shout-outs from the weekly yet!

Of course there have also been changes in our doc. Of note, jonathanstowe replaced examples for “earliest” with examples of “react”. Other contributions from dhaZoffix Znet, Skarsnikgfldexawwaiidmoleculeslizmatflussencestmuk, and raiph are of course also much appreciated!

And I must never stop mentioning usev6 (Christian Bartolomaeus) going through the bug tracker making sure to try to reproduce older bugs regularly to point out bugs that have long been fixed and close corresponding tickets. Thanks!

Don’t forget there’s a WANTED document in the doc repo that could surely benefit from your input!

Back to the Cryo Chamber

It’ll be another week until the next post on this blog. Until then it gets to rest in its cryo chamber 🙂

Except, maybe not this time. I just stumbled upon an idea I had earlier in the year: To go through all evaluated pieces of code in the irclog and highlight some of them in this blog on some other day of the week. Maybe I’ll have a look at that again and actually do it this time!

Have a splendid week, and see you again after the 3rd advent has passed!

2015.47: The Knights Who Fail Nil

Ohai everyone!

This time it’s timotimo at the post editor again. Again, a whole bunch of thanks to lizmat for covering the last three, er … four .. actually … seven posts for me! I think I’ve become a bit rusty at this, so please bear with me as I cover the changes between the 10th and the 16th of November:

One of the biggest changes from a user’s perspective is, I expect, that Nil is now let through the return type check, just like Failure used to be. Failure itself is now derived from Nil. TimToady explains that  “The upshot is that Nil is now regarded as the simplest form of failure, and people will be less tempted to use type objects to indicate failure”.

Other than that, there’s a bunch of things best covered as a few bulleted lists!

[Edit: added a note about nine’s excellent work in the curli branch just a bit below]

Assorted fixes & changes

  • nqp and rakudo can now be cross-built with the sysroot and sdkroot options for cross-compilation and similar tasks (Jens Rehsack)
  • The third argument in a loop(;;) now gets sunk. (TimToady)
  • = (assignment) can now be used in meta-operators and always means item assignment there. (TimToady)
  • Putting curly braces directly after a trait (like in sub foo is export{ … }) will now give you a helpful error message when those curly braces were actually meant to be the body of the sub or method. (TimToady)
  • Added a “put” sub that uses .gist (like say), but puts no newline (like print). (TimToady)
  • There were some problems in regexes with Longest Token Matching and the | operator in regexes when synthetic graphemes were involved or when “ignoremark” was set. (jnthn)
  • Having subs or methods in multiple dispatch that differed only in RW-ness of parameters used to be trouble. Now it works as expected. (psch and jnthn)
  • Named arguments that come after a flattened hash in calls now properly override the nameds that were in the hash. (jnthn)
  • Multi submethods accidentally got inherited into other classes. That no longer happens. (jnthn)
  • Captures that were backtracked over in regexes used to still show up in the final match. They no longer do. (jnthn)
  • Backreferences to captures that have multiple matches now have a “most recent continuous match” logic to them. The backreference then matches the text between $first.from
  • nine has been hard at work fleshing out the new CompUnitRepo Installation concept with code in the “curli” branch of rakudo. This will – among other things – give back precompiled modules, but also matching versions in use statements and such. Mad Props to nine for this!

Speedups

As always there’s a bunch of speedups all over the place:

  • The return typecheck of types with definedness or undefinedness type smileys is now quite a bit cheaper.
  • List.reverse is 4x as fast (6x on empty lists), List.rotate is 30% faster, List.roll(n) is 50% faster, List.sort is 30% faster
  • Buf.subbuf between 1.5x and 4x as fast
  • using [+], the reduce metaoperator on addition, is now special cased, so that adding up ranges of integers can be done with the O(1) algorithm instead. This also introduced a method “sum” on Any.
  • On the same note, the “sum” method on List is 30% faster than on a generic iterable.

Ecosystem and such

Zoffix has been putting a whole lot of work into the modules.perl6.org site, which has a branch in the works to turn it into a Mojo app.

On the documentation side, there’s of course always a bunch of changes and additions.

There’s also a little project underway to make sure modules in the ecosystem get more documentation. You can find the discussion in this github issue.

But in the ecosystem itself, there was a big number of modules added:

  • hartenfels’ Text::Markdown::Discount, a Text::Markdown compatible binding to libmarkdown (“discount”).
  • teodozjan’s Pod::Coverage, an important part of the “document all modules” project.
  • dwarring’s Crypt::RC4, for use in things like reading PDF.
  • cygx’ Image::PNG::Inflated, which writes an RGBA image to a PNG file without compression.
  • cygx’ Image::RGBA::Text, which lets you define images in a text format. Works well with Image::PNG::Inflated.
  • cbk’s Webservice::HazIP, which lets you get your machine’s public IP address from the HazIP service.
  • jonathanstowe’s  JSON::Infer, which creates class definitions for you from JSON objects like REST APIs based on JSON would provide, for example.
  • kolikov’s Lingua::EN::Conjugate, which conjugates english verbs.
  • Skarsnik’s Config::Simple, which supports JSON and Ini-like formats for storing configuration data.
  • vendethiel’s Hydrate, which lets you create an object hierarchy from hashes and lists.
  • bluebear94’s Terminal::WCWidth, which lets you find out how wide a given character will be printed in a terminal.
  • Not a Perl 6 module per se, but something worth a mention anyway: MadcapJake’s Perl 6 Support for Atom – Fun Edition.

Blog posts and videos

  • Larry Wall’s Perl 6 Release Talk at SF.pm has been online for a bit already, but I think it hasn’t been featured on the weekly yet and has recently made small waves on twitter again. That’s why I figured I’d link to it again.
  • Larry Wall gave an Interwiev on twit.tv’s “Triangulation” with Leo Laporte. You can find the video on twit.tv’s site.
  • Zoffix shares a bit of unicode fun for his HSV color module on twitter. Picture One, Picture Two.

One more thing…

arnsholt just revived my multiple-years-untouched iperl6kernel repository on github and added a pure-perl6 kernel for Jupyter. At the moment all it does is output on the terminal what it got from the front-end and react to heartbeats, but given a bit more time, I’m convinced it can be all you’d want it to be 🙂

Low Hanging Fruit for newcomers

With the Christmas Release fast approaching, most of our core developers are busy getting semantics right so that nobody accidentally relies on wrong behavior after The Release Everybody Looks At. That leaves a bunch of tasks on the wayside that aren’t necessarily hard.

I’ve got two [edit: three] little tasks that outsiders could reasonably easily pick up if they want to get into Perl 6 development. If you’re interested in trying or just want a few more hints, feel free to stop by on #perl6 on freenode or send a mail my way.

[HTML5, JS] Profiler App Improvements

Running any Perl 6 script with –profile spits out a HTML5 app based on Angular.js that lets you explore the gathered data interactively.

Unfortunately, there’s a few bugs still around, like the X button in some pop-ups not closing the pop-up.

More importantly the breadcrumb trail on the Call Graph portion of the profiler sometimes gets confused and you end up not being able to go up any more at all.

Also, the “icicle graph” in the top portion of the Call Graph section has terrible performance when the call graph is too deep, and quite often routines deep into the call graph are just 1px wide, rendering them useless.

All those things could be fixed in an example profile and then put into the profiler template.

[C] Fix an ABI compatibility issue between MoarVM and Rakudo

Adding more MoarVM ops causes spesh’s opcodes to shift. Rakudo accidentally compiles these opcode numbers into one of its .o files, and thus ABI breakage happens. I’ve described the problem as well as possible solutions in this github issue.

[Perl5] Add a probe to MoarVM’s build system for a too new compiler flag

This MoarVM github issue describes that RHEL5’s gcc doesn’t support -Werror=declaration-after-statement, a flag we’ve put in so that the linux-using or mac-using coders don’t accidentally break the build on windows.

Ideally, the probe.pm script would check if that flag is supported or not and then setup.pm would not include it.

That’s it!

This post took me a bit longer to write than I expected, but since that’s because so many nice things happened, I’m fine with that 🙂

Thanks to all our contributors Perl 6 looks better every day!

See you again next week!