Upon execution, the generated execs will complain about missing libraries, DLLs or similar. This is because pp does a lot, but it is somehow blind to see the Wx bindings dependencies. So you need to tell it that you have additional libraries for it to include in the build. You can do so by using the -M switch, or by using Mark Dootson’s excellent Wx::Perl::Packager! On Win32 ActivePerl setups, you might want to do “ppm install http://www.wxperl.co.uk/repository/Wx-Perl-Packager.ppd”, as not all repositories carry a ppm for this module.

Then, simply add this line at the very top of your Wx-using script:

use Wx::Perl::Packager;

and then use Wx::Perl::Packager’s “wxpar” drop-in replacement for pp. So, to compile, do:

wxpar -o myapp.exe myapp.pl

optionally adding a bit of salt like in the docs

wxpar –gui –icon=myicon.ico -o myprog.exe myscript.pl

and there you go.

So here it is. Instead of writing:

form->{var} = undef;
my $var;
if($form->{var}){
$var = $form->{var};
}else{
$var = 1;
}

use this elegant shorthand if-clause:

my $var = $form->{var} ? $form->{var} : 1;

which is short for: if $form->{var} is true ($form->{var} set), use it, else default to 1

Another shorthand variable declaration

The above is useful if you need to declare a variable and three variables are involved. If you just need to test if a passed variable holds a value/is true, another construct might be useful:

$var = $form->{var} || 1;

which is short for: if $form->{var} holds a (true) value, use it, else default to 1

My first approach was to build a hash in memory, with the usual my %hash, then adding keys and values in a giant loop. It was fast, but also very memory intensive. The problems came when I needed to have a look at the hash again to do some tidy up and when merging it with another even larger hash. The result was a large resources hog. Time to redesign the code.

So the second iteration was to keep the hash as small as possible. I though a good idea was to use delete() to throw away unneeded overhead keys… Wrong! My machine essentially locked up and got into serious disk thrashing. Time to redesign my code again.

Finally the solution was to operate in chunks and use bits out of the MapReduce box of tricks.If you face similar problems, try to keep the actual data the script has in memory small and the design lean.

Lesson 1: Don’t try delete(), as it is very resource intensive. Create a new hash instead.

for my $key (keys %oldhash){

if($some_case_is_true){

$newhash{$key} = $oldhash{$key};

}

}

Iterate over the old one, skip
what you would normally delete, and write to a new hash. This is especially true for large tied hashes (where every delete seems to start a complete new build of the hash…)!

Lesson 2: Don’t try a sort() while iterating over a large hash. Something like:

for my $key (sort { $hash{$a} <=> $hash{$b} } keys %hash){

}

is deadly (especially sorting by value). Think about your design. Why do you need sorted keys and if so, why didn’t you sort them in the first place, while building the hash? In my case the hash was so large that the only way to handle it gracefully in my environment was to use a tied hash. This gave me the option to use the BTREE type of hash, which does a very efficient sort on the hash’s build time. By using this construct, I could then access the keys in a nice sorted way.

tie %hash, ‘DB_File’, “hash.dbfile”, $flags, $mode, $DB_BTREE;

…

for my $key (keys %hash){

}

How do I pad a string so that a number or string gets leading zeros?

Answer:

By using sprintf:

my $number = 123;
$number = sprintf(”%07d”, $number);
print $number;

Output: “0000123″

after the %: “0″ is the character to add, <number>d is the amount of digits (that’s why it’s “d”) to add. See the documentation for sprintf.

my $input_width;
my $input_height;

# probe file for aspect
open(FFMPEG, “ffmpeg -i ‘$inFile’ 2>&1 |”) or $error .= “Couldn’t read from ffmpeg: $!\n”;
while (<FFMPEG>) {
if($_ =~ /Video:.+ (\d+)x(\d+)/){
$input_width = $1;
$input_height= $2;
}
}
if(!$input_width && !$input_height){
die “Could not fully get input video dimensions: $input_width x $input_height\n”;
}

