In this post I decided to dig deeper into the Pod::Weaver template well really I just explain that the 'weaver.ini' file is the template/
Dist::Zilla On Style
This post I go a little deeper into the varios differnt template bundles out that and show the template works a in a little more depth.
Dist::Zilla Takes it in the Name
The first in my rathder long series of review of the various 'Section' plug-ins. To start the rather simplistic [Name]
Dist::Zilla Regional Report
This post deal with one of the more common section plugins [Region] and I intoduce the concept of moving stuff about and build an ordered document out of an bunch of unorded parts.
OK, the tag “worst
Perl” might be overstating the case, but we ran into a funny error message
yesterday from a program that runs on all of our production equipment.
As each lot is tracked into a piece of equipment, the program running on it contacts our MES (manufacturing
execution system) to verify information about the lot. Because the MES used to
run on a really slow server, timeouts were common, so at some point the function
to look up a lot was wrapped in a function to retry a few times in that event. The MES server has since been upgraded, but we never took out the retry functionality. Here's the code in question:
In my previous post I explained how many utf-8 related issues are now fixed in the latest DBD::mysql development release, and I asked for feedback and testing from our users.
Even better utf-8 handling
I'm happy to inform you that, thanks to your feedback, we've now released yet another development version, with even more UTF8 issues fixed. Tanabe Yoshinori reported that column names and database warnings were not properly encoded and prolific contributor Pali Rohár fixed that issue, and much more.
Serialization issue under taint mode
One other issue which was reported by amavisd users has to do with how perl stores values internally under taint mode, which is the default way amavisd is run. This is now fixed, see for more information https://github.com/perl5-dbi/DBD-mysql/issues/78.
Another less than insipred day here at the Dist-Pen.
Well ten more posts to look at.
Dist::Zilla Plan
In this post I sat down with my Database::Accessor code base and ran it though dzil test to make sure it was all working.
Very Little Dist::Zilla
Well went off on a tangent with this post. I had problems with this test case 31_elements.t and finally found a solution to the problem I was having was where to place some test classes so the tests would run without hard-codeing the paths.
Dist::Zilla Party Time
Well in post I finally mad a mile-stone in my porject, I got all the test cases to pass and I found another bug I fixed and my tests still passed.
Dist::Zilla is Sad or is that Happy?
Still stuck on the same bug but this time I actully found a better solution that got rid of a kludge I was using and did not like
I'm currently running slightly behind the schedule outlined in the grant. I expect to complete the Action Plan and have it ratified by other core members by March 18th, which is the date of the 2017.03 compiler release. Then, I'll implement all of the Action Plan (and complete the grant) by the 2017.04 compiler release on April 15th. This is also the release the next Rakudo Star distribution will be based on, and so the regular end users will receive better IO there and then.
This time on blog I'll show you how to write your own template engine - with syntax and behavior tailored for your needs. And we'll do it in four different ways to analyze pros and cons of each approach as well as code speed and complexity. Our sample task for today is to compose password reminder text for user, which can then be sent by email.
Another chore post this time creating the README file.
Dist::Zilla VCS Opps!
In this post I had a go at linking up my distribution to my VCS which in this case was GitHub. Though I am quite sure I did things corrctly I was just way to earl in the developement cycle to actually hook things up.
Dist::Zilla Do Kwallitee Test
This was a first of a series on how Dist::Zilla does its testing. The first time I really figured out the difference between author, release and automated test cases. I also put in my first Test plug-in [Test::Kwalitee]
Hello everybody,
this is my first post, so please go easy on me.
I work with Perl for last 19 years and it always treated me extremely well in regards of interesting work or material compensation. Past December my company decided that it's time to finally join in the fashion of the day and start experimenting with ML.
I started researching and found out that's my lovely Perl is stuck in the past in regards to ML support and there's no any recent developments in this area (like full last decade).
Now look at Python!
Tensorflow, MXNet, Keras, Theano, Caffe, and many, many more. Java has it's deeplearning4j, Lua has Torch and what had Perl ?
We had AI::FANN, the interface (good one, I used it, it's good) to the C lib that has not seen any real development since 2007, only feed-forward neural networks, no convolutional networks, no recurrent networks, all advances in last 10 years just were happening outside of Perl.
Thanks to The Perl Foundation and our beloved sponsors, a large portion of the critical contributors to the Perl 5 Porters (p5p), the core group of Perl 5 developers, were able to get together on November 11th, 2016 at the Booking.com headquarters in Amsterdam, The Netherlands, for our very first Perl 5 Core hackathon, nicknamed Perl 5 Hack.
In this post I try my hand at building a distribution with Dist::Zilla. Here I found out about some of the required attributes that Dist::Zilla needs and how to use my first plug-in and generate my first distibution with dzil and had a quick look at the mass of Plug-in found on CPAN
Carrying on from my first attempts I added in an 'Abstract' into the mix and then started to add in other Plug-Ins to really make a useful distribution for CPAN and learning that dzil has a clean as well as a build command.
After spending a long time chasing a bunch of bugs (a lot of ones that boiled to a few lines of code had really weird consequences that needed to be painstakingly chased down) and implementing some missing parts I finally got Test.pm6 to compile and load.
This allowed rakudo to pass few roast tests (like S03-operators/not.t) for the first time. Once some remaining issues with the Test.pm6 get solved hopefully a whole bunch of others will pass.
Currently the coroutine ops needed for Test (for gather/take type stuff) to load are implemented in a node.js specific manner using the fibres. I previously had an pure js implementation of them using a CPS transform but it carried a large cost in terms of generated code and compile time so it got disabled as it was slowing down development. Some careful thought will be needed later on how to re-nable it with only paying for it for use.
Now that rakudo.js is starting to run actual Perl 6 code my current focus is to make rakudo.js easier for others to play it.
That includes means making the way it builds (at least remotely) sane and cutting down the horrible (10+ second locally) startup cost of loading the setting. A lot of the startup cost seems to be caused by the way lexical scopes are setup in rakudo.js which also needs a cleanup as it's currently to influenced by how nqp does things.
I am curious
whether anyone else would like to see else clauses applied to for/foreach and while loops, where the
code in the else clause would
be executed if the loop body was completely skipped due to the
conditions/boundaries. So for example:
…with a for/foreach loop:
for my $temperature ($temp_lower_bound ..
$temp_upper_bound) {
set_temperature($temperature,
$soak_time);
push @data, get_sensor_reading();
}
else {
die "Temperature upper bound must
be greater than lower bound!\n";
}
foreach my $datum (@data) {
print "processing
$datum...\n";
process($datum);
}
else {
warn "No data!\n";
}
…with a while loop:
open LOG_FILE, "<", $log_file
or die "Could not open log file:
$!\n";
while (<LOG_FILE>) {
process_log_entry($_);
}
else {
print "The log file was
empty!\n";
}
close LOG_FILE;
Obviously all of these examples could be implemented by
wrapping the loop in an if…then…else that checks the condition or boundaries, or by setting a
“ran once” flag in the body and checking it after, but those solutions—that I
use all the time—seem unwieldy and inelegant to me.
Note this isn’t a Perl-specific concept; it could apply
to almost any procedural programming language. (Does it already exist anywhere
else?)
See part 1 and part 2 to get caught up. In our part 2 meetup (last night), we changed things up a bit. I decided that tackling the space mission to start was going to be a bit much (too much content), so I switched us to Action Castle, the first adventure in the Parsely series. And built out a mission config file with notes from the adventure using the structures that we designed in our first meetup.
After explaining the reason for the change, the group agreed, and we continued on our merry way. As we continued to define our mission spec, we figured out an API for plugging code calls into the spec. For example, you could replace an exit like this:
exits:
North : catacombs
With a code call like this:
exits:
North :
code: PluginNameGoesHere
params:
destination: catacombs
foo: bar
We built some sample code for exits, actions, and turns. None of this is final or anything, just building some samples so we could work through the the thought exercise.
Today I am looking at the I think the last section plug-in the [WarrantyDisclaimer] plug-in. This is your standard blurb type plug-in that will dump a bunch of legal words that is suppose to cover your arse if someone uses you code to control a self-driving car that goes berserk and crashes into a children's hospital causing a fire as the cute puppy store.
This plug-in has a number of subclasses that you can use to match up the license you are using to the correct subclass. So far there are six sub-clases
Default
Artistic
Custom
GPL1
GPL2
GPL3
Myself as I am using the GPL 3 so in my 'weaver.ini' file all I need to add in is
You know, I’ve been trying to analyze my working patterns lately, and I think I’ve hit on something. Looking back over the past few years, it seems like I get obsessed with one particular project, work frantically on it and produce lots of great stuff, then I get distracted and next thing I know I’m obsessing over an entirely different project. And then sometimes I circle back around to the first project, but it’s usually a long time later. I’m actually starting to wonder if maybe I have some undiagnosed ADHD (not only because of the easily distracted, but also because of the hyperfocus, and SQUIRREL!). Anyways, that appears to be the pattern of my life, so I think at this point I’m just going to have to learn to roll with it.
Before we start: this is my first post at blogs.perl.org. Awesome that you're reading it despite me being a noob! :)
Three years ago, I started to change the way I think about logging in applications. Before that, to me it was just printing lines into text files, in order to later read and grep my way through them.
Then, a friend pointed me to ElasticSearch and Kibana, with its infinite ways to search through, and visualize, large amounts of textual data. Due to the nature of my $work, I was well aware of the benefits of a full text search database, however, it soon became clear that text alone was only part of the deal. The real fun in ElasticSearch begins when you add structured data into it, allowing filtering, grouping, and get all businessy with pie charts and world maps and whatnot. This would be where you'd start to gain knowledge that wouldn't be available anywhere in text-based logfiles.
(Graphics credit to Leonardo Maia.)