2014.35: A Star Release, perl5 interop, …

Hey, timotimo here with another little Perl 6 update!

This time, I can announce an actual Rakudo Star release. FROGGS did the honors this time. The release announcement contains a few ChangeLog entries, but since the previous Star release was in 2014.04 there’s a whole lot of changes you’ll get to enjoy. If compiling the Rakudo Star stuff by yourself seems like too much of a hassle, hoelzro’s got you covered with his Docker image of Rakudo Star.

A few of the YAPC::EU videos have been uploaded to youtube. It seems like these are only the videos from one of the three rooms. None of the Perl 6 related talks happened in that room, though.

After the YAPC::EU, Ovid published a nice blogpost entitled “Try rakudobrew and play with concurrency”.

Other than that, a few things have happened since last week:

  • nine continued work on the “embedding perl5 inside Perl 6″ project. On tuesday he announced he could now use DBI inside perl5 inside rakudo. An important feature for making this work absolutely cleanly is still missing: DESTROY submethods on the Perl 6 side don’t get called by the GC yet, so you’d have to manually manage the Perl5 objects in your program.
  • Jnthn implemented the mechanism to give objects a persistent WHICH when they are used as object keys. This feature is only available on MoarVM, though. On Parrot it is not necessary, as parrot’s GC doesn’t move objects. It will have to be implemented on the JVM backend at some point, though.
  • Jnthn utilized the profiler he built recently to optimize the MATCH method in NQP, which gets called whenever a regex (for example, any token/regex/rule inside a Grammar) matches something and a Match object has to be created. They used to allocate a whole lot of Boxes that were immediately thrown away.
  • jnthn and TimToady worked on making errors like using say without an argument happen at compile-time; it works for much more than just “say”, too!
  • In order to further make matching faster, brrt and I implemented some more ops in the JIT that were blocking frames from being jitted (these include bindattrs_*, indexat and indexnat)
  • lizmat invested a whole lot of time into many different WHICH methods (which are used to create keys for hashes and compare things for equivalence)
  • lizmat also improved the performance of path-related operations and rakudo startup.
  • TimToady implemented many cases of anonymous variables
  • TimToady also started on an implementation of the plan method for lazy lists, which allows you to add a list to the end of a lazy list without forcing it to be eagerly evaluated.
  • hoelzro put more work into the Pod documentation implementation of rakudo.
  • nwc10 improved MoarVM’s compatibility with PowerPC (mostly endian-ness related changes that’d also apply to other architectures)
  • carlin fixed a whole bunch of warnings clang would point out in MoarVM and added arc4random support on platforms that support it (like BSDs)
  • carbin and vendethiel added Crypt::Reop and Sprockets respectively to the ecosystem.
  • masak advocated (and finally implemented) a change to allow *..* as ranges (which mean the same thing as -Inf..Inf)
  • there’s been work on the spec test suite by hoelzro, lizmat, TimToady, jnthn, masak, FROGGS, and Mouq

All in all it’s been a good week. A friend of mine lent me a book about x86 assembly and I’d love to learn what SSE has to offer and maybe implement a simple hacky prototype for arrays of int or num that can be used with SSE instructions or something …

Anyway. Hope you’ll have a nice week :)

2014.34: chugging along, GSoC is over, YAPC::EU, …

This week, there was a Rakudo release (not Rakudo *, which is the distribution that contains the compiler and a bunch of modules) and for someone who usually runs the latest master branch code, seeing the change log is always pretty neat.

Over the weekend the YAPC::EU 2014 happened in Sofia, Bulgaria. There were a few Perl 6 talks as well as lightning talks. I heard the video recordings will be up in “a matter of weeks” … Jnthn did a talk on concurrency and a talk on Rakudo performance advances, in which he revealed he’s been working on a profiler in secret. That was a pretty “wow” moment for pretty much all of the Perl 6 community! There was also a talk by masak about goto and why it’s awesome (no, really) and a cute little lightning talk. On top of that, there were talks by lizmat and lichtkind and a lightning talk by nine, who showed embedding a perl5 interpreter inside Rakudo and embedding Python code inside that. Nifty!