Now, let’s define the target video dimensions:

my $output_width = 480;
my $output_height= 320;

# we need this for the ffmpeg command… ugly but works
my $padone = ‘-padtop’;
my $padtwo = ‘-padbottom’;

Then, here comes the magic that calculates the thickness of the black bars. This assumes that the video is actually full screen or less/letterboxed. If the video is less wide than the target frame size, the below routine will give a negative letterboxing result (which we will correct later on and use the value for pillarboxing):

# calculate padding (for black bar letterboxing/pillarboxing)
my $input_aspect= $input_width / $input_height;
my $conv_height = int( ($output_width / $input_aspect) );
$conv_height -= 1 if $conv_height % 2 == 1;
my $conv_pad = int( (($output_height - $conv_height) / 2.0) );
$conv_pad -= 1 if $conv_pad % 2 == 1;

Now we know the thickness of the black bars, but we must have a look at the video’s dimensions to actually know if we need to letterbox of pillarbox. Note the use of the value 1.333. This is the aspect ratio of your used target frame size. We use 480×320 which results in an aspect of 1.333 (480/320) and is the basis for a “breakingpoint” in our calculation:

my $aspect_mode;
if($input_aspect < 1.333){
$aspect_mode = ‘pillarboxing’;
$conv_pad *= -1; # negative to positive values
$padone = ‘-padleft’; # padding on sides
$padtwo = ‘-padright’;
}else{# default
$aspect_mode = ‘letterboxing’;
}

One last hack for the ffmpeg command:

# need for our command..
my $wxh = $output_width .’x’. $conv_height;

That’s it! Now let’s send these results to our ffmpeg command to start transcoding:

open(FFMPEG, “ffmpeg -y -i ‘$inFile’ -f flv -s $wxh $padone $conv_pad $padtwo $conv_pad -ar …”);

(the “-s” parameter informs ffmpeg about the target size, $padone and $padtwo change, depending on letterboxing or pillarboxing, to “-padtop/-padbottom” and “-padleft/-padright” while $conv_pad holds the symmetrical value for the black bars thickness.)

Further: An interesting algorithm to detect aspect ratio can be found in this thread:

my $aspect = $w/$h;
my $size;
if (abs($aspect - 16/9) < 0.02) {
$size = “320×180″;
} elsif (abs($aspect - 4/3) < 0.02) {
$size = “320×240″;
} else {
die “Weird aspect ratio: ${w}x${h} = $aspect\n”;
}

Care about copyright! and some other essential things

Before you start, you will want to take some time and think about the implications and legal aspects of running a search engine. Crawling the web at high speed will put a lot of stress on networks and foreign servers. It’s good to play by the rules. You should do the little extra work to make your robot a good robot and not let it behave like many of the spam-bots out there. As a good start, read the robot guidelines here.

OK, now after reading what a good robot should look like, let’s think about a few more things - first of all: copyright. Crawling and thus downloading large portions of the web is in it’s essence a breach of copyright. Many pages online forbid such procedures. BUT, they do allow google, yahoo and all the other search engines to crawl, download and index their sites. Why? Because these crawlers play by the rules. And the rules for a search engine are that, yes, you can download and store content but you should do it to send visitors to their sites. All storage of copyrighted content should only be done for the use of building the search index, it should be limited in terms of how long you will store this data and you should give proper indication of where and when you accessed a certain page.

The next thing to keep in mind is that your robot should follow the robots.txt rules. The robots.txt file is, as you already know from reading the “Guidelines for a well-behaved robot“, a simple ruleset for machines visiting a server. The webmaster informs your agent with this simple text file about what part of a website may be indexed and, more important, what part may be not. So, by all means, follow the robot.txt rules. In perl, you can use a module like LWP::RobotUA , WWW::RobotRules or similar to effectively do so.

The last essential thing to keep in mind is: properly identify your crawler as a search engine crawler in the User Agent String! This page here has a list of the most important robots out there. You can see: everyone else does it and it’s good practice, so do it as well. Be sure to identify your crawler, for example, like this:

 require LWP::UserAgent;
