blogs.perl.org

Test case clean up day today in the Moose-Pen

All those changes I introduced in my last post did quite a job in mucking up my test suite as the latest run results show;

Files=27, Tests=328, 39 wallclock secs ( 0.24 usr  0.06 sys + 36.90 cusr  1.92 csys = 39.12 CPU)
Result: FAIL
Failed 9/27 test programs. 37/328 subtests failed.

The first thing I noticed was not a fail in a test but this warning;

Use of uninitialized value in string eq at …/lib/Database/Accessor.pm line 37.

coming up all over the place, I should of caught earlier but that is why we run tests. A little change in my 'around BUILDARGS' sub;

Hey everyone,

Following is the p5p (Perl 5 Porters) mailing list summary for the past week.

Enjoy!

I recently added some functionality for random number generation to my modules, which led me on a digression about rand(). This is a short look at some modules for getting random floating point values. A later one will look at random ints and bytes.

Modules for rand()

Module Algorithm	Stat Quality	Interval	Bits in output	Auto Seed	Predictable	Speed
CORE::rand drand48	Bad	[0,1)	48	OK	Yes	29000 k/s
Math::Random::MTwist MT XS	OK	[0,1)	53	OK	Yes	14000 k/s
ntheory ChaCha20 XS	Good	[0,1)	53-113	Full	No	12000 k/s
Math::Prime::Util::GMP ISAAC XS	Good	[0,1)	53-64	Good	No	14000 k/s
Crypt::PRNG Fortuna XS	Good	[0,1)	53	Good	No	700 k/s
Math::Random::MT::Auto MT XS	OK	[0,1)	52	Full	Yes	5000 k/s
Math::Random::MT MT XS	OK	[0,1)	32	rand()	Yes	2200 k/s
Math::Random::Secure Math::Random::ISAAC	Good	[0,1)	32	Full	No	460 k/s
Math::Random::ISAAC ISAAC XS or PP	Good	[0,1]	32	None	No	5700 k/s 480 k/s
Math::Random::Xorshift Xorshift XS	OK	[0,1]	32	Time	Yes	16000 k/s

The Perl Toolchain Summit (PTS) is the annual event where we assemble the people who are actively working on the Perl toolchain, and give them 4 days to work together. In this blog post, we'll look at how we decide what everyone will work on, and give you a chance to make suggestions.

This blog post is brought to you by Perl Jobs by Perl Careers, which as well as helping Perl programmers find jobs, supports a number of community events, including the QA Hackathon last year.

It is keeping promises day here in the Moose-pen

Keeping in step with yesterday's post I am continuing with my code-review of Accessor.pm. It was suggested that I explain a little more on my reasons for doing most of the validation on the Accessor.pm side rater than the DAD side so here we go.

As today’s title suggests I want to make a promise to the DAD from the Accessor.pm that all the attributes that I have passed down to it are ready to go into a the requested CRUD query, so only a minimal amount of extra Database::Accessor::Driver logic is required.

What this mean is that I will have to carefully explain to potential users that the Update and Create methods only work with the initial set of 'Elements' and only with elements that have the same View. I have already did this one in yesterday's post.

Autoload can be a very powerful tool in Perl, though often you should first consider if there's a better way; Autoload is not necessarily the best solution for cases where you just need to generate many methods by name, and definitely is not the best solution for "wrapping" static methods. But if your use-case does necessitate methods created on the fly, I have released Autoload::AUTOCAN to make this easier to get right.

With the upcoming 5.26 release series of Perl, there's a breaking change that's part of the release. The current directory, '.', is being removed from @INC. It's a good thing, it deals with a bunch of potential security problems and has been discussed more thoroughly elsewhere http://www.nntp.perl.org/group/perl.perl5.porters/2017/03/msg243763.html and http://www.nntp.perl.org/group/perl.perl5.porters/2017/03/msg243722.html

This means that a number of common patterns in many perl scripts, particularly tests, no longer work the way that they did in the past.

In my long-term quest to host all of my data on my systems, one of the major points is to replace the note-taking app Google Keep with something that allows me to take my notes back to me. I've looked at various open-source apps for taking and synchronizing notes, but they either feel like overdesigned monsters that don't fit my workflow (Laverna) or don't have good synchronization from mobile phone to the server.

Well no progress day here in the Moose-Pen

After yesterday's post where I decided to much more validation on the Accessor side of things I had a chance to takke a deep and close look at Accessor.pm.

A code review is always a good thing and I found a few problems right from the start, in mose of my CRUD functions I was still doing this

return $container; 

which is dead wrong and funny thing I did not have a check for this. So today I added that in with a simple change to 20_dad_load.t

ok($da_new->$type(Data::Test->new(),$container),"$type Query ran");
--ok($da_new->$type(Data::Test->new(),$container) == 1,"$type Query ran");

You are invited to join us for this months Sydney PM meeting. We are hosted for the fist time by BarNet and we are glad and grateful for their invitation.

