2014.21: NLPW2014 recordings, release, optimization, GTK and Cairo

Heya, it’s timotimo again with your weekly change summary.

This week has seen the compiler release of MoarVM, NQP and Rakudo 2014.05. This post covers everything that was done before and after the release during that week.

  • Nicholas Clark used pahole to find and reclaim lots of bytes that were wasted in MoarVM’s structs due to alignment rules in the C compiler.
  • FROGGS’ loop label changes have landed in the release for all back-ends.
  • I added a few classes and a few lines of example code to the GTK::Simple module.
  • I also started work on a Cairo binding that’ll hopefully cooperate well with GTK::Simple as well.
  • I fixed a problem where NativeCall would dispatch callbacks to the wrong clones of the same closure.
  • tadzik added a module ClassX::StrictConstructor to the ecosystem that throws errors when excess named arguments are passed to a new method.
  • Thanks to lizmat, assigning to a read-only member or object now gives a proper error message on MoarVM.
  • A bunch of microoptimizations have happened. The result of those can be seen in the benchmarks: one with startup time counted, one without startup/compile time counted.
    • FROGGS made IO.d, IO.s and IO.z (checks for files being a folder, what size they have, and being empty respectively) about 40% faster
    • FROGGS also made Path::contains about 25% faster on JVM.
    • jnthn made binds to attributes in signatures (i.e. method foo($!bar)) take the fast path in the binder.
    • same thing for re-names in signatures
    • jnthn added more optimizations, that ended up making Path::contents much faster.
    • jnthn also tweaked the signature of “match” to go through the fast path in the binder.
    • the .comb method, when called without arguments, is also faster now, thanks to jnthn.
    • Junctions now work a bit faster as well. Another change by jnthn.
    • lizmat made say and note a bit faster.
  • There’s another big optimization done by jnthn that turns for loops that iterate over ranges into much simpler while loops. This change makes these loops as fast as the equivalent while (or loop) loop, but it’s still nice to look at.

Other than that, the recordings from the NLPW2014 are up on youtube. I’ve enjoyed jnthn’s talk about reactive programming a whole lot. Other than that, I haven’t yet spent much time watching these recordings.

That’s it from me for today. Hope you’ll have a brilliant week 🙂


Got something to note?

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s