my $ua = LWP::UserAgent->new;
$ua->agent('My Crawler. Visit http://www.foo.bar/robot.html for more information');

and please also include some email, url or similar on how you can be contacted so that a webmaster who notices your crawler running wild can contact you and thus help resolve the issue.

The basic design of a search engine

When thinking of how a search engine will work and how you will actually implement all that knowledge, you will soon discover that a modern search engine consists of several specialised components. Read about it in Howstuffworks or The Anatomy of a Large-Scale Hypertextual Web Search Engine by the Google Guys - whatever you do: get used to reading stuff like that. As I pointed out earlier, searching is pushing the limits of modern computing, so get used to reading scientific stuff like that.

Now, as a search engine might appear to be a simplistic construct, it is really a complex thing to master. And as each part of that complex thing is destinned to do certain very special things, you can break the complex of a search engine down into two, or as I like to see it, three major parts: the crawler, the indexer/merger and the frontnend .

The crawler

The crawler, spider or web robot is your content aggregator. It scours the web and systematically downloads websites, discovers links, follows these extracted links and again downloads these newly discovered resources. While traversing the web, a crawler will exncounter all kinds of things. You must decide on the protocols the crawler supports (http only, or mms, ftp, etc as well), wheather it downloads only text sources (html, php, asf and all that other extensions) and how it recognizes these content types.

A good start to give the crawler a certain knowledge about the resource is to have it look at the actual extension, like the .html ending. But many resources have no ending at all, like the “http://www.foo.bar/” root page and the like. A more cleverly approach would be to look at the content-type the server sends and actually have the crawler itself send the HTTP_ACCEPT header "text/*".

While speaking of headers, a good idea would be to implement support for compressed/gzipped pages. Many servers support this feature and you can download pages in a fraction of the uncompressed size/speed. But keep in mind that the perl LWP library doesn’t handle gzipped pages by default. You need to have Compress::Zlib and the associated libraries installed and content needs to be accessed via the $response->decoded_content function of LWP.

The next thing is Encoding. Once there were 255 characters on one codepage, that were the 50s, 60s and 70s. A bit later, computer science discovered that there were more characters than the once defined characters of the ASCII alphabet, like Umlauts and such. The internet happend right inbetween that and the next iteration was an ugly hack that is called Character Encoding. Yes, there were 255 positions on that codepage to fill with letters, but now each Country/Language used different characters referenced by the same id on the the codepage. You can only know which codepage to use by labelling it with names like latin-1 (or iso-8859-1), SHIFT_JIS etc. A disaster. When browsers arrived it got even worse. A thing called HTML Entities was instroduced. This enabled users to use the raw US-ASCII codepage and render umlauts and special characters with the help of descriptive patterns like ” ”

Finally, UTF-8 saw the light of day. The idea was, as can be read here, to use two bits instead of just one, thus creating a much larger codepage with space for every imaginable character, making Codepages and Entities a thing of the past. Anyway, there a re many pages out there that could be server in plain utf8 but are still using HTML Entities on top of that, some claim to be in us-ascii while they are in reality latin-1 encoded and on and on and on.

The lesson you can learn from that is that your crawler should be able to read and recognize all that, as a last resort by guessing the used encoding. A good idea would be to convert everything to UTF-8. You can use decoded_content() for that and all the tools of the Encode module. One thing: use a newer, utf-8 ware version of perl if you’d like to do so.

After your crawler has finally successfully fetched some content (more pitfalls here: 404 errors, redirections, revisits you need to schedule for later) you need to parse the content in one way or another. Use a readily available HTML parser for that, writing a parser is a road you won’t go down! Nested data structures are a thing that can make a man mad. And: Don’t even think about using regular expressions/regexes for anything in that direction!

The last step is link extraction: You need to decide wheater your crawler inits the linkextract or if a dedicated process does so. How will your extor handle or detect already visited URLs: a bloom filter? a sorting algorithm with uniq? Think about that!