Sadly, I missed many of the talks, so I’ll be patiently (or impatiently) waiting for the recordings to be published.

Anyway, here’s your summarized list of changes during that week:

  • TimToady continued work on making our lazy lists less costly in eager context, like making the xx operator many times faster, so it’s now useful for filling very big arrays or lists with some initial values.
  • Some more performance tuning happened to the X operator (especially for ranges, which you’d idiomatically use to replace a nested for loop to go over 2D coordinates, for example), and the combinations and permutations methods. More is very likely to come soon!
  • Together with brrt, I implemented spesh’d operations as well as jit output for the boolification of iterators; If we already know we’ve created an iterator from an Array or from a Hash, we don’t have to check if the iterator is an array or hash iterator every single time we boolify. And since loops over arrays and hashes in NQP usually end up as a while loop that checks the iterator it creates for its truth value, this ought to show up in a bunch of hot loops.
  • A huge change (which I mentioned above already) is the profiler that got added to MoarVM. You can just run your perl6 or nqp code with –profile or –profile-compilation and get a nice little html output that you can comfortably browse through. Neat!
  • hoelzro and sergot have been working some more on making HTTP::UserAgent style things better/more pleasant/more powerful/more extensible/…

This list is already it, but especially the profiler item is a huge thing. Many of our devs were attending the YAPC::EU event, so they have been watching talks and socializing instead of coding all day and night.

Another thing is, that it’s always quite a bit of work to prepare the release, make sure the test suite remains clean, have your release candidate tarballs tested by enough people, … – I’m glad to say that Coke did a wonderful job this month. I’m hopeful we’ll see a new Rakudo Star release this month, as problems between Parrot and Rakudo that prevented last month’s release have been worked on in the mean time.

Of course, with rakudobrew being readily available as a simple way to install panda (our package manager) for you, the need for a Rakudo Star release is not really that big if you’re willing to put a few minutes rather than a few seconds of work into getting a running Perl 6 compiler.

Another thing: Google Summer of Code is now over and the evaluations have been sent in. Both brrt and sergot have passed and we are extremely pleased with how both projects have turned out so far. In addition, we’ll see more contributions from brrt and sergot in the future :)

Finally, if you’re as impatient as I am, you can have a look at different slide sets that were presented at YAPC::EU.

Anyway, that’s it for today. Hope you’ll have a nice week :)

Weeks 32 and 33:

Last week I got distracted by an ear infection and productivity plummeted, and when I recovered near the end of the week I didn’t want to write the blog post for monday and ignore everything that happened since, nor did I want to write a blog post on friday and have almost nothing to write about the next monday!

