This talk presents the Dancer web framework beginning with “Hello World” and progressing through a couple of easy to digest introductory applications. All of the primary Dancer features are presented including URL routing, writing handlers, and output templating. A selection of useful and common Dancer plugins will also be covered. This talk is best suited for beginning and intermediate Perl programmers.

(via JT Smith, in turn via the YAPC::NA blog.)

I hope it’s recorded, as I’d like to see it, but won’t be able to afford to attend YAPC::NA.

• Dancer Advent Calendar – the Dancer web framework’s calendar (feed)
• Perl Advent Calendar (perladvent.org) (feed)
• Catalyst Advent Calendar – the Catalyst web framework’s calendar (feed)
• Perl6 Advent Calendar (feed)
• SysAdvent – an advent calendar for sysadmins, but often Perl-related

There are also several Japanese-language advent calendars:

• http://perl-users.jp/articles/advent-calendar/2011/:
  • AnySan Track
  • Casual Track
  • dbix Track
  • English Track
  • Hacker Track
  • Test Track
  • Acme Track
  • Teng Track
  • Amon2 Track

If you know of any others, please feel free to let me know and I’ll add them to the list :)

I had a good day, met a few members of the Perl community I knew from online interactions who I’d never met in person before, saw some good talks, and partook in some free food and beer (kindly paid for by the sponsors, including my employer, UK2).

Some brief mentions of talks I attended:

Matt S Trout (mst) – First, Tak wrote the world‎

I have IO::Pipeline. I have App::FatPacker. I have IPC::Command::Multiplex. And yet I still couldn’t whip up a five line example of bolting them all together that made a compelling argument for a perl-loving sysadmin to stop using fabric.

This problem, among others, will be solved by the conclusion of this talk.

Tak sounds like something which will be very useful to me – running code on multiple other hosts via SSH, but including Perl code – with all locally-installed modules available for use at the remote end!

As mst went through explaining how it all worked, my thoughts went from “hmm, useful”, to “hmm, useful but looks over-engineered, not sure it needs to be that complex” to “whoah, that’s genius”. Fatpacking and sending code to the remote side, which then adds a coderef to @INC which requests other modules from the local end, sent over and loaded remotely, is awesomely creative.

These kind of tricks remind me of why I love Perl.

Mike Whitaker (‎Penfold‎) – ‎Perl and Unicode, the 5.14 edition‎

A very good talk on handling Unicode safely in Perl, and the gotchas to avoid. Provided major impetus for me to upgrade to 5.14, too.

Zefram – ‎why time is difficult‎

Dates, times, time intervals, clocks, calendars, and related phenomena are major contributors to hassle in programming, and the source of innumerable bugs.

Zefram’s talk, whilst barely Perl related, was very interesting, and very well delivered. I hadn’t realised quite how complex time was :)

Zefram’s amusing lightning talk on doing away with source code by simply storing bytecode and editing it by deparsing the source, editing it, then “compiling” back to bytecode was also entertaining.

Claes Jakobsson (‎claes‎) – ‎Don’t debug now, debug later

Runops::Recorder is a alternate runloop for perl that writes down what your program does to disk for playback later

It also comes with a viewer and some helper classes for you to write your own playback tools such as diffs etc.

This looks like a very useful debugging tool, recording the path of execution through your code and writing it to a file which can then later be “replayed” using a viewer – much like single-stepping or tracing through the debugger, but after the fact. The ability to leave it running and have it dump out a configurable amount of trace data when a die is encountered looks excellently useful for catching intermittent / rare problems – you should be able to leave it in place, wait until the problem occurs, then replay what happened leading up to the die to see what was going on.

Future versions should also be able to track changes to variables, etc, which will be very useful indeed.

There were a couple of workshops I’d like to have attended, but which I didn’t; partly because they conflicted with talks I wanted to see, and partly because I didn’t have a laptop with me to “work along” and didn’t think I could take much of value away from them.

Andrew Solomon – ‎[[TRAINING SESSION]] Web development for beginners using Dancer‎

As a core developer for the Dancer perl web framework I’d love to have attended Andrew Solomon’s workshop, to see what was being taught, and offer any input desired. Unfortunately, I wasn’t there, but I’ll be looking with interest for any feedback from people who were, and what they learned and what they thought of Dancer if they hadn’t encountered it before. Making Perl accessible for new users is an important thing.

Gabor Szabo (‎szabgab‎) – ‎[[TRAINING SESSION]] Testing in Perl

I’d also like to have taken part in Gabor’s workshops, but they were in two parts and conflicted with several other talks I wanted to see.

I met a few members of the Perl community who I knew from online interactions but had never met in meatspace, so it was great to meet them. Unfortunately, there were a few others I’d meant to go introduce myself to, but never got a chance to do so – including Tatsuhiko Miyagawa and Gabor Szgabo.

Overall, it was a good day, and I imagine there’s a very good chance I’ll be back next year :)

Overall, I think it was a good talk, and raised some good points, even if the “you don’t always have to write tests, write them only if they provide value” is a little controversial with some of the audience, leading to a reasonable amount of debate and running late with the talk so having to skip some slides.

