In the meantime I’ve been doing a little work around the house and on the car, and I’ve also done a little C programming, just for the heck of it.

I’ve revisited my infamous random sort algorithms. I used variations of a random sort algorithm in my data structures and algorithms class at UWYO, one or two homemade tests, and on a test for course placement at UTA (with a whole lot of controversy around that).

The one at UWYO was what I like to call the “shuffle the deck” variation. You assign each element in whatever list you want sorted a new place in the list, chosen randomly but only using each place once, and then check to see if it’s sorted. Repeat until the list is sorted. I remember doing this cleverly, but I can’t remember exactly how. I’m working on recreating it. (This is known as a Bogosort, apparently I wasn’t the first one to think of it.)

The one on that test at UTA was a simple swap two values, and check if sorted. It was all from memory in pseudo-code. This, also, is known as a Bozosort. All I had to do, according to the instructions, was to “Write, in pseudo-code, a sorting algorithm.” So, I wrote a sorting algorithm. I got bad marks on that test (but was still able to pass after a small scolding). Unfortunately, my requests to see the actual graded test went against deaf ears…

So, anyway, here’s what I have:


int isSorted(int array[], int length)
{
int c;
for (c = 0; c < (length - 1); ++c) if (!(array[c] <= array[c + 1])) return 0;

//rands2 - Shuffle sort v0
void rands2(int array[], int length)
{
int i;
while (!isSorted(array, length))
{
//give each array value a new index from an index pool and swap them all
}
}


I haven’t quite implemented my favorite yet. I have timed the sorting of random lists from 2 to 12 items long, each 1000 times. I turns out that sorting a list from 2-9 items is, as far as a human can tell, just as fast as quicksort and the like. It’s that magic number 10 where things start taking time. Then at 11 items it’s already unbearable. At a list size of 12 items it took 54 hours to sort 1000 unique lists, the average one taking 3 minutes or so.

I’m working on the bozosort, and can’t wait to see how slow it is.

I’ve personally witnessed, as a computer lab assistant (who wasn’t supposed to be helping people with homework), as a CS student (trying to help other students), and as a IT person, that there are two groups of people: Those who get computers, and those who don’t (like, really do not get it).

First, as an IT support guy, there are people that I rarely ever have to help. The users can either figure it out by themselves or look it up themselves. Then, there are people who stop at the slightest bit of unfamiliarity, and call me. Of course, there are people that are a bit of both, but most stick to one side or the other. There’s a gap.

There’s another gap between programmers and non-programmers. Well, no. I know some computer savvy people that could probably learn to program without much fuss. Let me say it like this: There’s a gap between people that can program and people that cannot program.

And it’s glaring. It’s more like a sharp divide. It’s pointy.

When I worked as a computer lab assistant, I ran in to these two students who were in a beginning programming course, I think it was Java. It was some C style language. Whatever.

Anyway, first of all, their code was the ugliest shit I have ever seen. Before I could help them, I had to reformat all their whitespace so I could read it. Then I tried over and over again to explain to them the various reasons why their programs would not compile.

They never got it. I ended up doing their work for them just to get them to stop bothering me. I’ve seen people in my CS classes who just don’t understand the simplest things, like assignment or logic/conditional statements. It seemed to me like they were expecting to learn each program character by character–that by studying each line of someone else’s code they would “learn” how to do it. It seemed that they couldn’t take a step back and abstract any of the problems. There had to be a certain way to do it and that was it, it had to be some certain combination of key strokes to make it work.

I’m probably not explaining this well. It’s not about key strokes, it’s about understanding the problem, and the ways a computer can and can’t solve that problem, and what ways are the most efficient. Only then is it about key strokes and code.

How are these people graduating?

Speaking of random, I was (am) attempting to make my own version of the MegaLogViewer for Megasquirt. In this attempt, I happened to notice that my Z31 cranks at 280-325 or so RPM. This is not a big deal, it’s just that I have my MS box set to interpret anything at 300 RPM or below as “cranking”. It applies a whole different fuel factor to the engine when cranking versus running, which is 301 and up RPM.

So, this could explain why my car is hard to start sometimes. One of these days, when I’m not busy studying (which consists of mostly me running errands and otherwise not studying), I will up the cranking RPM to 350 or so and see if I can finally get some positive feedback from modifying the cranking pulsewidths. Before now I was pretty much shooting in the dark, with some settings working some of the time.

Here’s a screenshot of my program so far. It’s in C#, and it’s horridly put together right now. All it does as of now is load files (up to a million records long, anyway), parse the data in to memory, and draw unscaled graphs of the first x records. Where x is the pixel size of that picturebox control you see there (the actual graph):

MSLog Preview

The ticker control at the bottom is eventually going to “scroll” the graph. Right now it does do something, it scales itself according to whatever file is loaded (thus, however many records are loaded), but I’ve yet to implement the scrolling feature.

Needless to say, I uninstalled it. MediaWiki it is. Darn.

That narrows it down to a Visual C++ program installed in “C:\Program Files”, thanks!

Not only is the message box’s title botched, but they didn’t even bother to enter “Their application name”.

I made sure, after I shutdown Windows after exit the program, that I turned off a computer. This reminds me off the signs in the restrooms at school: “Please make sure toilet is flushed”. Meh, that wasn’t so funny.

And to finish off this post, I give you the almighty Microsoft Installer uninstallation script for Symantec Endpoint Protection:

Don’t be fooled, neither the time remaining nor the progress bar actually indicate anything useful. It actually takes about 3-5 minutes, depending on the computer. It shouldn’t take more than one minute, but perhaps Microsoft or Symantec thought a few useless time-wasting loops were needed. The timer on it is so inaccurate, it quickly jumps down to 1 hour, then 40 minutes, and so on until it reads zero seconds. And then it stays at zero seconds for another minute or two. And then the progress bar repeats a few times, each time rather quickly, though. My question is: Why even bother putting the progress bar or the time estimate there, Microsoft? Why not just say… “Please wait…”

If you “wp-content” folder permission are correct (this depends on your server’s settings, mine required a temporary “chmod 777″), then you will find that the media uploader reports success, but the thumbnail is not loading, and the file path is incorrect.

Right now I am using WordPress 2.8.4. The text in the “Store uploads in this folder” box was “wp-content”, although just to the right it says the default is supposed to be: “wp-content/uploads”. Using this value unmodified results in the actual file being uploaded to “wp-content”, but the database information on the file lists it as “wp-content/uploads”, even though no “uploads” folder existed.

Changing the value to “wp-content/uploads”, the so-called default, fixed the problem:

After changing that, then attempting to upload, the “uploads” directory is created and the file is placed correctly in it. After that, you can change the permissions on wp-content back to whatever they were. The change in permissions is only for the creation of the uploads folder.

Anyway, my Bash scripting skills aren’t exactly great, but I knew what I wanted to do and how to do it, more or less. Here’s the code, I’ll explain later:

#!/bin/bash

# Backup Script
# 2009 Nick Earwood
# TODO:
bsversion=1.6

. /etc/init.d/functions.sh
#ebegin "Initializaing"
#eend
#einfo "The car is in the garage."
#ewarn "Warning!"
#eerror "Error!"

einfo "Nick's Backup Script v$bsversion"

myBase=/mnt/usb
myDir=$myBase/backup
myDate=`date +%Y%m%d`
myFile=$myDir/$myDate.tar.bz2
clearOld=1
createBackup=1

#Check and delete old backups. Must be at least 3 no matter how old.
#Sort of. If 1 file is <21 and 3 files are >21, the 3 files get rm'd, leaving only 1 file.
# Which isn't a big deal, I think.
ebegin "Checking current backups"
if [ $clearOld -eq 1 ]; then
if [ `find . -daystart -mtime +21 -type f | wc -l` -gt 3 ]; then
ebegin "Clearing old backups"
find $myDir -daystart -mtime +21 -type f -name \*.tar.bz2 -exec rm -v {} \;
eend
else
ewarn "Not enough backups exist."
fi
fi
eend

echo Backup Completed `date` >> /var/log/backup
eend
else
eerror "Unable to create backup."
fi

The script, as it stands now, just backs up the main hard disk (minus /mnt, /proc, my swap file, and other dynamic directories). This results in a 7.5 GB bzip2 file. Since it’s on my home server, it’s also somewhat autonomous.

First, it checks for really old backups, and deletes them if there will still be 3 backups left after deleting. This check works when operating normally, but if something or someone were to change the file modification times, the script would delete more than intended.

Second, after potentially clearing out some space, the script checks the amount of free disk space, and will not attempt to backup if there’s less than 25 GB remaining.

Third, if there’s enough free space, the actual backup happens. I have the system output the amount of time it takes to compress everything in to a log file. I eventually want to compound some simple statistics about it.

You’ll notice that the script includes “functions.sh” which provides the pretty init style output, that include file, or at least the location of it, is probably specific to Gentoo, the distribution of GNU/Linux I’m using.

Here’s what my “/var/log/backup” log file looks like:

Backup Started Thu Aug 20 19:20:00 CDT 2009
real 220m24.434s
user 189m50.361s
sys 5m43.754s
Backup Completed Fri Aug 21 00:26:34 CDT 2009

Backup Started Fri Aug 21 14:20:00 CDT 2009
real 216m16.404s
user 186m16.552s
sys 5m32.129s
Backup Completed Fri Aug 21 16:01:43 CDT 2009

Backup v1.5 Started Mon Aug 24 01:30:01 CDT 2009
real 208m32.106s
user 180m19.725s
sys 4m47.159s
Backup Completed Mon Aug 24 04:58:33 CDT 2009
Backup v1.5 Started Mon Aug 31 01:30:02 CDT 2009
Creating /mnt/usb/backup/20090831.tar.bz2...

real 215m57.642s
user 185m56.501s
sys 5m50.068s
Backup Completed Mon Aug 31 05:06:00 CDT 2009
Backup v1.6 Started Mon Sep 7 01:30:02 CDT 2009
Creating /mnt/usb/backup/20090907.tar.bz2...

real 213m39.033s
user 184m2.978s
sys 5m37.151s
Backup Completed Mon Sep 7 05:03:41 CDT 2009


I used “cat backup | grep -v tar:” to get that. The “-v” option for grep is filter out all the tar messages; they all begin with “tar:”, and there are a lot of them.

The script also outputs the last run to “/var/log/backup-last”:
* Nick's Backup Script v1.6
* Checking current backups ...
* Clearing old backups ... [ ok ]
[ ok ]
* Checking free space on "/mnt/usb" ...
* Free space: 188G
[ ok ]
* Creating /mnt/usb/backup/20090907.tar.bz2 ... [ ok ]

It looks nicer in the console, I swear. Anyway, It’s been running as a Cron job every Monday around 1:00 AM. So far, my backup directory is listed like so:

-rw-r--r-- 1 root root 7.5G Aug 20 06:00 20090820.tar.bz2
-rw-r--r-- 1 root root 7.5G Aug 21 16:01 20090821.tar.bz2
-rw-r--r-- 1 root root 7.5G Aug 24 04:58 20090824.tar.bz2
-rw-r--r-- 1 root root 7.6G Aug 31 05:06 20090831.tar.bz2
-rw-r--r-- 1 root root 7.6G Sep 7 05:03 20090907.tar.bz2


The first couple are out of sequence due to testing. But the last 3 are genuine. So far so good, but I hope I never need any of them.