Chewing The Cud

Having setup a backup server for work and home, I was looking into how to remove archives that were a week or older. Initially, I wrote a simple script to search a path for files that matched a naming convention and whose creation dates exceeded the week limit. This was fine and dandy but not the most elegant and didn’t really increase my linux-fu. So I decided to delve deeper and find a good one-liner that embraces the linux way of life. My result:

rm `find /path/to/backups/ -mtime +7 -name ‘*.bz2′`

The breakdown:

1. rm - remove files, any n00b knows that…
2. the ` mark surrounding the argument passed to rm denotes that the shell should use the result of executing the command(s) inside the ticks as the arguments to rm. This tick can be found to the left of the number one.
3. find does that, finds files and lists them to stdout, generally the screen.
4. /path/to/backups is the path find begins its search from…
5. -mtime +7 says find files who’s modification time is more than 7*24 hours ago, effectively a week or more in the past.
6. -name ‘*.bz2′ matches any file ending in with the .bz2 extension.

Slap that sucker into a cron job and you have yourself an automated way to maintain a certain number of files that do not exceed a certain time frame. find is enormously useful and has so many wonderful options to assist you in your file searching. So there you have it, a simple one-liner to remove files based on their timestamp.

So what’s a guy to do on Friday night / Saturday? Probably look for something really nerdy to do, right??!?? That’s probably the response of most guys right? Okay, maybe not; but when your significant other is still playing in Florida, and the movie theatre is running on partial power and not showing movies, it is easy to become absorbed by something new and shiny. My new toy: YAWS, (Yet Another WebServer for those not in the know).

I am a web developer and as such spend a healthy chunk of time leveraging the Apache webserver to serve up the web applications I develop. So when another web server makes performance claims like this (thoughput ( load(x-axis) vs KBytes/second(y-axis)):

Our figure shows the performance of a server when subject to parallel load. This kind of load is often generated in a so-called “Distributed denial of service attack”.

Apache dies at about 4,000 parallel sessions. Yaws is still functioning at over 80,000 parallel connections.

Intruiged, I upgraded my version of erlang, got myself YAWS up and running, and am now delving into the world of erlang web development. I think I’ll write a simple application in both erlang/YAWS and PHP/Apache and run some benchmarks to test these claims myself. To see my YAWS development, tune your browser to my compy. Currently it only has the default site, as my erlang fu is in development.

The graph is non-trivial and if it proves to be true, even partially true, that YAWS can handle 20x the number of parallel requests Apache can, that may be just the advantage we need over our competition.

More to come…

Continuations…frequently referred to by Paul Graham as, to paraphrase, awesome. With all the reading I’ve done regarding continuations, I’ve never really seen the big deal about them.  Turns out its because I didn’t get it. Imagine that… Fortunately for me, I have continued to read about them and finally had the “ah ha” moment. Reading this page describing fuctional programming, the author explains continuations in way that finally made it click:

A “continuation” is a parameter we may choose to pass to our function that specifies where the function should return. The description may be more complicated than it sounds. Take a look at the following code:

int i = add(5, 10);
int j = square(i);

The function add returns 15 to be assigned to i, the place where add was originally called. After that the value of i is used to call square. Note that a lazy compiler can’t rearrange these lines of code because the second line depends on successful evaluation of the first. We can rewrite this code block using Continuation Passing Style or CPS, where the function add doesn’t return to the original caller but instead returns its result to square.

int j = add(5, 10, square);

In this case add gets another parameter - a function that add must call with its result upon completion. In this case square is a continuation of add. In both cases j will equal 225.

So if you redefine your functions to take an optional last parameter that points to where the function should return to, suddenly you have some serious flexibility regarding what happens at the end of functions. The brilliance behind this method is shown a little further in the article:

Once we convert a program to CPS it becomes clear that every instruction has some continuation, a function it will call with the result, which in a regular program would be a place it must return to. Let’s pick any instruction from above code, say add(5, 10). In a program written in CPS style it’s clear what add’s continuation is - it’s a function that add calls once it’s done. But what is it in a non-CPS program? We could, of course, convert the program to CPS, but do we have to?

It turns out that we don’t. Look carefully at our CPS conversion. If you try to write a compiler for it and think about it long enough you’ll realize that the CPS version needs no stack! No function ever “returns” in the traditional sense, it just calls another function with the result instead. We don’t need to push function arguments on the stack with every call and then pop them back, we can simply store them in some block of memory and use a jump instruction instead. We’ll never need the original arguments - they’ll never be used again since no function ever returns!

So, programs written in CPS style have no stack but have an extra argument with a function to call. Programs not written in CPS style have no argument with a function to call, but have the stack instead. What does the stack contain? Simply the arguments, and a pointer to memory where the function should return. Do you see a light bulb? The stack simply contains continuation information! The pointer to the return instruction in the stack is essentially the same thing as the function to call in CPS programs! If you wanted to find out what continuation for add(5, 10) is, you’d simply have to examine the stack at the point of its execution!

Continuations are particularly well-suited to web programming because of the stateless nature of the web. A request for a page could come at anytime, and what happened before  that page request will not matter. However, this is not always desirable. With continuations, we can simulate state, even in a stateless environment. For more on that subject, start with this article. An interesting alternative to MVC.
This is a whole new paradigm from the one I was taught in school and I think rightfully so. It is a tough concept to wrap your mind around at first. Now that I’ve had the “ah ha” moment, I look forward to implementing these ideas in my future work.

Ever find a link or button on a website that looked interesting but was disabled? Did you feel frustrated when you didn’t know why that certain something was disabled? This is a prime example of where a little hint as to why something is the way it is would be oh so useful. These hints are commonly referred to as tooltips, and a nice little javascript library named Tooltip.js handles this nifty little feature. Looking at their demos, it seems like a nice tool in the toolbelt. We’ll see how nicely it plays with Caseman.

For those that wish to send me email, I have set up my work email (james@serafinistudios.com) with a key pair. Download my public key here. Use this key with your favorite email client (I like Thunderbird) and send me email that no one else can read. Well, most any one…

Oh snap! No posts in over a month. What could I possibly have been doing?

For starters, I have been coding the last week and a half at an average of 13 hours a day. We have a pretty significant project due in a little over a week which coincides with a major refactoring effort of the codebase. The refactoring took me a week an a half while Gabriel, Ben, and Steve worked on new features and infrastructure enhancements. The next couple of days should see the melding of those efforts into the refactored codebase.

The other consumer of my time has been the girlfriend. The day off I take each week is devoted entirely to her and nary a bit is processed or email read during that day. It’s not that she’s a Luddite or anything, but she definitely helps me reconnect with my non-geek side. Like Saturday, we are having a barbeque at my place then going to a professional soccer game. It’s a no-computer day in the midst of coding insanity, and I, for one, am all for it.

As May approaches, I find myself gearing up for wedding season. No, no crashing; I’m actually invited to these. Three are to take place in the next two months while a fourth occurs in November. I think I am fine with the weddings; its when the friends start popping out kids that I’ll have some adjusting to do.

On a geekier note, I found a site today that I think has some potential for being quite helpful in making me a better programmer. Developing Programmers is a site that dedicates itself to giving resourse, articles, tools, etc, that help a budding programmer make the transition from being a coder to being a professional programmer. I realize that I am being paid to code right now, and in a loose sense that makes me a professional. I am, however, not on par with the creme de la creme of programmers, and I want to be. I know its not an overnight process, and this site seems to be a resource that will help with that journey. The cool thing about the journey - it never really ends. No programmer knows it all, has done it all, seen it all; there’s always more to learn and more to experience. That’s why coding is so fun. It takes you places, rather than being a destination itself.

Take, for example, my very limited experience. I’ve worked for a college, a “secret shopper” business, a multi-national publisher, and an association of realtors. Those are some pretty disparate fields and yet all needed code written. I am not claiming to have grokked all there is to know about how each realm operates, but my jobs have exposed me to the fields and I am more conscious of how those fields affect various aspects of life. What keeps it fresh is not knowing where the next job will come from, what industry it will be in. That is exciting.

Anyway, progress and change are constants, and when you realize that, it’s not so scary…

Want to connect to a remote server without having to type in those annoying passwords? Have you generated your public and private keys? That is a must my friend.

$ ssh-keygen -t dsa -f filename

This will create two files: ‘filename’, your private key, and ‘filename.pub’, your public key. Store the private key away (probably $HOME/.ssh) and put your public key on the remote server.

Assuming you put the private key in the $HOME/.ssh directory, you need to run

$ ssh-add $HOME/.ssh/filename

and this will put your new key into ssh’s knowledge.

****IMPORTANT****

When prompted, do not enter a passphrase, or else you will need this passphrase to use the key, thus negating the purpose of the key for password-less connection. Do not use this key pairing when you need the added security of a passphrase. You have been warned.

******************

Now we need to setup the remote machine. This is fairly trivial using the ssh-copy-id command.

$ ssh-copy-id -i $HOME/.ssh/filename.pub user@remotemachine.com

The command should return with a success message and an ssh command to try your new key out with. If this doesn’t work, RTFM!

LAMPPP (Linux Apache MySQL PHP/Python/Perl) was recently deemed the most secure open source software package by a government-backed study.

In the analysis, more than 17.5 million lines of code from 32 open-source projects were scanned. On average, 0.434 bugs per 1,000 lines of code were found, Coverity said. The LAMP stack, however, ’showed significantly better software quality,” with an average of 0.29 defects per 1,000 lines of code, the technology company said.

Develop in PHP? Want to allow users to pay you on your site, but don’t want to pony up the dough for a merchant account? Why not use Paypal, some clever PHP, and whammo bammo, you’ve got yourself a nice, inexpensive system for accepting credit card payments online.

Read this for more…

Funny comic from Dilbert today: