For this tutorial, it assumes that Irssi is running on a box separate from your current local machine that you have SSH access to. For example, at work, we have an inter-office server that is running an IRC server. I just SSH into that server from my workstation, fire up screen then Irssi, and connect to it. Irssi is running remotely from my desktop. This is also the case for my personal Irssi session. So, in other words, Irssi is running under screen remotely, and you connect to that session from any other computer via SSH.

First, there is fnotify.pl, a Perl script for Irssi to save the highlights you get in a channel to a file. Save this script to your ~/.irssi/scripts/ directory:

aaron@achilles:~$ mv fnotify.pl ~/.irssi/scripts

Now, if you want the script to run automatically when you launch Irssi, then create a directory called ‘autorun’ in the ~/.irssi/scripts/ directory, and create a symbolic link to fnotify.pl so Irssi starts it up automatically when loaded:

aaron@achilles:~$ cd ~/.irssi/scripts/autorun && ln -s ../fnotify.pl .

Once copied in, either start your Irssi session, or if it is already running, then execute the script in Irssi itself:

/RUN fnotify.pl

When running, it creates a file called ‘fnotify’ in the ~/.irssi/ directory. It is just a plain text file containing all the times you have been highlighted in a channel, one highlight per line.

We need to get the highlights in the appropriate channel to our desktop, so we can visually see them when we are not looking at Irssi itself. You will need notify-send to notify you when someone says your name in a channel. If not installed, install libnotify-bin (Ubuntu/Debian syntax below):

aaron@hercules:~$ sudo aptitude install libnotify-bin

Now, we just need to write a shell script to send us the GUI notifications. This can be done with a simple Bash script (yes, from the same page we got the Perl script for Irssi). Save it anywhere on your local box (not the box that is running the Irssi instance; like your workstation, for example) and execute it (here, I saved it as ‘irssi_notify.sh’).

In the script above, you need to replace ‘remote.system.somewhere’ with your server that you are connecting to. The script makes an SSH connection to the server that you specified, and parses through ~/.irssi/fnotify one line at a time. Each line gets its own notification. That line is then removed from the file, so it doesn’t continuously grow as you continue to get highlighted in channels.

There you go. That’s it! Pretty easy, but a little hackish. But that’s okay. Isn’t that what computers are all about? To automate human tasks? Besides, what fun would it be, if it weren’t hackish? At any rate, a screenshot of the notification results is shown below (you can see the notifications in the bottom-right of the screenshot). But first, a couple caveats:

1. If the screensaver kicks in, and you are highlighted in a channel, you will not receive a GUI notification. This is default behavior with libnotify-bin.
2. By default, Irssi only highlights the nick that mentioned your nick if your nick is first on the line. Otherwise, it is not the case. This can be fixed highlighting the nick that mentions your nick anywhere in the text. Do the following in Irssi:

/hilight -nick (your_nick)

Thanks to Clint for bringing this to my attention! Click for a larger screenshot.

For me, my first language that I sat down and learned in a formal setting was Java. However, I had TI, Casio, and HP calculators, as well as an Atari 800 that I would fiddle with, and program. So, Basic was really the first language that I toyed with. I just never sat down, and took the time to “learn” it.

So, for all the programmers, coders, script kiddies and developers out there, what is the 1st programming language that you learned? If applicable, leave a comment specifying the system that you learned the language on.

First and foremost, I have a global variable used as a counter. I know that this is a BIG NO-NO, but, because the code is only 35 lines in length, I’m not too worried. I do recognize, though, that passing the counter by reference through the recursive function PrintFiles() would probably be the better way to handle that, but then, that’s just making things a bit more difficult than I care at this point.

What does the program do? It should be fairly obvious: it runs through a root directory structure, looking for OGG Vorbis files, counting them, and printing the results to another text file for inventory. Basic, gets the job done, and without a lot of fanfare. The code should be self-evident, but I’m anal about commenting code, so redundant comments are placed throughout. The program was just an exercise for me to:

1. Increase my ability to do simple recursion.
2. Learn recursion using Perl.
3. Create an inventory of my music.

Anyway, here’s the code:

The Perl code I used to accomplish the task is as follows (please take note, that WordPress loves to parse tags, even if contained within <code> tags. WordPress also likes to lowercase the tag, so in Perl, file handles will be in lowercase):