So now I’ll give you a blog post covering two weeks instead of just one. Here we go!

  • Mouq has started implementing the ** (called the HyperWhatever), which is like the Whatever Star, except for lists of values rather than individual values (the regular Whatever Star works like this: @names.map: *.uc)
  • Mouq, with input from TimToady, has also started working on making Lists of Lists work to spec, which is an especially nice thing to have in array slices. It means you can have a two-dimensional array and get the second entry of each inner array like @twodim[*;1].
  • Last monday was the “soft pencils down” date for the GSoC. At that day, the moar-jit branch got merged into master, as it’s rather stable now and Configure.pl will build a jit-less MoarVM by default still (use –enable-jit to get a jit-enabled build instead).
  • A whole bunch more ops have been implemented for jitting. Mostly by brrt and Jnthn, but I added a few myself, too. I don’t recall when exactly it happened, but On-Stack-Replacement interacts properly with the JIT now and the JIT can handle extops, too. Handlers, which used to trip up spesh, are functional with spesh and JIT, as well, but I think that has already been the case ~2 weeks ago.
  • The most obvious thing still missing from the jit is support for a bunch of different “param” accessor ops. brrt is still looking for the most efficient way to jit them. After those are done, I expect a tremendous amount of frames that are currently bailing out will be jitted (either “further” or “to completion”).
  • Jnthn implemented asynchronous process spawning and communicating to stdin/stdout/stderr on MoarVM, which is a feature he’ll be giving a talk on during the YAPC::EU in Sofia at the end of this week.
  • Froggs has continued pushing Slang support in Perl 6 further and further. His port of v5 from being NQP code to being pure Perl 6 code is progressing nicely and has just reached the point where the Perl 6 version passes a third of the tests the NQP version used to pass.
  • lizmat nuked eval_dies_ok and eval_lives_ok from the specs, as they are likely to be used incorrectly (local subs and variables are not always available in the eval’d code, as the optimizer is free to turn lexicals into locals and thus hide them from eval). She’s now busy replacing all the uses with direct uses of EVAL in the spectests. A few spectests have already turned out to have been relying on some eval’d code dying, but the code was dying for the wrong reason, thus giving a false positive test result.
  • Jnthn changed both the annotation API and the children node API of the QAST objects, causing fewer allocations (no childrens array for leaf nodes, no annotation hash for annotation-less nodes).
  • Also, Jnthn threw out a “middle man” datastructure that was created and shortly thereafter thrown away and turned into a different datastructure on every single successful match or sub-match. An equivalent change is still needed in rakudo, but having the change in NQP already makes build times better.
  • On top of that, more kinds of things are now lazily deserialized in MoarVM, making start-up faster and cheaper on RAM yet again.
  • sergot posted a nice nearly-end-of-GSoC post on his HTTP::UserAgent and friends project, which includes a bunch of documentation (to be found in the actual HTTP::UserAgent repository itself).
  • I re-ordered code in the library loader that used to cause a whole bunch of stat calls on locations in the libpath for libraries that were already cached! Now the cache is looked at before the filesystem is searched through.
  • japhb has been improving perl6-bench for better windows compatibility and made the history comparison less prone to exaggerated scores from some of the microbenchmarks – the JVM implementation makes really, really short work of empty loops!
  • hoelzro is continuously working on improving the ability to attach documentation to objects like classes, roles, attributes, … in the S26-WHY branch.
  • pmurias is working on a refactor/rewrite of the nqp-js code emitter which leads to better code output, support for “source maps” and other nice things.
  • nwc10 has been a tremendous help for regularly running the newest MoarVM and JIT changes through ASAN (address sanitization) and valgrind for us.
  • lichtkind has resurfaced and worked on the tablets again.
  • TimToady gave pushing a list into another a big speed boost for bigger lists by un-lazying the list that is to be pushed.
  • Another change TimToady did was to give dynamic variables a little cache so that lookups would happen quite a bit quicker and be cheaper in general.
  • donaldh found out what made one of the later stages in Rakudo-JVM’s (and nqp-jvm’s) compilation processes so terribly slow and fixed it. In rakudo’s core setting compilation, stage jast used to take as long as stage parse, now it’s down to about a tenth of that. This impacts every single run of rakudo and nqp, not just the initial build.
  • psch improved some error messages in regexes. Also, some improvements to m:g// and s:g/// are in the pipeline for a later date.
  • PerlJam fixed some problems with floating point numbers and scientific notation in sprintf.

So that’s pretty much it. A whole bunch of nice changes, I must say.

A release is coming up this week, on Thursday if I remember correctly. Unfortunately last month’s Rakudo Star release isn’t finished yet; we’ll see if it will be released later or if the work that has gone into preparing last month’s Star release will just be ported over to the upcoming version directly.

2014.31 (for real this time):

Even though last week’s headline claimed it was about weeks 30 and 31, the 31st week was actually this last one! D’oh! Calendars are hard :)