Personally, I agree to some degree – I think some people write tests simply to push up their test coverage figure, without really writing tests which are likely to catch bugs (exercising the code in both expected and unexpected ways, providing strange input and edge cases (does it blow up if given undef or a ref, say).

However, I do think a fair amount of the talk is summed up by advice given to me by a boss at work, Ditlev, with regards to getting stuff out – sometimes you have to “launch crap but launch” – sometimes code that works well enough to be put into use and making money for you can be more valuable than taking longer to produce better quality code – which may be nicer and better to work with in the future, but isn’t ready to launch now. In other words, examining the trade-off between quick results now, and better quality code which becomes more valuable later – but “what if later never comes?”.

The impression I took away from the talk, which might be a misconception, is that Booking.com don’t do code reviews or refactoring, which would seriously put me off applying for a position there – I think code review in particular (even if just casual – it needn’t be a formal procedure) is very valuable to push yourself to be a better coder. If you know other members of the team are going to be glancing over your commits when they have time and pointing at bits you could have done better, that’s a good motivation to write good code, and also often helps you realise other ways you could have done things.

I’d be interested in seeing the other slides which abigail had to skip over, but I haven’t been able to find them anywhere online.

Modules I considered were:

• Chart::Strip
• Chart::Graph
• Google::Chart
• Chart::Clicker
• Chart::Gnuplot

Unfortunately, I didn’t have time to do a full in-depth writeup trying every module like the excellent ones Neil Bowers has been doing, but I thought I’d write up a quick post on the choice I made, with example code, in case it helps other people looking to graph potentially irregularly-spaced time-based data samples in Perl easily.

Chart::Clicker looked to be a nice choice (with a nice example of doing just what I want given as the topic answer to a question on StackOverflow), but had a huge chain of dependencies, finally failing when demanding Cairo and various X11 libraries (on my headless server).

Chart::Strip seemed to do exactly what I wanted in a simple way, but I encountered a div-by-zero bug when dealing with a certain dataset with > 89 data points.

I reported this to the author, Jeff Weisgberg in RT #72288, and he promptly released 1.08 with a fix (thanks Jeff!).

Chart::Strip made it simple to do what I wanted:

my @dataset;
while (my $row = $sth->fetchrow_hashref) {
    push @dataset, { time => $row->{timestamp}, value => $row->{value} };
}
 
my $chart = Chart::Strip->new( title => "My chart" );
$chart->add_data(\@dataset, { style => 'line' });
 
# then get the chart as an image with $chart->png

Nice and easy, just what I wanted – a way to say “here’s some timestamps and values (quite possibly irregularly spaced) – work out how to plot this sensibly for me”.

The resulting graphs look good enough to me, e.g.:





(Rendered intentionally a little smaller to fit the blog; naturally the graphs can be whatever size you want. Also, I had to use the transparent option to disable transparent backgrounds.)

]]> http://www.preshweb.co.uk/2011/11/graphing-time-based-data-in-perl/feed/ 6 http://www.preshweb.co.uk/2011/10/why-irc-is-a-valuable-tool-to-your-development-team/ http://www.preshweb.co.uk/2011/10/why-irc-is-a-valuable-tool-to-your-development-team/#comments Mon, 17 Oct 2011 08:55:15 +0000 bigpresh http://www.preshweb.co.uk/?p=1021 IRC (Internet Relay Chat) is a protocol for multi-server text chat between many participants in many channels, started back in 1988.

There are plenty of IRC networks out there for social chatter, including the likes of Freenode and irc.perl.org hosting many channels for Perl and open source channels in general, making it easy to get quick help from developers and users of your favourite project.

However, I find IRC to be a very valuable tool indeed to help development teams collaborate effectively; at work we make extensive use of it. It’s useful whether you’re a formal development team in a corporate environment, or an open source project whose developers / collaborators gather on IRC.

Why is it so useful? Well:

It enables quick discussion and collaboration without breaking your workflow

As a developer, you don’t want to lose your concentration – when you’re “in the zone”, you’re carrying information about the code you’re working on in your brain, and it doesn’t stay there for long if you’re distracted. Someone walking over to you and starting talking to you, or a phone call, demand more or less 100% attention; you will be distracted, and you will “fall out of the zone”, causing your productivity to fall until you get back to where you were.

IRC, on the other hand, means you don’t have to respond quite so immediately, and I find it easy to flick between coding and IRC (both terminals within Terminator for me) without losing focus on where I’m up to and what I’m doing.

Most IRC clients support alerting you when your nick is mentioned in a channel or you receive a direct message, so you can ignore general chatter in the channel until you’re ready to read it, but know if someone is trying to get your attention.

Of course, it’s even more valuable when your development team work from multiple locations, whether that’s having employees working from home, or multiple offices.

Logs of discussions can be valuable for future reference

If you keep logs of your discussions, it’s easy to refer back to later – sometimes you’ll remember “ah, yes, we talked about this – what was the outcome?” – quick log search, and your answer is there. “Why did we decide that this was the best way to implement this?” – log search – “ah, that was why”.

Open, widely-supported protocol

IRC is an open, widely supported protocol; there’s various clients available for pretty much every platform, so whatever system your devs work on, they’ll be able to find a client that suits them.

Easily extensible to integrate with other tools