Just for fun, a buddy of mine mentioned to code it in Ruby, and compare results. Seeing as though I have never coded a Ruby script in my life, I was a bit worried. However, it wasn’t too bad. I just had to cure my itch to put a $ in front of all my variables. Anyway, heres the Ruby code, following as closely as possible to the Perl code:

Ok. As you can see, the code is fairly similar. The algorithms the same. Running the script takes a mere second or two, and the file comes out correct. However, I was curious about execution speed, so I decided to pit one script against the other, time them, and see what happens. Here are my results

aaron@hercules:~/Desktop$ time perl weight.pl
Processed: 5394

real    0m1.386s
user    0m1.304s
sys     0m0.048s
aaron@hercules:~/Desktop$ time ruby weight.rb
Processed: 5394

real    0m2.180s
user    0m1.992s
sys     0m0.124s

Am I reading this correctly? Perl is almost 60% faster at execution with this code than Ruby? I thought Ruby was supposed to have exceptional file handling. Better than Perl, even. However, I have also heard that the Ruby devs are more concerned about functionality than speed, which should be expected. Still, that’s a serious speed factor. If I was worried about speed here, Perl, in this case, would win out.

At any rate, this was a fun little exercise to stretch my scripting muscles, and to learn a bit of Ruby. I’m curious if I can make the scripts more efficient. If you know how, comment below, or contact me.

>>> vontrapp
Dr, co yd. Ekrpat jrmcbiZ

Not exactly intuitive as to what is trying to be said. The only way to figure it out, is set your keyboard layout to Dvorak, and type the letters as they would appear on a QWERTY keyboard. Doing so would produce:

>>> vontrapp
How is the Dvorak coming?

As we began discussing in the channel, we thought that it would be great if we could have ibot do the decoding for us. Well, I’m not familiar with blootbot or it’s scripting capabilities, so I wrote a script for Irssi that can convert any “Dvorak text” to QWERTY and vice versa. The commands to run are ‘/dv some text here’ and ‘/qw some text here’. When ran, it just puts the the result in the channel in a single line, as to not flood or annoy the channel. The script does not utilize color, but that could be added easily to help identify the difference between the input and output text.

Here is the code below (no syntax highligting. Sorry). Save it as ‘dvoark-qwerty.pl’ in your ~/irssi/scripts/ directory, and run “/script load dvorak-qwerty.pl” in Irssi.

As you can see, this is a very inefficient algorithm. If “phones.dat” is n-lines long, and “P1514.FIN” is m-lines long, then for every n-record, I am looking at EVERY m-record. This means, my search algorithm is O(n*m). Now, I’m going to say, that this works for small files. Looking at “phones.dat” which only has 330 lines, and “P1514.FIN” which only has 500 lines, what am I worried about? It takes less than a second to execute the code, and spit out the result. Heh. If only every file I dealt with was that small. Today, I was looking at two files that had about 12,000 lines. It took ~20 seconds to finish the script. Still, not really a length that I have to be concerned about, but I can make it better.

First, thanks go to Levi Pearson and Jason Hall for helping me realize the errors of my ways. I can increase the efficiency of the algorithm greatly by using hashes. In fact, I can take the order of the algorithm to O(n+m) by only traversing each file only once. Here’s the code I came up for that:

In this case, “P1514.FIN” still has the 500 lines it used to have, and “p1514.afo” has well over 12,000. Executing the code is actually faster than previous. We should expect this as rather than traversing the m-file n times making my comparison, I traverse each file only once. The first file to store the key and value in a hash, and the second file to make the comparison. The only thing that may make the program a bit more efficient, would be to store the smaller of the two files in the hash, and use the larger of the two for comparing against the hash. But really, in that case, we’re just concerned about memory, which isn’t a worry for me.

The funny thing about this little programming example? I’m applying what I’ve learned in Discrete Math to a very real everyday problem. And who’d-a-thunk that any of the stuff was important?!

The initial reason this blog was put up, back in September 2005, was to provide an archive to Perl, Python and PHP (thus, the “Pthree”). It was to take a look at those languages from a scripting point of view. Being fairly new in all 3, I thought this would provide great tutorials to those languages for those who are also new to those languages. More importantly, it was to keep me working with those languages to improve my programming prowess. Well, it took a different direction, and it didn’t take long either.