Anyway, here’s your mostly-weekly fix of changes:

  • Jnthn found a bunch of optimization opportunities in the optimizer (hehe), making it run a bunch faster.
  • Another big win was jnthn finding stuff we did repeatedly or stuff we did just to throw away the results again:
    • When trying to match an <?after …>, the regex compiler would flip the target string every time the <?after > was hit. Now the flipped target string gets cached.
    • Every time an NFA got evaluated (which happens whenever we reach a “|” alternation in a regex or a proto token that has multiple implementations. i.e. very often) we took a closure. Jnthn re-wrote parts of the code that works with the NFA cache and managed to shave off a dozen GC runs from our CORE.setting build!
    • Another 800000 allocations went away after jnthn let the alternation index array be generated statically rather than every time the alternation is hit.
    • Improved handling of sink (which is what handles things like failure objects being thrown and side-effects invoked in certain conditions; only thing you need to know is it gets emitted a whole lot during AST generation) leads to smaller ASTs and gives our code-gen opportunities to output better code.
    • even more improvements I didn’t mention!
  • A little piece of work jnthn suggested I’d do is letting our bytecode specializer only mark a guard (like “please make sure this object is concrete” or “please make sure the type of this object is $FOO”, which would cause a deoptimization if they fail) as necessary, when the optimization that would rely on the guard in question actually was done. Unfortunately, we don’t have before/after measurements for how often specialized bytecode deoptimized …
  • On MoarVM, simple exception throws can now be turned into simple goto operations. This also includes things like redo/continue/last in loops.
  • I implemented specializations for the smart numify and smart stringify operations on MoarVM; Something that happens especially often is numifying lists or hashes, which now turns into a simple elems op (which our specializer can and will further simplify)
  • I also implemented a few very simple ops for the jit, so that brrt could spend more time doing the hard bits.
  • Another thing jnthn worked on is making allocations and deserializations lazy. This helps improve the start-up time of the repl and all programs and also improves the  memory-usage of perl6 programs that don’t use much of the CORE setting, which would probably be most.
  • Vendethiel (Nami-Doc on github) wrote a nice guide to perl6 that became included on learnxinyminutes. Kudos!
  • Froggs and lizmat worked further on CompUnitRepo and module-loading-related things
  • a well-timed “well volunteered!” motivated btyler to start a C binding for the jansson JSON parsing/manipulating/outputting library. In very performance-critical situations, especially when you only use parts of a very big JSON document, this should give you better performance than JSON::Tiny. However, JSON::Tiny is a part of the benchmark suite we’re running all the time, meaning we’ll react to performance regressions switfly and try to figure out what makes it slower than it has to be.

Now here’s some numbers to compare today’s state with the state at the time of the last release:

  • 30 seconds for a NQP build (used to be 37)
  • 57 seconds for a Rakudo build (used to be 1:15)
  • 0.02s and 13 MB maxrss to fire up a Rakudo REPL (used to be 0.04s and 35 MB)
  • 0.2s and 114 MB maxrss for a “say 1″ (used to be 0.27s and 135 MB)
  • now it is: 584.95user 75.88system 3:44.71elapsed 294%CPU for a full spectest run with 4 test_jobs
  • used to be: 765.43user 89.06system 4:40.32elapsed

There’s still more opportunities to deserialize things lazily upon first use in MoarVM which ought to give us lower baseline memory usage and spread out startup time “more evenly” (and remove it when possible).

The baseline memory usage of our Perl 6 compilers has always been something that annoyed me. MoarVM gave us about a 2x memory saving compared to Parrot and now we’ve started work on making the memory usag better. I’m excited! :)

Sadly, brrt has been plagued with very stealthy bugs all week, so progress was kind of slow. What he did manage to finish is support for indexat and jumplist, which is needed in most regexes Also, sp_findmethod, findmeth, findmeth_s, indexat, getdynlex, … are done now, but temporarily commented out for bug-hunting purposes.

That’s it from me for this week. I’m already looking forward for the cool stuff I’ll be able to highlight next week :)

2014.30 & 2014.31: A release, upcoming Star, optimizations, v5 refactor, …

Hey there,