It’s easy to write IRC “bots” which can help integrate with various other tools in various ways.

A good example is providing easy links to commits / bug reports or issues / pull requests etc.

If you’re using my Bot::BasicBot::Pluggable::Module::GitHub for instance, you can mention an issue and have the bot automatically provide a summary and an URL for anyone who wants to see what the issue in question is – e.g.:

<user1> Anyone had a moment to look at Issue 42 and see what's going on?
<bot> Issue 42 (It doesn't work) https://github.com/....
<user2> Oh yeah - I fixed that in 5fcbb01
<bot> Commit 5fcbb01 (Retarded logic fail.) - https://github.com/....

It’s easy to cobble together a simple bot or bot module to do this kind of stuff for whatever your in-house situation requires, if there’s nothing suitable already out there on CPAN (which, a lot of the time, there already will be).

GitHub provide post-receive hooks which can be configured to announce pushes to your IRC channel(s). Bot::BasicBot::Pluggable::GitHub::Announce can automatically announce new/updated issues, and, in future releases, also pull requests and commits/pushes.

System problems reported instantly

Use something like my Bot::BasicBot::Pluggable::Module::Nagios, and you can have system problems reported automatically to the appropriate IRC channels, for quick attention by whoever needs to deal with them. I use an applet in my GNOME system tray which alerts me to problems, but seeing them reported in detail on IRC is handy, and also strikes up conversation about it – a simple “I’m on it ^^” is enough to let others know you’re dealing with the issue and they don’t need to worry about it.

Announce tweets about your company/brand/project/interests

My Bot::BasicBot::Pluggable::Module::TwitterWatch module allows you to have the bot watch for and report new posts on Twitter about your company/project/brand/stuff of interest, and post them to your IRC channel – either for awareness, or to strike up discussion about them.

Wrap various other tools

Your IRC bot(s) can provide various other useful facilities – for instance, find the corelist command useful? Bot::BasicBot::Pluggable::Module::CoreList makes it easy for your bot to answer corelist lookups within the flow of a conversation.

<user1> Could use File::Spec - that's part of core, isn't it?
<user2> bot: corelist File::Spec
<bot> File::Spec was first released with perl 5.00503 (released on 1999-03-28)
<user2> Yep :)

]]> http://www.preshweb.co.uk/2011/10/why-irc-is-a-valuable-tool-to-your-development-team/feed/ 1 http://www.preshweb.co.uk/2011/10/botbasicbotpluggablemodulenagios-released/ http://www.preshweb.co.uk/2011/10/botbasicbotpluggablemodulenagios-released/#comments Sat, 15 Oct 2011 15:03:09 +0000 bigpresh http://www.preshweb.co.uk/?p=1019 I’ve just released Bot::BasicBot::Pluggable::Module::Nagios – a module for IRC bots powered by Bot::BasicBot::Pluggable which monitors one or more Nagios instances and reports problems to IRC channels.

I’ll be using this at work to have service problems reported to us on IRC for quick attention, but figured it’s something that’s likely to be of use to others elsewhere, too, so I’m releasing it.

There’s still some more features and improvements I want to make (a TODO list is included in the module POD), but it’s at a state where I consider it to be usable (it works for me).

Feedback/suggestions welcome.

It should be on a CPAN mirror near you soon, and the repo is on GitHub should you wish to submit pull requests or raise issues for bug reports/feature requests.

]]> http://www.preshweb.co.uk/2011/10/botbasicbotpluggablemodulenagios-released/feed/ 0 http://www.preshweb.co.uk/2011/10/botbasicbotpluggablemodulegithub-released/ http://www.preshweb.co.uk/2011/10/botbasicbotpluggablemodulegithub-released/#comments Thu, 06 Oct 2011 17:21:34 +0000 bigpresh http://www.preshweb.co.uk/?p=1009 I’ve released a new distribution for Bot::BasicBot::Pluggable powered IRC bots, providing some useful GitHub-related functionality, named Bot::BasicBot::Pluggable::Module::GitHub.

The following modules are included – see the documentation for each for more details on how to use them.

Bot::BasicBot::Pluggable::Module::GitHub::EasyLinks

Provides quick URLs to view issues/pull requests etc when someone mentions one – for example:

<user> Go have a look at Issue 42
<bot1> Issue 42 (It doesn't work) https://github.com/....
<user> I fixed that in 5fcbb01
<bot1> Commit 5fcbb01 (Retarded logic fail.) - https://github.com/....

You can set a default project per-channel, so the above examples will look at whatever project is set as default for the channel the message was in.

You can also explicitly tell it to look at any other GitHub project:

<user> 5fcbb01 @ bigpresh/Bot-BasicBot-Pluggable-Module-GitHub
<bot1> Commit 5fcbb01 (Retarded logic fail.) - https://github.com/...

Bot::BasicBot::Pluggable::Module::GitHub::PullRequests

Monitor pull requests for GitHub projects.

Example:

<@bigpresh> !pr
< sophie> Open pull requests for sukria/Dancer : 8 pull requests open (felixdo:3, perlpilot:1, jamhed:1, dams:1, ambs:1, JTimothyKing:1)

Bot::BasicBot::Pluggable::Module::GitHub::Announce

Announces issues raised/closed for each channel’s default project.

Periodically checks on issues for each project, and reports changes,
for example:

< sophie> Issues closed : 667 (YAML::XS for Session::YAML) by jamhed : https://github.com/sukria/Dancer/issues/667

The code is on CPAN, and is available on GitHub. Contributions / bug reports / suggestions encouraged.

]]> http://www.preshweb.co.uk/2011/10/botbasicbotpluggablemodulegithub-released/feed/ 0 http://www.preshweb.co.uk/2011/08/dancer-1-3080-released/ http://www.preshweb.co.uk/2011/08/dancer-1-3080-released/#comments Tue, 23 Aug 2011 15:22:09 +0000 bigpresh http://www.preshweb.co.uk/?p=977 Version 1.30801.3072 of the Dancer Perl web framework was released today.