And how do you store all these URLs and all this content for later analysis? You can read about the limits of traditional storage below, but be sure to have a clever structure for the organisation of all this data. My advice, without giving too much away, would be to use buckets and chunks of data. How exactly you can implement this is another homework left for you, but make sure you use compression, some kind of a bucket index (maybe blend in some SQL here, but only some, see my comments below) and clever sorting/footprint reduction techniques for the URL lists may also help.

Puh, you made it throught, everything works. But what is that? It is sloooow! Now comes the interesting part, it works, but it is an expensive operation. More homework here: DNS lookups needs to be cached, utf8 operations/detection are too expensive, the parser is a resource hog… Some requests time out and all of that needs to be scalable, concurrent and running on multiple machines and in multiple instances. You see, the crawler alone can cost you hair…

The indexer/merger

OK, you’ve made it this far. You have extracted thousands of unique urls, visited them and downloaded the content wich is really only textual content. The next step is now: indexing it.

Most search engines, at least all the seriously large ones, don’t use techniques to really do fulltext searches on the content. Opening all those files and running regexes on the text in them would takes ages once you surpassed the mark of a few hundred content objects. The solution to this problem is turning the whole idea upside down and using what is called an inverted index.

An inverted index is like the index in a book. Texts are analysed and your process stores each word, each new word it finds, in a kind of dictionary, remembering the position of the word on-the-way. This dictionary, upon search, is used to identify the objects or positions within your body of content that match your keyword and are used to compute the results list. On a search tat consists of multiple keywords, the searcher identifies the matching entries/objects for each of thos words and then identifies the intersectioning entries.

So, write a routine that harvests all single words from your fetched content and compiles a list of what is called postings. Then arrange your content in a content db accompanying your word index.

As simple as it sounds, as difficult it is in reality. How do you differentiate between “book” and “books”, will it be the same word or will it be regarded as different concepts upon search. The quality of your index is crucial for the quality of your search engine’s results. A user looking for “short films” should get similar matches when looking for “shortfilms” - at least in theory.

Writing a good indexer is as demanding as writing a good crawler. Just some keywords to get you started: you should be aware to linguistic morphology, stemming, a fixed dictionary might help with popularity ranking, synonyms and concepts. Everybody can write a script that downloads stuff from the web (ok it’s a bit more demanding), but actually making sense of it is another cup of tea and still a big issue in information retrieval and research.

Actually, the functionality described above is the more traditional approach to searching. It is fast for a keywords based search, but nearly useless when you need to compute associations (like a human would do), similar objects or for answering semantic search requests. So it is up to you to invent the next best search engine. Tell me about your successes. It might be a Vector Search approach, a semantic engine, or a mixture of new techniques.

Anyway, the result of your indexer will, in most cases, be a kind of solid search index, a large construct of your dictionary and your indexed content - in one way or another. This search index will be accessed by your frontend for the search results.
Also, your index needs to be updated, re-checked (if indexed sources still exist) and merged with newly discovered content. Merging an index with a new chunck of data is an expensive operation. You will need to develop routines or systems to do it in a quick and feasable manner. Solutions might be to use multiple larger indexes, incremental merging or the like. An interesting problem to mediate about.

The web front-end (presentation layer)

Actually, developing the web frontend is the easiest part. In most cases you will have guidelines in terms of design and layout that were developed in conjunction with the overall userexperience that was chosen for the project and the overall corporate identity tha twill be in effect. Remember that you should inform the user about returned objects as much as possible while being brief and simple. And “form follows function”! Google is a good example for a text search engine that’s on concise on text results. The results layout of video search engine Lumerias is also simplistic by design but has some extensions and modifications that give respect to the nature of presenting video results.

Talking mainly about design here is due to the fact that the underlying technology for the search should already be available from you writing the indexer. The searcher component is the corresponding negative (or positive, depends on how you put it) to your indexer technology. The searcher reverses the algorithm of your indexer and presents matching results based on the user’s input. As simple as that.

The limits of current hardware and software