last week I didn’t find enough exciting stuff to talk about and there was a release due for the middle of the week, so I decided to just skip a week. Here’s what happened in both weeks combined:

  • There was a Rakudo release and avuserow is currently quite close to finishing up a Rakudo Star release as well. Since Rakudo Star was supposed to be a quarterly release anyway, we’re still on track :P
  • on the JIT side of things, thanks to brrt MoarVM got the following stuff improved:
    • ops that want to invoke can now be handled, including the smart_stringify and smart_numify ops, which were very common in our test code (we’ve been using the CORE.setting to get “real-world” code.)
    • the jit learned how to cope with On-Stack-Replaced frames.
  • thanks to a test case by TimToady, jnthn was able to fix a couple of memory leaks in MoarVM’s spesh framework (found with valgrind).
  • jnthn also came up with a bunch of optimizations that benefit regex/grammar matching, start-up time, and junctions with certain operators.
  • Inlining, which is a major source of speed improvements on MoarVM, has been bailing out if it saw the lexotic op in a frame (which is used for example for returning, but also for exceptions) or when a frame had handlers (exceptions handlers for example). Those occur very often in code generated by Rakudo, so Perl 6 code didn’t benefit from inlining as much. Both of these have been made to cooperate with inlining now, though.
  • extops, meaning ops that are loaded into the VM from a dynamic library rather than being built into it, can now participate in the facts discovery and bytecode specialization phases of spesh. This is especially nice for Perl 6’s containers, as the decont operation can now be as efficient as a simple pointer indirection.
  • Froggs has reached the point where a v5 implemented in Perl 6 code (rather than NQP code as it used to be) runs again.
  • Froggs also made warnings print line numbers and file names again on JVM and MoarVM.
  • Froggs implemented the “charrange” method for our regex compiler, which I helpfully stubbed in about 9 months ago …
  • Coke spent a lot of time making sure non-passing tests were properly fudged and had tickets in our RT.
  • dwarring has made a bunch more tests corresponding to advent calendar posts and created at least one RT ticket for those, leading to (actually: following) a discussion about how junctions should interact with smart matching.
  • pmurias has started working on NQP-Js again, our javascript backend for NQP (and rakudo in the future). There’s a todo file to which low hanging fruit will be added for people who are interested in getting into this project.
  • Mouq has been working on support for semilists (“semicolon-separated lists”) in hash and list subscripts, which are going to help a lot with multi-dimensional arrays and such.
  • hoelzro improved our test running of rakudo a bunch, among other things to make output more useful
  • japhb built even more improvements to perl6-bench!
  • Froggs made it finally possible to use variables and code-blocks as quantifiers in regexes, i.E. / foo ** $a /. This is probably a feature many people have missed so far! It works on all our backends, as well!
  • Froggs also improved a bunch of other things, like how words are split inside our quotewords (which we spell < >).
  • Instead of writing this post, I spent some time implementing more and more ops for moar-jit, following a very helpful bail report by moritz.
  • Another thing I implemented (after jnthn assured me it would be simple) is less conservative marking of which guards we end up relying on when specializing code; 15 guards removed for the core setting may not be terribly much, but each of these may correspond to any amount of unnecessary bail-outs from specialized bytecode back to unoptimized bytecode.

Right now, some more bugs in the jit and spesh are being ironed out. After that I’ll get to find out what happened to the about 500 frames that used to run into some unimplemented operation I implemented in the mean time; Each of those can either run straight into a different unimplemented op, or get compiled successfully. Either case is interesting and they are easy to distinguish by just looking at the overall numbers of bails.

Anyway, it’s nearing midnight and I still want to get this post out the door on monday local-time. So here you go, an unpolished blog post :)

Hope your week’s going to be good; I’m sure it’ll be a nice week for us Sixers :)

2014.28: Moar jit, string overhaul, metaoperators, …

Even though the previous post was a bit late and so this one covers a few days less, there’s interesting things to report. This week, raiph sent me a little summary of IRC activity again, which made it much easier for me. So thanks!