It was codenamed the "Precious David Precious" release after me – thanks guys :)

The changes included are:


    [ BUG FIXES ]
    * Fix prefix behavior with load_app (alexrj)
    * send_file() shouldn't clobber previously-set response status
      (David Precious, reported by tylerdu - thanks!)
    * Depend on URI 1.59 - Fixes problems when redirecting with
      UTF-8 strings (Alberto Simões)
    * Fix before_serializer POD fix (Yanick Champoux)

    [ ENHANCEMENTS ]
    * send_file can send data (pass a reference to a scalar), and can
      specify a content-disposition filename. (Alberto Simões)
    * Set 'Server' HTTP response header as well as 'X-Powered-By'.  For cases
      where Dancer is being accessed directly, or the proxy passes on this
      header, it's nice to see it.  (David Precious)

    [ DOCUMENTATION ]
    * Cookbook links to canonical documentation of keywords in Dancer.pm, so
      readers encountering a new keyword can easily see the docs for it
      (David Precious)
    * Docs for debug/warning/error link to Dancer::Logger for details on how to
      control where logs go (David Precious)
    * Document import_warnings option, and mention it & link to that
      documentation in opportune places.
    * Document that 'get' also creates a route for 'HEAD' requests
      (David Precious, prompted by Matt S Trout)
    * Extend request() keyword docs with examples (David Precious)
    * Correct port in Lighty/FCGI example in Dancer::Deployment
      (David Precious, thanks to pwfraley in Issue 621)

EDIT: I stupidly typed 1.3080, not 1.3072. 1.3080 is to be released fairly soon, and will contain some sweet new features. 1.3072 is the release which came out today, and contains slightly less impressive features :)

]]> http://www.preshweb.co.uk/2011/08/dancer-1-3080-released/feed/ 0 http://www.preshweb.co.uk/2011/08/using-p3rl-org-for-ff-search-keyword/ http://www.preshweb.co.uk/2011/08/using-p3rl-org-for-ff-search-keyword/#comments Fri, 19 Aug 2011 21:33:17 +0000 bigpresh http://www.preshweb.co.uk/?p=973 The lazy side of me enjoys Quick Search bookmarks in Firefox, so that I can type e.g. cpan ModuleName to look up a module on CPAN etc, pd perlfoo to look up the imaginary perlfoo documentation on perldoc, etc.

I also like p3rl.org‘s intelligent handling of short URLs, e.g. http://p3rl.org/Dancer, http://p3rl.org/perlrun etc.

It suddenly occurred to me to create a keyword search with the keyword p3, and the URL as http://p3rl.org/%s – now I can jump straight to pages I want with e.g. p3 Dancer, p3 perlrun etc.

My laziness likes this very much indeed.

]]> http://www.preshweb.co.uk/2011/08/using-p3rl-org-for-ff-search-keyword/feed/ 0 http://www.preshweb.co.uk/2011/08/happy-birthday-dancer/ http://www.preshweb.co.uk/2011/08/happy-birthday-dancer/#comments Sun, 07 Aug 2011 10:28:33 +0000 bigpresh http://www.preshweb.co.uk/?p=967 Today marks two years to the day since the first version of Dancer hit CPAN!

According to the BackPAN, Dancer-0.9003.tar.gz hit CPAN on 07-Aug-2009.

I think you’ll agree we’ve come a long way since then, thanks to the awesome community and user base built up around the project since then.

In these two years, we’ve had countless valuable contributions from a large list of contributing users (see the list on the about page), gathered over 300 watchers on GitHub, had 84 people fork the repository on GitHub, had 620 pull requests submitted… amazing stuff.

We’ve seen a wide range of awesome Dancer plugins appear on CPAN (see Dancer::Plugins, or search on CPAN for “Dancer::Plugin::”).

We’ve seen Dancer presented at various conferences including FOSDEM, OSDC.fr, the French Perl Workshop, the Bulgaria Perl Workshop, PyWeb IL (an Israeli Python group).

We’ve seen screencasts on using Dancer (thanks Gabor!), we’ve seen Dancer discussed plenty within the Perl community with plenty of helpful suggestions.

Unfortunately, we’ve also seen some trolling from someone who, for reasons unknown, seems to take a strong dislike to the project – puzzling.

As a result of some of the trolling which included fake reviews falsely attributed to members of the Sinatra team, we’ve seen our initial inspiration, Ruby’s Sinatra project, release a statement proclaiming that “Sinatra Loves Dancer”.