I’d like to go back to what this blog was initially designed for, and provide my experience in looking at those three languages. However, I admit that I am intimidated by the expertise of those out in the “real world”. I fear that my experiences will be ridiculed by those of greater experience and knowledge. However, I’m going to take a step in the dark, and brave the journey. Starting tomorrow, the overall content of the blog will be in respects to Perl, Python and PHP with touches of Ruby and Bash all on GNU/Linux systems, primarily Ubuntu. Of course, comments are always open, and I encourage those of higher knowledge to help me identify what to fix or improve with my code. I plan to have a post up per day at a minimum.

This means that I’ll need a good syntax highlighter for my blog. I have been using Geshi, and like it so far, but it needs a little tweaking. If anyone knows of a solid syntax highlighter, which cover the above languages, for the WordPress platform, I’m all ears.

I hope you enjoy the direction this blog takes.

Fairly straight forward. Nothing fancy here. I’ve assigned 3 variables some text from the current line, and rearranged their order, then printed out the new order to newfile.txt. If oldfile.txt is 100 characters long on each line, and 500 lines long, then newfile.txt is also 100 characters long on each line and 500 lines long.

However, what if I only want to print the first 18 characters on each line to be in newfile.txt rather than the whole line? Than rather than:

I would need:

Ah. But do you notice anything wrong with the code above? I didn’t, and it took 8 hours of sleep later to figure it out. When printing out the whole line ($_), the line feed as the last character on that line. Thus, newfile.txt will also have the line feed. However, if using substr() in the middle of the line, not including the last character of the line (the line feed), then the line feed doesn’t exist, and Perl attempts to write every line on the same line. So, rather, we need to append a line feed at the end:

Much better. Something so simple, yet easily overlooked.

The first thing for me, again, because of my n00b skills, was to create a stand-alone program that converted the system time to a binary string representation. I wanted to test and retest that the conversion worked perfectly before testing it in irssi and crashing the program.

So here was what I had in mind:

1. Get the hours and minutes from the localtime on the system.
2. Convert the hours to a binary string.
3. Convert the minuts to a binary string.
4. Concatenate the binary strings together with the colon time seperator.
5. Store the concatention in the irssi timestamp variable.

The first four steps took no time at all. I could print them to the console and see the results. The wall that I hit was trying to hook it into irssi. I had no idea where to begin with that. So I figured I’d start looking at other scripts, and figure out exactly how to do it. There was also documentation on the irssi web site for creating brief scripts. Needless to say, it isn’t that comprhensive, and I spend more time hacking than learning. I can easily say that learning the syntax and functions took 80% of the time getting this script finished.

Well, it’s finished. It’s a fairly easy and brief script. Nothing to it really. You can download the whole script here. To execute the script, just /script load binary_time.pl and to unload the script, just /script unload binary_time. I would be interested in feedback on the script, if you wouldn’t mind testing it out.

Also, I received a couple emails and a comment on the last post regarding my hacked madcow theme, and if I could post it here. Sure, no problem. Here you go.