And now let’s see about those developments:

  • hoelzro has continued work on the pod documentation attaching to entities (methods, classes, variables, …)
  • Will Coleda worked on cleaning up our spectest suite a bunch.
  • brrt has continued work on the JIT, namely making invocations work (both the spesh-improved “fast” invocation and the regular “slow” invocation).
  • There is now also a log that shows what opcodes end up being jitted and which opcodes cause the JIT to bail out due to NYI or other reasons.
  • Using this log, brrt concentrated on a bunch of opcodes that commonly cause bails.
  • Even I got some work in this week, namely having been inspired to hack on the JIT a bit myself; a bunch of ops can be compiled to regular C function calls, and those are sufficiently easy to add. I’ve added support for:
    • checkarity (which is responsible for giving run-time errors for wrong numbers of arguments if we couldn’t determine that at compile time)
    • push_o, pop_o, shift_o and unshift_o (to access lists and such)
    • atpos_o (getting an object in a list by index)
    • getattr_s (accessing a named attribute of an object; with help from brrt).
  • Additionally, jnthn pointed out that deconts on containers that are quite simple (just a pointer indirection) can be spesh’d to look exactly like a spesh’d attribute access, so I was able to add support to spesh to simplify some deconts (which is an operation that used to cause the jit to bail out extremely often).
  • The top ops causing the JIT to bail during the compilation of CORE.setting are now:
    • “graphs_s” (which seems to be in every piece of code that follows “getattr_s” + “flattenropes”)
    • “ifnonnull” (100% of the “atpos_o” bails turned into “ifnonnull” bails)
    • param_rp_o (grab a required positional parameter)
    • newlexotic (related to exception handling)
    • the decont ops that were not spesh’d away.
  • Sadly, MoarVM’s JIT compiler isn’t invoked at all in the case of On-Stack-Replacement optimized code, so none of our current benchmarks will show any change between JIT and no-JIT.
  • jnthn has started on the long-awaited rewrite of MoarVM’s string handling. Here’s a benchmark from jnthn’s machine comparing last month’s release of MoarVM, the strref branch of MoarVM and last year’s rakudo-parrot. (so no JIT yet). Across the board there’s improvements, but the most important improvement can be seen in the benchmarks that have “concat” in their names. These are the ones that concatenate strings.
  • jnthn greatly improved the metaoperator parsing in rakudo. The parser used to barf when it saw rather unwieldy operators with disambiguating brackets in them and set operations and such, for example (|)= or metaops with reductions like [[*]]=.
  • jnthn also merged the “lex2loc” branch that allows the Optimizer to turn lexical variables into locals if we can prove that they’re not accessed outside the frame they’re in. All backends benefit from this.
  • psch finished the implementation of the translate operator “tr///” and its return value.
  • thanks to japhb, more perl6-bench improvements landed.
  • A whole bunch of work has been put into improving the POD to HTML rendering by Mouq, lue and atroxaper, like the Pod::SAX, Pod::Walker, and an HTML renderer based on both of these modules.
  • retupmoca added a module for interfacing with RabbitMQ to the ecosystem, called Net::AMQP.
  • lizmat worked some more on S22 and the related tests and did some more discussion about details with the community.
  • lizmat and retupmoca fixed problems for Supplies that are .tap’d multiple times.
  • masak added a module Data::Pretty that will give common things you might want to “say” a friendlier output.
  • sergot posted about adding both a high level and a low level wrapper for OpenSSL on his blog.

And if you’re interested in getting into Perl 6 Module Development, you could adopt bbkr’s MongoDB related modules BSON and MongoDB.

The next releases are going to happen soon-ish. On Thursday, MoarVM is going to be released and the NQP + Rakudo release is going to follow this week, too.

Thank you for reading and may your week be filled with adorable kitties (or something equivalently cuddly, if you’re allergic).

2014.27½: A boat load of stuff, pointer arithmetic and casting.