When you start to write your code, regardless of the language you do it in, you will soon reach the limits of what’s possible in information retrieval running code on current hardware and the way software works today. Your piece of software will munge billions of urls, will see thousands of doublettes, errors and pitfalls and will generate Terabytes of traffic - so be prepared for a bumpy ride. And this isn’t only the case when you try to do it all in perl…

Rule 1: Filesystem is always too slow

When thinking about storing stuff, your first idea might be: “let’s just save it to filesystem”, one data object = one file. Nice idea, but a mistake! The filesystem mgith work similar to a database but it’s actually too slow when you rely on it in thousands of operations. As a rule of thumb you should try to avoid filesystem accesses as good as you can. Load chunks of data from disk into memory, process them and write results back. But do it chunck-wise and not for every object. That’s the way to go!

Rule 2: SQL is too slow

Regardless of how many indexes you create, how optimized your queries are and how fast and well-scaled your MySQL or whatever server might be: SQL will always be too slow for the job! SQL might be great to do complicated queries but its absolutely useless to store URLs in it or store page content or anything that will go into the hundreds of thousands of objects. Believe me, I’ve been there. In-memory databases are no cure. And even committing 1,000 pooled queries at once won’t give you that extra speed you’ll need. Keep it simple! (repeat two times) and just use flat-files combined with a system of chunks of data. Process them one by one and you will be a big step closer to your goal of actually getting it to run longer than a few hours without out-of-memory of a frozen system.

Rule 3: Storage is always too small

After running your search engine for a few hour, days, weeks. Sooner or later you will run out of storage. Your first reflex might be to add a few drives. The common idea is to add a physical abstraction layer between your OS and your drives and virtualize your storage volumes. Nice idea, but you will see that when you keep adding drives each day, there will come a day when that mean time between failure rate (which appears to be quite low from a personal perspective) will starting to hit you on the professional level with thousands of drives spinning. So by all means, expect failure and implement measures to face them. Google uses the Google File System, a cluster of commodity hardware that doesn’t try to be flawless but instead backs up itself and makes desaster recovery for single nodes a simple process. Learn from that and use the Hadoop framework for the heavy lifting. The adventurous might as well outsource the storage part to Amazon’s EC2 and S3 services, but be prepared for some hefty invoices when doing so on a search service.

I hope this small quide is a good start for you, the aspiring search engine coder. I was involved in the development of the video search engine Lumerias.com and these are just a few of the issues we faced while developing that beast. This article is far from complete.

Again, if you would like to learn more about search engines, be sure to milk citeseer for all whitepapers you can get, you might as well read Anna’s amusing article on how to write a search service over at ACM. The out-of-the-box search engine Lucene can be a good source of inspiration. Are you crawling the whole web, or will you run a focused crawler? Nutch can be a good point to start without writing a single line of code.

login via ssh
ssh remotehost.com -l myusername

create these directories:

myperl/man
myperl/man/man1
myperl/man/man3

then start your perl and cpan

path/to/my/perl -MCPAN -e ’shell’

in cpan enter:

cpan> o conf makepl_arg “LIB=/path/to/myperl/lib \
INSTALLMAN1DIR=/path/to/myperl/man/man1 \
INSTALLMAN3DIR=/path/to/myperl/man/man3″

the best thing to do is to copy in these lines via [CTRL]+[SHIFT]+[V] and after that remove all wrong newlines

Finally
cpan> o conf commit

sets this conf default for the future

After that, installing things like Bugzilla is simple:

install Bundle::Bugzilla

just remember to define the path to your libs in scripts

use lib “/path/to/lib/”;

Although the origin of the name Perl are a more adventurous story, today most agree that Perl stands for Practical Extraction and Report Language, which summarises quite well what it does but hopelessly understates what’s possible with it. Perl can be used for simple, shell-like programming and automation or for highly complicated tasks in information retrieval, bio-informatics and more.

The Camel is, since O’Reilly’s books the official mascot and cpan the vast repository of helper modules written by contributing authors. Have fun!