techify

At work I’m trying to set up an NFS mount on my desktop. Our servers mount a given directory on our filer as /auto. I want to do the same thing on my (Ubuntu) PC so that I don’t have to ssh to the server to do my development anymore. Our filer is (for the sake of this post) company-filer05.

I want to access company-filer05/projects as /auto on my computer and company-filer05/company-linux-rhel4.0-x86-32 as /usr/company for access to things like perl (binaries and modules).

I’m pretty new to network file sharing (NFS), so I’m trying to figure out how it all works. I found a lot of guides that worked a little bit, but nothing that worked for me completely. I should mention that my PC is behind the company firewall, so I didn’t have to deal with that. This is what I finally did to get it working.

First, create the directory that will act as the mount point.

Notes

Next, open your /etc/fstab file. I use vim, though you can use gedit or anything else, of course.

The file should look something like this:

Add the following line to the bottom (or anywhere, I guess) to mount company-filer05/projects as /auto:

Save and close the file.

Notes

We’re almost done. Next, let’s create the credentials file that will hold our username and password to the filer. We do that instead of putting it into the fstab file so that our password isn’t just plainly visible to anyone. Replace “my_username” and “my_password” below with your username and password respectively, of course.

Your ~/.smb_credentials file should now look like this:

Almost done. Now all we have to do is mount the files. We’ll use the mount command with the -a (Mount all filesystems (of the given types) mentioned in fstab) option.

If everything worked, you won’t get any messages. To check if it worked, just go to the mount point and check if it now has the remote contents. You can do this for as many mount points as you like, of course.

I do have one outstanding question myself: I don’t want the files to be masked with 0777 — or anything else. I would like to have them be whatever they really are on the server, but I don’t know how to do that. Does anyone else?