Hey there! I’ve been a bit busier and distracted than usual this monday and tuesday. Sadly, I can’t really write the posts on sunday night and publish them when I get out of bed, as many nice things usually happen between sunday evening and monday noon :) Anyway, raiph combed through the IRC logs for me and collected a whole bunch of things. Here’s my rendition of the recent happenings, including up to today, as I’m running so late:

  • lizmat led the discussion about the behavior of writing “my %h = { … }”, which is now considered assigning an itemized hash to a hash variable and gives a deprecation warning. Programmers might assume this would flatten the right hand side into the hash, but we found that behavior too magical. Thus, lizmat took care of that.
  • psch has been working (for a bit longer than just this past week, actually) on patches to teach rakudo to properly work with tr///, the “translation” operator. It’s supposed to return the number of characters changed in the source string, which was the most complicated part so far, it seems.
  • FROGGS taught all backends to do pointer arithmetic on CPointer repr’d things, allowing NativeCall to handle array-like things better.
  • FROGGS and sergot also implemented “NativeCast” for the NativeCall module, allowing a CPointer to be cast to any type we know. Apart from legit use cases, this allows some scary, scary stuff to be done :) (see also)
  • The above work is an important stepping stone towards proper TLS support as well as supporting function pointers (for an OpenGL implementation, for example, when you want to have GL extensions)
    • Function Pointers need a bit more work in the perl6 Grammar (actually the Actions) so that we have proper type annotations for &vars (like my &funcptr:(int, int –> int) or something)
  • lizmat implemented and then reverted the “is cached” trait on methods, which is a bit harder than doing it for subs, because it has to factor in the “self”, as well. It’s not yet clear what the semantics are supposed to be.
  • lizmat has also continued working dilligently on the S11 and S22 things, among others the CompUnitRepo classes. I saw FROGGS do a few things in this area, too.
  • masak and krunen did a little “ping-pong programming session” to implement “emmabot”, a bot that should report on the daily ecosystem and Rakudo Star module testing results. Here’s the section of the irclog and here’s the repository for the bot. I didn’t pay close attention to the conversation, but it might be a good example of how to do Behavior Driven Development :)
  • Speaking of the daily ecosystem module testing results, a result page now lives on one of our servers and can be reached here, thanks to moritz, coke and colomon.
  • hoelzro invested a bunch of time into making the handling of #| (that is, attaching pod comments to variables, methods, classes, subs, …) to spec in rakudo and the test suite. Turned out to be quite a bit hairier than it looks from afar!
  • dwarring continued to improve our test coverage of the advent calendar posts.
  • japhb landed more improvements to perl6-bench, including extracting a bunch of smaller benchmarks from rc-forest-fire to help figure out why rakudo is so slow at it.
    • In doing so, we found out that rakudo easily beats perl5 at Big Rational Number arithmetic. Pretty neat!
  • jnthn continued his usual work: stability and performance. Among other things, rakudo now turns more lexicals into local variables if it can and variables gained a new scope (“typevar”) that is interesting for optimizing roles and such.
  • jnthn helped japhb figure out what changes are needed to get perl6-bench to run well on windows. Here’s a benchmark result from his machine.
  • jnthn has made MoarVM’s bytecode specializer throw away guards that the specialized code ends up not relying upon. This reduces the number of times we deoptimize unnecessarily.
  • A few fun things on RosettaCode: TimToady’s “draw a clock” implementation with braille-based graphics and sml’s parser for the Multiple Dwelling Problem.
  • tadzik tried out MoarVM on his phone. Sadly, cross-compiling the MoarVM bytecode isn’t as trivial as it ought to be, as it contains file paths that would need fixing up…
  • Mouq is working on a Pod::Walker module to make creating Pod-To-* converters easier. In order to test it, he’s also refactoring Pod::To::HTML to be based upon it.
  • atroxpaper is working on a different Pod Walker, namely Pod::SAX. It will provide a stream-like/callback-like API to processing Pod files.
  • retupmoca fixed up the ecosystem to point IRC::Utils, Date::WorkdayCalendar, TestML and YAML at forked repositories on github that had pull requests open for longer than a month.
  • zengargoyle built a module for fortune files, grondilu started work on a module for “chess related stuff”.
  • Coke dilligently made sure everything’s all right with the daily test runs. For example, att one point, rakudo.parrot had failed 1800 spectests (due to mostly a single problem).
  • JimmyZ updated MoarVM’s packaged uthash to the newest version.

Here’s an update on the GSoC stuff:

  • brrt recently blogged about his progress and has been working mostly on refactoring the code base and supporting invocation in the jit since then.
  • sergot has started working on OpenSSL related things. The repositories can be found on his github.
  • Unfortunately I have either not heard from the other projects or forgotten what I’ve heard, but I do recall that all our students have passed the mid-term evaluations!

Apologies again for the much belated post. Hope y’all have a nice week :)

Update: a few inaccuracies were fixed.