Everyone with an interest is welcome regardless of your experience with Perl and although we appreciate people RSVP'ing on Meetup, there is no need. Feel free to show up (and bring a friend) if you can make it.

There will be two speakers.

Lloyd will be speaking on his config management system, written in perl6

Brendan will be speaking about HashiCorp's Vault software, and how you can make use of it in your systems

When? Tuesday, April 18, 2017 6:00 PM

Where? BarNet ( Technology Dispute Centre ) 7/155 King Street, Sydney (St James Station is probably closest)

Find us on Meetup.com or Facebook

Hello everyone, today I'd like to present Neaf [ni:f], a web tool that tries hard to stay out of the way. Initially it was started for my own education. However, the result may be worth looking at even for users of serious stuff like Mojo, Dancer, and Kelp.

The main usage scenarios are perhaps sharing an existing module or script via the network, as well as supplementary tools and admin interfaces.

My day job involves programming in Go. One feature I like about Go is "defer". Any function that's deferred gets ran at the end of the functions scope. As a very simple example, the program below prints

hello
world

instead of the other way around, because "world" is deferred until the main() function exits.

package main
import "fmt"

func main() {
    defer fmt.Println("world")
    fmt.Println("hello")
}

Well its Accessor.pm post-ette day today here in the Moose-Pen

Yesterday's post I managed to make a very small start on my Driver::DBI before I figured it would be a good idea to do more of the param validation on the Accessor side rather than the driver side. That way I know I will not run into the situation where one Accessor/Driver combination works differently than another.

The validation rule for today is on the $container param for both the Create and Update and is as follows;

'Each element in the elements array that has the same view as the DA class must be present as a key in a Hash-ref or as an attribute in Class container. This rule is not on by default but is to be turned on only when the all_elements_present flag is true.

So to get the above in place I will need to add in that new flag here;

I just saw the release of Aristotle's Try::Tiny::Tiny to CPAN, which aims to speed up Try::Tiny. That led me to wonder how fast the various Try* modules were. I cannibalized the benchmark code from Try::Catch, and off I went.

At tonight's Chicago Perl Mongers Office Hours, Ray came up with an interesting problem. While testing all of CPAN for CPAN Testers, how do you detect when a test is hanging and kill it before it takes down the entire machine? How do you simply kill a test that is taking too long? And how do you do it without having a wholly separate watchdog program?

Ray's using Parallel::ForkManager to execute testing jobs in parallel across multiple Perl installs. There are a few ways we could implement timeouts, including IPC::Run's timeout function, or the alarm Perl built-in, but these must all be implemented in the child process. It'd be nicer if we could use the parent process to watch its own children.

So last day I with a colleague got to trace an interesting memory leak ( which was rather a memory waste than a leak ). It was using tens of gigabytes of RAM, whereas I wouldn't expect it to use more than 3-4GB.

Call it a witchcraft if you like, but we identified line to blame within first minutes we started looking at the problem. Unfortunately, we were not able to convince each other that it is the issue and as the problem was only visible in a long running soak test we were not able to justify running it.

Perl's garbage collection works by reference counting and only frees circular references at exit. As we were dealing with a long running daemon - we started by trying to locate circular references. Inspecting code gave nothing away. So we decided to utilise wonderful Paul Evans' Devel::MAT module. Unfortunately we were not able to locate any circular references.

Almost some code day here in the Moose-Pen.

Not much code today unlike yesterday's post where I changed eighteen files and checked in one new one.. Today I had a look at how I am going to proceed with Driver::DBI, With all the changes I made to Accessor.pm I have some rethinking to do with Driver::DBI

I will now have to

1. work with a results class
2. capture any errors into the appropriate attribute of that class
3. set the appropriate class attributes on success
4. set the appropriate class meta attributes and
5. check for any flags that may be set for special processing

Not a big deal really I thing this will really work out well. As for testing I think I will keep 10_crud_basic.t for now and just get that one all passing before I move onto more complicated queries and proccessing.

Recently, I needed to add a simple cache to my application. In particular, I was looking for a way to memo-ize a function, and age out old entries as necessary. There's great cache modules on CPAN that do this, but I needed to accomplish it with only standard modules.

In order to create a very dumb Least-Recently-Used cache, you need a list and a hash. The hash obviously stores mapping from keys to values, and the list keeps the order of items in the most recently-used order. When an existing item is modified or retrieved, its key moves to the end of the list. When an insertion is made that would overflow the size limit of the cache, entries from the front of the list are removed. Note that the implementation below would only work for string keys (and things that are convertible to strings, like intergers, since perl hash keys are stringified), but it shouldn't be too hard to modify to handle arbitrary objects.

Virtual Spring Cleaning (part 1 of XX / 2017) - in which I look who's calling

I really like the products by AVM, especially their Fritz!Box line of VoIP+DSL modems. For a long time, I've wanted to synchronize my CardDAV contacts from my server to my Fritz!Box, so that the reverse number lookup works on my landline as well as my mobile phone.

Hey everyone,

Following is the p5p (Perl 5 Porters) mailing list summary for the past week.

Enjoy!