Sometimes colorized diffs are a lot easier to read than the default diff output. Thankfully, Dave Ewart has written colordiff (http://colordiff.sourceforge.net/), a diff colorizer for the linux command line. It turns out it’s available in package repos for Debian and Ubuntu, and has been packaged for or ported to Gentoo, Fedora, Mac OS X, Lunar Linux, and FreeBSD.

After you’ve installed it, you can just pipe diff output to it to colorize your diffs:

The following is designed to test Geshi’s highlighting capabilities against Perl’s special variables and other magic. I’ve compiled a list of oddities here at the top. Have I missed anything?

• $0 and $1 - $9 appear to be interpreted as comments rather than special variables.
• <> default filehandle var appears to be ignored.
• Almost all operators seems to be ignored … but ne, cmp, and, and or are highlighted.
• Dereferencing seems only to work for arrays and hashes.
• Heredoc is ignored (should be treated as a string delimeter).
• $# “last element” sigil is ignored.
• Referencing is ignored for all variable types. Matching on /(\\+[\\$@%&\*]\w+)/ should cause $1 to be seen as a ref (greedy matching) … (note that \\\\\\$foo is valid).
• Subs and globs and file handles are ignored.
• The => “comma alternate” operator should be interpreted as a comma, forcing the left-hand operand into string context. Matching on /[^'^"](\w+)\s+=>/ should cause $1 to be interpreted as a string.
• Package namespaces are a little wierd. Perhaps matching on :: as a left-or-right sigil will help catch the first tier (as in line 76). Priority should be given to packages preceded by variable sigils, and the whole thing should be marked as a variable.
• Most of the special variables are excluded. Generally they can be interpreted without a subsequent \w+ match. Some have special cases, like the @_ variable (sub arguments), which can be accessed via @_[$index].

In a work project, I had to find the difference between two arrays bidirectionally. I didn’t just need to know which elements were not common, I had to know which were in one and not in the other.

An inefficient — but conceptually straightforward — approach is to loop over the two arrays:

Ugly. One major problem with this is that you then have to invert the loop nesting and search @a against each element of @b to get the mirrored.

That’s not very pretty, so after a bit of thought, I decided upon the following approach to the problem.

Let’s assume I’m working with two arrays of numbers (though they can contain anything): (1,2,3,4,5) and (3,4,5,6,7). The overlap is (3,4,5) and the differences are (1,2) and (6,7).

Now @foo_only contains what’s in @foo and not in @bar and vice versa for @bar_only. The best part is that we only had to loop over each of our original arrays twice, and incurred the extra cost of only two hashes.

The Bash shell has the terrific feature that as you traverse directories your pwd reflects the perceived path rather than your absolute path. That means that if you move across the file system through a symbolic link, you appear simply to have descended further into the current tree. In other words, Bash preserves the structural illusion offered by symbolic links.

Most of the time that’s terrific! Sometimes you’ll want to be able to see where you “actually” are (such as using pwd to determine your absolute path from the disk root. Thankfully, both pwd and cd have a -P parameter that will puncture the illusion and reveal your true location. For example, let’s say you have this file structure:

Here, ./kung/fu links to ./bar/foo. Let’s move to ./kung/fu and take a look around.

Look what happened in line 8 (after we cd fu in line 7): bash reports our current path as if the symbolic link were a local directory. By adding the -P option (line 10), we get to see our actual location — /users/username/bar/foo. If we had backed out of ./kung/fu using cd .. (rather than cd -P ..) we would have ended up back in ./kung. Instead, by using the -P argument, we told bash that we wanted to move around in the “real” disk structure, rather than in the illusory one created by links, so we ended up in /users/username/bar (line 13).

Neat =)

Diomidis Spinellis, a Grecian researcher, has made a comparison along various lines of the Linux, FreeBSD, OpenSolaris, and Windows Research Kernel kernels in a paper called A Tale of Four Kernels. The abstract states that

The FreeBSD, GNU/Linux, Solaris, and Windows operating systems have kernels that provide comparable facilities. Interestingly, their code bases share almost no common parts, while their development processes vary dramatically. We analyze the source code of the four systems by collecting metrics in the areas of file organization, code structure, code style, the use of the C preprocessor, and data organization. The aggregate results indicate that across various areas and many different metrics, four systems developed using wildly different processes score comparably. This allows us to posit that the structure and internal quality attributes of a working, non-trivial software artifact will represent first and foremost the engineering requirements of its construction, with the influence of process being marginal, if any.

You can read the rest of the paper via the link above.

It’s pretty hard for me to get used to Apple’s “lock-down” mentality. When I was young, my first computer was an Apple ][ Plus that my brother and I got in 1981. We loved it — we translated Choose Your Own Adventure! books into computer games (with graphics!) and even made up a few of our own adventure-sets. We got pretty good, playing classics like Zork and Stellar-7. We had that computer for quite a while, and in the mid-80s started to think about upgrading. The problem was, by the time we were ready, Mac had gone all AOL on us (of course, we didn’t frame it that way at the time) and had gone with a ridiculous graphical interface to broaden its appeal. So, we got a PC so we could use DOS and pretty much ran PC boxes since — mostly DOS and Windows, with an occasional foray into Linux.

A couple of years ago, Mac made one of the best choices ever and switched to a NeXT based system for it’s newest operating system: OS X. That was pretty much all I needed to push me back towards mac — being a programmer and a command-line lover (yes, it is faster if you know what you’re doing), it now had everything I needed: graphics capabilities (Photoshop, Flash, etc. and 3D modeling) as well as command line for serious engine work (Perl development, etc.). I was ready.

Finally, about 2 years ago, I got an iPod (and loved it). In addition to music, I used it as a spare hdd, and did everything I needed to. Great product. About 6 months later, I got my first mac (through my job). It’s a nice, 17″ Powerbook G4 — excellent computer. My main OS is Linux (Ubuntu) which I run on 3 machines at home and at work; I virtualize windows XP and Vista on two machines for work (because I have to do cross-platform testing), and now I use OS X natively on my Powerbook. I’ve had a few troubles with it here and there — mostly character differences between OS X’s underlying system and Linux — but it’s no big deal, just learning a new system.

This past Christmas (’07) my excellent wife surprised me with an iPhone (I had been swooning over them for a while =). I must say, it is a superb device. It has excellent hardware, a smooth interface, and it does almost everything it should. It does have one major problem: It’s heavy into Apple’s lock-down mentality. Let me explain.

I have no problem buying software. I don’t want to steal anyone’s work, I don’t want to rip anyone off. I don’t download music illegally — I buy it from iTunes if I want it (one of the main reasons an iPod and iPhone worked well for me). Everything’s happy-fun. I have a bunch of music from CDs and stuff from GarageBand, etc. The problem is, Apple wants to rule my computing with an iron fist. Everything has to be registered with everything else; I can’t whip out a program and stick it on my iPhone, I can’t read the spec and do something fun like make a little game for my little boy — I basically can’t do anything unless I want to participate in Apple’s philosophy of “the privilege of buying Apple.”

Yesterday my Mac HDD freaked out. I tried to do everything I could to fix it, but it couldn’t be saved. In the end, I had to re-install Leopard (thankfully I had bought into a family pack!).

Anyway, I thought, “It’s a good thing I have my iTunes music and my contacts and calendars on my iPhone! Go Apple!” The funny thing was that when I got everything re-installed and set up, and went to re-sync my phone, the only option available to me was to wipe my phone and sync to the new (empty) library. I could transfer my purchased songs, which is fine, but I couldn’t transfer my non-purchased songs. Anyway, I ended up searching for a very long time to find some free software that would let me mount the phone (to Windows, Linux, or Mac) and grab my stuff, but I couldn’t find anything legal and free. What a weird mentality switch from Linux! I ended up buying some nice software called MegaPhone from a company called ecamm (http://www.ecamm.com/mac/megaphone). It works really nicely and does exactly what it should (plus a bunch of extra stuff like the ability to edit my notes and such).

Anyway, as a friend of mine pointed out, I wouldn’t have gotten into trouble if I hadn’t been counting on my iPhone as a backup. Really, though, I wouldn’t have gotten in trouble if I hadn’t been thinking with a freedom-based mindset. It’s very true, and not Apple’s “fault” — they have the right to have whatever mindset they like — but it’s a very strange one to me. I’m used to thinking in terms of mutual benefit, not … well, I guess I’d have to call it something like, “adversarial benevolence.” I mean really, Apple and users are poised as adversaries to each other; the users want certain things (such as the freedom to distribute apps freely) and Apple wants to see how little it can give and still retain users, as opposed to how much it can give and still retain partners. This dichotomy is key to understanding Apple — it’s got business partners and interests, and it needs users to maintain its goals in those relationships (profitability). It’s 180 degrees off of the mindset to which I’ve chosen to grow accustomed (FOSS, for example) which holds the relationship between provider and user as primary.

C’est la vie; lesson learned. I am starting to lean ever more away from Apple. It’s like a smart, nice, pretty girl who spits and hits and smokes and curses: picking up coarseness and brutality because she can’t tell the difference between strength and force. You don’t mind occasional encounters, but you don’t really want a deep relationship until she gets a bit more wisdom and learns what’s really important.

If you have an array in perl but you don”t know how long it is, there’s a really fast way to get the last element. Use the special variable sigil $# to get the index of the last element of an array. Here’s a clear code example.

Now you know.

I’ve got a .bashrc file that has some functions defined.  Every so often I need to do one of them on a list of files — that I can usually get out of find.  Sadly, if I want to run an alias myfunc on all the files in a dir (recursively), I can”t do it the intuitive way:

Since myfunc is a shell function, it’s not found anywhere in the execution path, and is therefore invisible to find.

But there is a solution!  Instead, we can pipe the output of find through our shell, like so:

Easy as pie.