So, to celebrate Dancer’s 2nd birthday, I think a little marketing effort would be good – I’d like to invite you all to let the world know what yout think! Do you use Dancer? Do you like it? Let people know – blog about it, tweet about it, leave positive reviews & ratings on cpanratings or +1′s on MetaCPAN – however you like.

(If you leave reviews/+1′s, feel free to also do so for any Dancer plugins you find helpful, too – they need the love too! :) )

Also, if you don’t already, please “watch” the Dancer project on GitHub – just go to the project page and click the “Watch” button near the top.

Pithy quotes on what you like about Dancer suitable for inclusion on www.perldancer.org/testimonials would be very welcome, too :)

Also, we’ve come a long way, but we have a long way to go, too – we have some great improvements to Dancer planned, but suggestions for new features would be very welcome – it’s always good to know what users would like to see!

So, happy birthday Dancer, and happy dancing, community!

And, of course, an invitation – if you’re interested in Dancer, but aren’t already part of the vibrant welcoming community in the #dancer IRC channel on irc.perl.org, feel free to join us – see http://www.perldancer.org/irc for a web chat client if you don’t use IRC normally.

Cheers

Dave P

]]> http://www.preshweb.co.uk/2011/08/happy-birthday-dancer/feed/ 1 http://www.preshweb.co.uk/2011/07/renaming-mp3s-based-on-id3-tags-with-perl/ http://www.preshweb.co.uk/2011/07/renaming-mp3s-based-on-id3-tags-with-perl/#comments Wed, 27 Jul 2011 20:00:33 +0000 bigpresh http://www.preshweb.co.uk/?p=958 As mentioned in my previous post on retagging MP3s by filename, I have a fairly large music collection, and prefer to keep it well organised.

I like the filenames used to always follow the same pattern, so I wrote mp3-rename, a Perl script to rename them based on the filename.

It takes a directory name as an argument (if not provided, it will operate upon the current directory). It will find all the MP3 files within that directory, extract information from the ID3 tags, then display a table showing the renames it will make if you tell it to go ahead, then ask for confirmation.

An example in action:

[davidp@supernova:~]$ mp3-rename /[...]/Rob\ Costlow\ -\ Woods\ of\ Chaos/
The following renames will be performed:
01 - Meant to Be.mp3    -> 00 - Meant to Be - Rob Costlow.mp3
02 - Reflections.mp3    -> 00 - Reflections - Rob Costlow.mp3
03 - Semester Days.mp3  -> 00 - Semester Days - Rob Costlow.mp3
[...]

Review the above renames to check the info is correct.

Type 'yes' to go ahead: ?>

(Some lines omitted for brevity)

It uses CPAN modules to do most of the work, including File::Find::Rule to find matching files to work on, Music::Tag to handle the tag processing, and Term::ReadKey to find out the terminal size.

]]> http://www.preshweb.co.uk/2011/07/renaming-mp3s-based-on-id3-tags-with-perl/feed/ 0 http://www.preshweb.co.uk/2011/07/retagging-mp3s-by-filename-with-perl/ http://www.preshweb.co.uk/2011/07/retagging-mp3s-by-filename-with-perl/#comments Mon, 25 Jul 2011 20:09:10 +0000 bigpresh http://www.preshweb.co.uk/?p=954 I have a fairly large music collection in MP3s, and I like my files to be sensibly named and tagged.

One of the tools I use to do that is a Perl script I wrote named retag-by-filename, which allows you to provide a regular expression with named captures (so requires Perl 5.10 or later), and uses that to retag a bunch of MP3 files.

An example of it in use:

[davidp@supernova:~]$ ls -1 /shared/music/Complete\ Albums/Oasis\ -\ The\ Masterplan/ | head -3
01 - Acquiesce - Oasis.mp3
02 - Underneath The Sky - Oasis.mp3
03 - Talk Tonight - Oasis.mp3