• nicklist.pl perl script for the nicklist on the right. It is redrawn on screen for every part/join and every channel change. Really nice. I run it in screen mode rather than fifo mode. I would rather deal with one terminal than two.
• madcow.theme as my main irssi theme. Yes, even though irssi is a console application, there are themes to customize the look. I like madcow the best. It has a tight overall theme integration, and the indented nicks on the left are a must. The colors work well with each other and they are strong.
• Split windows are the only way to go with irssi. As pictured, I have 3 containers managing the channels (windows) that I am in. This way, I can keep updated on the channels that I frequent the most (I’m in 16 channels on freenode currently). The only problem is being able to know what window you are in before sending a message.
• Theme hacking for split windows is a must. With the default theme, it difficult to know what channel you are in. You have to look at the status bar, and see where it is located before sending. This isn’t enough, so I made the active status bar bright red as a better visual clue to where I am. Since hacking this in the theme, I haven’t sent a message to the wrong channel. Also, if anyone says my nick at all, the whole line is yellow, versus just my nick getting highlighted. A little more obvious when focusing on 3 windows at once.

       Decimal   Octal   Hex    Binary     Value
       -------   -----   ---    ------     -----
         000      000    000   00000000      NUL    (Null char.)
         001      001    001   00000001      SOH    (Start of Header)
         002      002    002   00000010      STX    (Start of Text)
         003      003    003   00000011      ETX    (End of Text)
         004      004    004   00000100      EOT    (End of Transmission)
         005      005    005   00000101      ENQ    (Enquiry)
         006      006    006   00000110      ACK    (Acknowledgment)
         007      007    007   00000111      BEL    (Bell)
         008      010    008   00001000       BS    (Backspace)
         009      011    009   00001001       HT    (Horizontal Tab)
         010      012    00A   00001010       LF    (Line Feed)
         011      013    00B   00001011       VT    (Vertical Tab)
         012      014    00C   00001100       FF    (Form Feed)
         013      015    00D   00001101       CR    (Carriage Return)
         014      016    00E   00001110       SO    (Shift Out)
         015      017    00F   00001111       SI    (Shift In)
         016      020    010   00010000      DLE    (Data Link Escape)
         017      021    011   00010001      DC1 (XON) (Device Control 1)
         018      022    012   00010010      DC2       (Device Control 2)
         019      023    013   00010011      DC3 (XOFF)(Device Control 3)
         020      024    014   00010100      DC4       (Device Control 4)
         021      025    015   00010101      NAK    (Negative Acknowledgement)
         022      026    016   00010110      SYN    (Synchronous Idle)
         023      027    017   00010111      ETB    (End of Trans. Block)
         024      030    018   00011000      CAN    (Cancel)
         025      031    019   00011001       EM    (End of Medium)
         026      032    01A   00011010      SUB    (Substitute)
         027      033    01B   00011011      ESC    (Escape)
         028      034    01C   00011100       FS    (File Separator)
         029      035    01D   00011101       GS    (Group Separator)
         030      036    01E   00011110       RS    (Request to Send)(Record Separator)
         031      037    01F   00011111       US    (Unit Separator)
         032      040    020   00100000       SP    (Space)
         033      041    021   00100001        !    (exclamation mark)
         034      042    022   00100010        "    (double quote)
         035      043    023   00100011        #    (number sign)
         036      044    024   00100100        $    (dollar sign)
         037      045    025   00100101        %    (percent)
         038      046    026   00100110        &    (ampersand)
         039      047    027   00100111        '    (single quote)
         040      050    028   00101000        (    (left/opening parenthesis)
         041      051    029   00101001        )    (right/closing parenthesis)
         042      052    02A   00101010        *    (asterisk)
         043      053    02B   00101011        +    (plus)
         044      054    02C   00101100        ,    (comma)
         045      055    02D   00101101        -    (minus or dash)
         046      056    02E   00101110        .    (dot)
         047      057    02F   00101111        /    (forward slash)
         048      060    030   00110000        0
         049      061    031   00110001        1
         050      062    032   00110010        2
         051      063    033   00110011        3
         052      064    034   00110100        4
         053      065    035   00110101        5
         054      066    036   00110110        6
         055      067    037   00110111        7
         056      070    038   00111000        8
         057      071    039   00111001        9
         058      072    03A   00111010        :    (colon)
         059      073    03B   00111011        ;    (semi-colon)
         060      074    03C   00111100        <    (less than)
         061      075    03D   00111101        =    (equal sign)
         062      076    03E   00111110        >    (greater than)
         063      077    03F   00111111        ?    (question mark)
         064      100    040   01000000        @    (AT symbol)
         065      101    041   01000001        A
         066      102    042   01000010        B
         067      103    043   01000011        C
         068      104    044   01000100        D
         069      105    045   01000101        E
         070      106    046   01000110        F
         071      107    047   01000111        G
         072      110    048   01001000        H
         073      111    049   01001001        I
         074      112    04A   01001010        J
         075      113    04B   01001011        K
         076      114    04C   01001100        L
         077      115    04D   01001101        M
         078      116    04E   01001110        N
         079      117    04F   01001111        O
         080      120    050   01010000        P
         081      121    051   01010001        Q
         082      122    052   01010010        R
         083      123    053   01010011        S
         084      124    054   01010100        T
         085      125    055   01010101        U
         086      126    056   01010110        V
         087      127    057   01010111        W
         088      130    058   01011000        X
         089      131    059   01011001        Y
         090      132    05A   01011010        Z
         091      133    05B   01011011        [    (left/opening bracket)
         092      134    05C   01011100        \    (back slash)
         093      135    05D   01011101        ]    (right/closing bracket)
         094      136    05E   01011110        ^    (caret/cirumflex)
         095      137    05F   01011111        _    (underscore)
         096      140    060   01100000        `
         097      141    061   01100001        a
         098      142    062   01100010        b
         099      143    063   01100011        c
         100      144    064   01100100        d
         101      145    065   01100101        e
         102      146    066   01100110        f
         103      147    067   01100111        g
         104      150    068   01101000        h
         105      151    069   01101001        i
         106      152    06A   01101010        j
         107      153    06B   01101011        k
         108      154    06C   01101100        l
         109      155    06D   01101101        m
         110      156    06E   01101110        n
         111      157    06F   01101111        o
         112      160    070   01110000        p
         113      161    071   01110001        q
         114      162    072   01110010        r
         115      163    073   01110011        s
         116      164    074   01110100        t
         117      165    075   01110101        u
         118      166    076   01110110        v
         119      167    077   01110111        w
         120      170    078   01111000        x
         121      171    079   01111001        y
         122      172    07A   01111010        z
         123      173    07B   01111011        {    (left/opening brace)
         124      174    07C   01111100        |    (vertical bar)
         125      175    07D   01111101        }    (right/closing brace)
         126      176    07E   01111110        ~    (tilde)
         127      177    07F   01111111      DEL    (delete)

Taking the decimal value and adding a “&” and a “#” before the number, and a “;” after it, results in the HTML code for that ASCII value. For example, my email address would be as follows (broken-up over a couple of lines to fit better on pages with smaller screen resolutions):

Now tell me that web bots are going to make sense of that. Becuase bots scan the source code of the HTML rather than the parsed code, you can rest assured that your email address will remain secure from spam and the such.

Becuase of this new found idea I had over the weekend (I doubt it is that new- I am sure someone else thought of this as well), I decided that I will be coding a simple HTML page with forms that will parse any ASCII character into the HTML obfuscated code. I only see this useful for hiding email addresses on web pages, and making web pages W3C compliant. I decided to use Perl as my language of choice. This page should be quick to code, including the Perl script. When the code is complete, I will post the results online, for all to use and share.

Several years ago, a former employee wrote a few batch files utilizing the QuickBasic language. At the time, it worked well, and it still is. However, the more we use Linux, the more we see the sheer power it offers, and getting rid of a lot of Windows and other licenses is optimal. So I decided to take it upon myself to make the conversion.

Fortunately, there isn’t much in the QuickBasic realm at work that I need to deal with. All of them just read plain text files, make some adjustments, and spit out the result into a new text file. And luckily, there are only a handful of these programs to worry about.

The only drawback to making this switch is the macros that a few of the data engineers have grown accustomed to. Also, these employees have become familiar with the language, so altering the Basic program to fit their certain circumstances isn’t too difficult. This could mean trouble when moving to a new language for a few reasons. First, the new language will need some tutoring and training before making the switch. Next, the macros everyone has grown to love will disappear, unless smaller Perl or Python scripts can be written to replace those macros. Finally, these programs would need to be bullet-proof. Due to the manipulation of extremely valuable data, bugs would have to be 100% worked out before implementation.

Weighing the benifits versus the drawbacks, however, seem to be clear. If the goal of the company is to move to everything Linux, even for workstations, then a new language will need to a replace the existing Windows-only QuickBasic programs. Perl has low overhead and utilized little processing power. It is an easy language to grasp, and an easy language to write “quickies”.

While I have no code yet, I do plan on attempting the conversion this week, which means I’ll have some code and tutorials up soon.

Unfortuantely, this program only took 2nd in a obfuscated code contest. According to the author on his website:

I think Felix (the contest judge) made a bad judgement, because the winning program was not nearly as confusing as mine—it was actually very simple. If you fixed the indentation, it was quite straightforward. My program is difficult to understand even if you fix it up with good formatting and reasonable variable names. In the solution file I provided, I expanded it in this way, and it still took me about 2500 words to explain what was going on.

He does provide a more straightened version of the code as a solution to figuring out exactly what the program does and when. He may provide a cleaner, more organized view of the code, but trying to understand the program is left to you. Here it is:

Not bad. Not bad at all.