IMHO:
Yes, Windows sucks as an operating system for developing in Unix-based programming languages
Yes, Windows has the best general Desktop user experience (of all current systems)
So, getting to the point, context-matters. Disgruntled old IRC channel loiterers love to make generalizations about everything from politics to operating systems, regex use-cases to procedural versus object-oriented programming.
This is a cautionary tale for newbies, listen and do as you’re told, but also, don’t.
Your friendly neighborhood rebel-rouser
-Al
]]># so basically this would load classes on-the-fly using Module::Runtime (or the like) if not already loaded, and provide simple and cute access to class methods, etc. Obviously there are times (most-times) when you'd rather know about a problem at compile-time versus run-time but my brain dumps could care less about those types of particulars.
package App::Controller::Root;
use Class::Path class => 'App';
{
my $obj;
$obj = class '/database'; # App::Database->new
$obj = class '/database.connect'; # App::Database->connect
$obj = class '/database.connect' => [...]; # App::Database->connect(...)
$obj = class './admin'; # App::Controller::Admin->new
$obj = class 'admin'; # App::Controller::Root::Admin->new
$obj = class 'adminDB'; # App::AdminDB->new
$obj = class 'admin-db'; # App::AdminDb->new
}
-Enjoy
]]>The version number 0.0.0 could be (is usually) interpreted as version.edition.iteration, whereas the version number 0.0.0.000 would be version.edition.iteration.build having the build identifier correspond to the number of times the code has been compiled against said version of the code.
If a person is a product of his/her environment, .. more specifically if a person is a derived result of some original (parents, grandparents, etc), that doesn't necessarily make the person a new version, ... a 2.0.
I suppose what version you are depends on how much you deviate from the original version.
What version are you?
]]>WHAT
Pegasus - The Module-Starter for DBIx::Class data models
Pegasus is a simple scaffolding utility for RAD (rapid app development).
It helps you generate a DBIx::Class data model with schema class, and
tests.
It basically extends the convenience of using DBIx::Class::Schema::Loader.
This devkit exists solely to help further eliminate the tedium when
creating data models using DBIx::Class.
WHEN
A developer could use Pegasus after creating the database schema at the
database. Pegasus will then generate a DBIC data model.
WHERE
Pegasus is far from ready for the CPAN, ... So where do pre-CPAN modules
attend daycare? GitHub ofcourse:
Pegasus CLI: https://github.com/alnewkirk/Pegasus
Pegasus Example Model: https://github.com/alnewkirk/Pegasus-Example
HOW
Pegasus Scaffold Generation
1. generate schema (using DBIC S::L)
2. generate sql scripts (deploy)
3. generate transaction layer (Pegasus)
4. generate tests (Pegasus)
Usage (from the command-line)
$ sqlite3 example.db < creation_script_not_inc.sql
$ pegasus setup Example::DB dbi:SQLite:./example.db root
$ pegasus run
WHY
Scaffolding helps us build it faster, bigger, better (some restrictions apply)
Also,
-- Programming today is a race between software engineers striving to build
bigger and better idiot-proof programs, and the Universe trying to produce
bigger and better idiots. So far, the Universe is winning. Cit. Rich Cook
Validation::Class Overview Screencast. In this video I explain what Validation::Class is, why it is, and what it has to offer you.
]]>In the beginning there was Oogly, then Oogly::Aagly, and finally Validation::Class. All reiterations of the same idea, each a wee bit better executed than the last with Validation::Class being (IMHO) the end-game.
Where are we now:
Validation::Class now has a pretty solid core and test coverage, a plugin system, and I just git-push'd an HTML form field rendering plugin called Validation::Class::Plugin::FormFields to be release on the CPAN after rigorous testing.
I'd never used terms like rigorous testing before because I've never cared about the code enough. In the past I've only ever wanted to get it the concept down and out-of-my-head. I believe this adds to the reason this iteration is alot more solid, ... because I'm becoming alot more solid as a developer.
-- Al
]]>This spawned a new way of looking at data validation, using a class as an application's firewall representing the rules of the data allowed to pass through it, not bound to a use-case and flexible.
I encourage you to check it out and please leave feedback:
Validation-Class has been shipped, Moosified since 2.0.0:
Github: https://github.com/alnewkirk/Validation-Class-Moose
CPAN: https://metacpan.org/module/Validation::Class
Although I vowed not to work over the weekend, I ended up creating WWW::MadMimi for the Perl community which currently live at GitHub.
]]>For the sake of time I will just highlight some of the features that I think are innovative and add value.
♥ Scrappy can be used as DSL or OOP (even interchangeably). e.g.
[oop]
use Scrappy;
my $spidy = Scrappy->new;
$spidy->crawl($url, { 'a' => sub { print 'I found this link', shift->href; } });
or
[dsl]
use Scrappy qw/:syntax/;
crawl $url, { 'a' => sub { print 'I found this link', shift->href; } };
♥ Pick a User-Agent, Any User-Agent, e.g.
use Scrappy qw/:syntax/;
user_agent random_ua;
or
user_agent random_ua 'firefox'; # firefox only
user_agent random_ua 'firefox', 'linux'; # firefox on linux only
♥ XPath or Grab and Zoom
Most spider writers know that if you need to grab an element with precision accuracy, especially when the HTML is not marked up with alot of CSS selectors, then XPath is your best friend. Sometime you may not want a mix of XPaths and CSS selectors through you code so instead use the grab and zoom technique to get closer to that particular element.
my $block = grab 'div', ':all'; #grab
my $zoom = grab 'span', ':all', $block->html; #zoom
♥ Scrappy has URL pattern matching (like web apps), e.g.
get 'http://localhost/tags/websites';
if (match '/tags/:tag') {
print param('tag');
}
♥ More and More Variables Automatically
Scrappy has a convenient stash object for sharing data throughout various actions, and forked processes, has a param method for accessing the current page's querystring or matched URL patterns. e.g.
♥ Scrappy is automated Out-of-the-Box
Scrappy can be written manually with you specifying which pages to crawl and scrape from, or you can use the crawl method to automatically crawl pages in the queue and apply specific actions on specific pages. The crawlers method provides the same level of automation but increases the processing time by forking the action processing operations. In short, you get a site crawler and the ability to execute multiple processes.
♥ Session Handling
Session handling can be easily turned on and by default stores all cookies encountered in the session file by domain.
♥ Pausing
Pausing is where you can set a range in second for your spider to wait between requests in an attempt to fake human interaction.
♥ Proxy Support
Get It On CPAN:
http://search.cpan.org/dist/Scrappy/lib/Scrappy.pm
Follow Scrappy on GitHub:
http://github.com/alnewkirk/Scrappy
Also, a previous article written on Scrappy:
http://ana.im/press/2010/09/scrappy/
The shebang line really presents a problem when developers using Windows collaborate on scripts with non-Windows developers. All Perl scripts that are executed indirectly will (should) have a shebang line. Most Perl hackers code in a Linux (-like) environment which means their shebang line will look something like this:
#!/usr/bin/perl
#!/usr/bin/env perl
Windows Perl hackers shebang line would look something like this:
#!C:\Perl\bin\perl.exe
#!C:\strawberry\perl\bin\perl.exe
As you can see, this would present a problem if the Linux Perl hacker sent me (using Windows) the script, or more commonly, I fetched the script from a version control repository, updated the script using my shebang, made some modifications, then pushed the changes back to the repo only for the Linux user to have to repeat the same pattern.
The answer is a little know hack for WIndows whereby the path to Perl is mocked under the Windows file system by copying the Perl installation to a `usr` folder in the root drive's folder, e.g. copy C:\Perl to C:\usr:
Now, #!/usr/bin/perl in the script is treated the same as #!C:/usr/bin/perl.exe. The only problem with this is that when modules are updated or installed using CPAN, the copied instance of Perl is not updated, so instead of re-copying your Perl installation each time you update or install a new module, instead make a symbolic link. Wait, how do you create a symbolic link with Windows, why the same way you do in Linux, with one exception. First you need GNUWin32 (http://gnuwin32.sourceforge.net/), this will give you tools like grep, find, ls and what we want, ln.
cd C:\
ln -s C:\strawberry\perl\ usr
We just created a symbolic link to our Strawberry Perl installation. With the aid of GNUWin32, we now have a psuedo-Linux-like Perl programming environment armed and ready.
]]>