[davidp@supernova:~]$ ./retag-by-filename --dry-run \
  --pattern="(?<track> \d+) \s - \s (?<title> .+ ) \s - \s (?<artist> .+ ) \.mp3" \
  /shared/music/Complete\ Albums/Oasis\ -\ The\ Masterplan/*.mp3
[01] Acquiesce by Oasis ()
[02] Underneath The Sky by Oasis ()
[03] Talk Tonight by Oasis ()

The --dry-run option shows the details of each track, but doesn’t actually update the tags. The --pattern option supplies the regular expression to match against filenames; you’ll use named captures named track, title, artist and comment to capture the appropriate parts. (In the example above, there is no comment to match.)

Thanks to the awesome power afforded by using modules from CPAN (Music::Tag and Getopt::Lucid), the actual script is 37 lines of code.

]]> http://www.preshweb.co.uk/2011/07/retagging-mp3s-by-filename-with-perl/feed/ 1 http://www.preshweb.co.uk/2011/07/backing-up-google-contactscalendar-etc/ http://www.preshweb.co.uk/2011/07/backing-up-google-contactscalendar-etc/#comments Sat, 23 Jul 2011 12:59:51 +0000 bigpresh http://www.preshweb.co.uk/?p=946 I recently followed a discussion on Twitter after @thomasmonopoly‘s Google account was blocked for unknown reasons, denying him access to the data he’d entrusted Google with.

I casually mentioned that entrusting Google to store all your data without having backups yourself is a bad idea, and @jmrowland enquired as to how you can back up stuff you create “in the cloud” (using Google).

I figured I should share the Perl script I’m currently using to back up my Google contacts, calendar and Google Reader subscriptions, so I’ve uploadedbackup-google-stuff on GitHub.

As I only wrote the script for my own use it’s quite basic and perhaps not particularly user-friendly, but I thought it only fair to share it; if people are interested in it, I may extend it somewhat. I’m fairly sure there are other “backup your Google account” solutions already out there already, though.

Of course, backing up mail from Gmail is trivial as they offer IMAP access; I don’t rely on Gmail so I’ve not bothered with that myself.

EDIT: I’ve seen Backupify recommended as a good solution for backing up your stuff from Google.

]]> http://www.preshweb.co.uk/2011/07/backing-up-google-contactscalendar-etc/feed/ 6 http://www.preshweb.co.uk/2011/07/easy-profiling-for-dancer-apps/ http://www.preshweb.co.uk/2011/07/easy-profiling-for-dancer-apps/#comments Sat, 23 Jul 2011 12:32:14 +0000 bigpresh http://www.preshweb.co.uk/?p=941 Today I released Dancer::Plugin::NYTProf, which provides easy profiling for Dancer apps, powered by the venerable Devel::NYTProf.

Using it is simple – load the plugin in your app:

use Dancer::Plugin::NYTProf;

Then, use your app as normal, then, to view the profile data, point your browser to /nytprof (e.g. http://localhost:3000/nytprof, and you’ll get a list of profile runs (each request is profiled individually):



Select the profile run you wish to view, and nytprofhtml will be invoked behind the scenes to generate the HTML reports, which will then be served up, and you’ll be looking at the helpful Devel::NYTProf reports, to see where time was spent processing your request:



Early days yet, and a lot of room for improvement, but in my testing, it works.

Things I’d like to add when time permits:

• The ability to exclude Dancer internals from the profiling (if I can find a clean way to do so)
• The ability to enable profiling only for certain requests – for instance, providing a pattern to match the request URLs you want to profile
• The ability to customise the URL at which profiling reports are served up
• Check for sane behaviour if prefixes are in use

Feedback welcome!

]]> http://www.preshweb.co.uk/2011/07/easy-profiling-for-dancer-apps/feed/ 2 http://www.preshweb.co.uk/2011/07/writing-a-bugzilla-extension-to-auto-link-commits/ http://www.preshweb.co.uk/2011/07/writing-a-bugzilla-extension-to-auto-link-commits/#comments Tue, 05 Jul 2011 09:49:59 +0000 bigpresh http://www.preshweb.co.uk/?p=931 I’ve been meaning to write a Bugzilla extension to turn mentions of commits in bug messages into a link to view the commit via our web-based SVN viewer for ages – this morning I finally found the time to do it.

I needed to use the bug_format_comment hook to format comments as they’re being displayed, turning mentions of commits (e.g. “Commit 123″ or “r123″) into links.

The code was pretty simple:


The following is in /var/lib/bugzilla3/extensions/LinkCommits/Extension.pm:

package Bugzilla::Extension::LinkCommits;
use strict;
use base qw(Bugzilla::Extension);

use constant NAME => 'LinkCommits';

our $VERSION = '0.1';

sub bug_format_comment {
    my ($self, $args) = @_;

    my $regexes = $args->{'regexes'};

    my $commit_match = qr/\b( (?:Commit|r) \s? (\d+) )/x;
    push(@$regexes, { match => $commit_match, replace => \&_link_commit });
}

sub _link_commit {
    my $args = shift;
    my $text      = $args->{matches}->[0];
    my $commitnum = $args->{matches}->[1];

    my $url = "http://warehouse.uk2.net/repolist/?diff=uk2&rev="
        . join ':', $commitnum - 1, $commitnum;
    return qq{$text};
};

# This must be the last line of your extension.
__PACKAGE__->NAME;

And that is about it. Hopefully this might be of use to someone. Bugzilla comes with a comprehensive Example extension which illustrates this along with various other hooks, but I suspect I’m not the only one looking to create a simple plugin to make tweaks to bug comments when displaying (like auto-linking to commits), so this might help someone.

]]> http://www.preshweb.co.uk/2011/07/writing-a-bugzilla-extension-to-auto-link-commits/feed/ 0 http://www.preshweb.co.uk/2011/07/secure-password-handling-in-dancer-apps-with-bcrypt/ http://www.preshweb.co.uk/2011/07/secure-password-handling-in-dancer-apps-with-bcrypt/#comments Mon, 04 Jul 2011 12:02:33 +0000 bigpresh http://www.preshweb.co.uk/?p=926 James Aitken has released Dancer::Plugin::Bcrypt, a new plugin for Dancer apps to make secure password hashing using Bcrypt easy.

For a background on why you ought to use Bcrypt rather than simpler hashing, see http://codahale.com/how-to-safely-store-a-password/ – basically, using MD5/SHA etc is too inexpensive, meaning that, even with a good salt, cracking the hash isn’t too hard to do these days, especially with the advent of use of the GPU. Bcrypt is intentionally expensive and slow (you can decide just how much).

Dancer::Plugin::Bcrypt makes validating a password hash as easy as:

if (bcrypt_validate_password($entered_password, $stored_hash)) {
    ...
}

Generating a hash to store is also very simple:

my $hash = bcrypt($plaintext);

Generation of random salt is taken care of for you.

*UPDATE* – the above is a nice simple way to quickly get secure password hashing with minimal effort – it is likely not the best way, though. If you’re already using DBIx::Class, then see DBIx::Class::PassphraseColumn for a better way to do this automatically at your database model level.

Thanks to mst for prompting me to mention the above :)

]]> http://www.preshweb.co.uk/2011/07/secure-password-handling-in-dancer-apps-with-bcrypt/feed/ 0 http://www.preshweb.co.uk/2011/06/wordpress-plugin-for-easy-cpan-module-links/ http://www.preshweb.co.uk/2011/06/wordpress-plugin-for-easy-cpan-module-links/#comments Sun, 05 Jun 2011 15:48:42 +0000 bigpresh http://www.preshweb.co.uk/?p=903 Just installed the CPAN Auto Link Generator WordPress plugin, which automatically matches module names and provides links to the module’s documentation on CPAN. Very helpful for anyone blogging about Perl, so thought I’d give it a link here.
]]> http://www.preshweb.co.uk/2011/06/wordpress-plugin-for-easy-cpan-module-links/feed/ 4 http://www.preshweb.co.uk/2011/06/dancerpluginsimplecrud-0-10-released/ http://www.preshweb.co.uk/2011/06/dancerpluginsimplecrud-0-10-released/#comments Sun, 05 Jun 2011 15:44:25 +0000 bigpresh http://www.preshweb.co.uk/?p=901 I’ve just released version 0.10 of Dancer::Plugin::SimpleCRUD, incorporating a new display_columns option to control which columns should be visible when listing records, kindly provided by saberworks in PR-9. Also included is a documentation fix for the editable_columns option, and implementing the not_editable_columns option, courtesy of Alberto Simões (ambs) – thanks!
]]> http://www.preshweb.co.uk/2011/06/dancerpluginsimplecrud-0-10-released/feed/ 0 http://www.preshweb.co.uk/2011/05/htmltablefromdatabase-1-00-released-with-row_callbacks-feature/ http://www.preshweb.co.uk/2011/05/htmltablefromdatabase-1-00-released-with-row_callbacks-feature/#comments Tue, 24 May 2011 23:26:49 +0000 bigpresh http://www.preshweb.co.uk/?p=878 I just released version 1.00 of HTML::Table::FromDatabase, with a new row_callbacks feature.

You could already declare callbacks on a cell-level basis, so you could say, format monetary values appropriately, round numeric columns, turn URLs into clickable links etc. Now, you can also declare a callback which receives an entire row as a hashref, which it can modify as needed.

An (admittedly somewhat contrived) example from the documentation:

my $table = HTML::Table::FromDatabase->new(
    -sth => $sth,
    -row_callbacks => [
        sub {
            my $row = shift;                                                                                 
            if ($row->{name} eq 'Bob') {
                # Hide this row
                $row = undef;
            } elsif ($row->{name} eq 'John') {
                # John likes to be called Jean these days:
                $row->{name} = 'Jean';
            }
        },   
    ],       
);

I decided to bump the version to 1.00 for the sake of anyone who considers 0.x versions to be unready for production use; this module has been about since 2008 and is working well in production use for me.

]]> http://www.preshweb.co.uk/2011/05/htmltablefromdatabase-1-00-released-with-row_callbacks-feature/feed/ 0 http://www.preshweb.co.uk/2011/05/the-dancer-release-that-will-get-you-hooked/ http://www.preshweb.co.uk/2011/05/the-dancer-release-that-will-get-you-hooked/#comments Tue, 24 May 2011 13:57:10 +0000 bigpresh http://www.preshweb.co.uk/?p=872

Sawyer X wrote up a good post on version 1.3050 of the Dancer Perl web framework being released – "The Dancer release that will get you hooked!".

The addition of extra hooks, along with support for plugins to create hooks, heralds additional flexibility and power for your Dancer apps.

Dancer itself now provides various new hooks you can use to customise its behaviour, including before_deserializer, before_file_render, before_error_render, before_template_render, before_layout_render, before_serialization
- see the Dancer::hook() documentation for the full list. Plugins can register their own hooks, which your code can then make use of.

Props go to Franck Cuny for the implementation, and JT Smith of Plain Black for pushing for this feature and working with the Dancer team in designing the implementation.

Dancer 1.3050 also includes various bug fixes and improvements – see the CHANGES file for a full list.

]]> http://www.preshweb.co.uk/2011/05/the-dancer-release-that-will-get-you-hooked/feed/ 0 http://www.preshweb.co.uk/2011/05/dancerplugindatabasetimerequests/ http://www.preshweb.co.uk/2011/05/dancerplugindatabasetimerequests/#comments Mon, 23 May 2011 23:10:12 +0000 bigpresh http://www.preshweb.co.uk/?p=870 Today I knocked up a quick plugin for the Dancer Perl web framework to log the time taken by requests to help look for bottlenecks – enter Dancer::Plugin::TimeRequests.

At the moment it’s very simple, and simply logs the time taken to execute every request; in the future, I may extend it to support capturing statistics and adding a route handler to display stats (e.g. average request time, which routes take the longest to execute, etc.)

Suggestions / patches welcome – the code is on GitHub as usual.

]]> http://www.preshweb.co.uk/2011/05/dancerplugindatabasetimerequests/feed/ 1 http://www.preshweb.co.uk/2011/05/bot-basicbot-pluggable-module-github/ http://www.preshweb.co.uk/2011/05/bot-basicbot-pluggable-module-github/#comments Tue, 10 May 2011 19:40:47 +0000 bigpresh http://www.preshweb.co.uk/?p=839 We have an IRC bot in the #dancer IRC channel powered by Bot::BasicBot::Pluggable, and I recently wrote some new features as a distribution of modules which I plan to release to CPAN soon.

Until then, you can see the code in the Bot::BasicBot::Pluggable::Module::GitHub repository on GitHub.

There are two modules so far:

EasyLinks

Bot::BasicBot::Pluggable::Module::GitHub::EasyLinks recognises certain elements within discussions on IRC and provides responses containing titles/URLs to see the corresponding entity, for instance:

<someuser> I'm just working on Issue 42 now
<bot> Issue 42 (Issue Title - Issues - sukria/Dancer - GitHub) - https://github.com/user/project/issues/42

<someuser> I've just submitted PR 517, anyone want to merge it?
<bot> Pull request 517 (Pull request title - Pull Request - GitHub) - https://github.com/user/project/pull/517

<someuser> What do you think of commit 0d2752 then?
<bot> Commit 0d2752 (Commit message summary here) - https://github.com/user/project/commit/0d2752...

PullRequests

Responds to a !pr command, reporting the number of open pull requests, either for whatever project is specified as the default for that channel, or a specific project can be named. For instance:

<someuser> !pr user/project
<bot> Open pull requests for user/project : 5 pull requests open (usera:3, userb:2)

I plan to add more features before releasing the first version to CPAN; in particular, I’d like to add commit hook support, so the module could spawn a trivial webserver to listen for hook triggers from GitHub, and announce commits.

As always, contributions would be welcomed.

]]> http://www.preshweb.co.uk/2011/05/bot-basicbot-pluggable-module-github/feed/ 0 http://www.preshweb.co.uk/2011/05/welcoming-ambs-to-the-dancer-core-dev-team/ http://www.preshweb.co.uk/2011/05/welcoming-ambs-to-the-dancer-core-dev-team/#comments Tue, 10 May 2011 08:38:26 +0000 bigpresh http://www.preshweb.co.uk/?p=836 Alberto Simões (ambs) has been a helpful contributor to the Perl Dancer web framework for some time now, submitting a lot of helpful pull requests and being a valued member of the community providing ideas and support to new users.

I’m very happy to note that ambs is now a member of the Dancer core developers team – great to see all that hard work recognised (well, Dancer 1.3030 was released with codename “Silence of the ambs” as recognition too :) )

Welcome aboard, ambs!

]]> http://www.preshweb.co.uk/2011/05/welcoming-ambs-to-the-dancer-core-dev-team/feed/ 1 http://www.preshweb.co.uk/2011/05/dancer-plugins-simplecrud-0-03-and-database-1-24/ http://www.preshweb.co.uk/2011/05/dancer-plugins-simplecrud-0-03-and-database-1-24/#comments Mon, 09 May 2011 22:33:17 +0000 bigpresh http://www.preshweb.co.uk/?p=831 A busy evening’s hacking on Dancer plugins tonight. I’ve released Dancer::Plugin::SimpleCRUD 0.03, which incorporates a new search feature kindly contributed by Alberto Simões which I’ve been meaning to release for a while, along with removing the dependency on SQL::Abstract in favour of the convenience methods provided by Dancer::Plugin::Database, which will make D::P::SimpleCRUD work correctly with PostgreSQL databases too – thanks to Jonathan Barber for reporting this issue in RT #68040.

(I should point out that the problem was not with SQL::Abstract, but with D::P::SimpleCRUD setting the quote_char param to a backtick, which is good for MySQL and SQLite, but not so much for PostgreSQL. The code in D::P::Database uses the quote() / quote_identifer() methods provided by DBI, so should Do The Right Thing for any DBI-supported database engine.)

Also released is version 1.24 of Dancer::Plugin::Database, fixing a bug with the log_queries setting reported today on IRC by Martin P Evans (mpe) – thanks Martin!

As soon as time permits, I intend to add more features and refinement to Dancer::Plugin::SimpleCRUD to make it even more useful. Any contributions would be very welcome indeed – you can fork the Dancer::Plugin::SimpleCRUD repository on GitHub and submit pull requests, or contact me with patches.

(You can also find Dancer::Plugin::Database on GitHub, and if you’re interested in my other projects or “following” me, see my GitHub profile.)

]]> http://www.preshweb.co.uk/2011/05/dancer-plugins-simplecrud-0-03-and-database-1-24/feed/ 0