Cell Phones/Electronic Devices/Personal Property:

The cell phone/electronics policy is stated that a a student with a cell phone or electronic device out, the device may be confiscated and a parent must pick up the confiscated item when it is available for pick up, which is only on Thursdays from 2:00pm till 3:30pm. Personal electronic devices, i.e., beepers, CD players, radios, electronic games or any unnecessary devices deemed potentially disruptive shall not be allowed at school.

Cell phones shall not be activated or used during school hours or on school buses. The school shall not accept responsibility for cell phones, personal electronic devices or personal property of any kind including money. Failure to comply with these procedures may result in confiscation of cell phones, electronic devices or personal property and students will be subject to disciplinary action for repeated offenses.

Wait, let’s back up there. A parent can pick up their child’s electronics “only on Thursdays from 2:00pm till 3:30pm.” What parent can make it to the school at that time? Most parents have work or job interviews to be at. And cell phones are not only a means for social interaction — they are necessary for communication between family and in emergency situations. What happens when a student’s phone is taken away on a Thursday? They can’t call their parents to come get it. It’ll be a week before they might be able to have their phone again.

Anyways, this post is not about the flaws in their policy. It’s about the flaws in following their policy.

In March, I was walking down the hall to lunch listening to my iPod. A Mr. Medvin pulled me aside, took my iPod, headphones, and my name (he didn’t write it down). For two Thursdays afterward, I went to the main office to get the iPod back. The first time I visited, I found out about the electronics policy. I’d hoped a simple phone call to my dad would allow them to relinquish my beautiful, shiny sound maker. However, that turned out not to be the case, as neither the man guarding the electronics (Luis Rodriguez) nor the principal would accept a phone call on the spot.

I then asked my dad to call in ahead of time, so the school could give my dad the whole spiel about how I’m a horrible kid and I should never bring my iPod into school, and they would finally hand it back to me. Instead, the administrator on the phone told him he needed to come into the main office between 2:30PM and 3:30PM on Thursday with photo ID. “Screw that,” my dad and I thought. I lived without music for a couple of months, which really sucked, but I made it through somehow. It probably forced me to interact a bit more socially, but that’s the only good consequence.

Finally, my dad was able to drive in — this was yesterday, Thursday, May 14, 2009. He met Mr. Luis Rodriguez in the main office and presented his photo ID. There was no talk about the school’s electronic policy. They just wanted to punish the parent for the student’s mistake by hassling the parent until it becomes such a bother that they make sure their kid doesn’t screw up again. Of course, this doesn’t work at all. It just breeds hatred and noncooperation between the parents and the school.

Mr. Rodriguez searched through the basket of assorted iPods, Sidekicks, and Zunes enclosed in brown clasp envelopes. Searching, searching, searching…”Nope. No iPod here registered to your son.”
My dad: “Alright, what happens now?”
Rodriguez: “Well, you can check in Student Affairs or talk to an administr–”
My dad: “No, no. I followed your policies and instructions exactly as I was told. Where is my son’s iPod?”
Rodriguez: “I just don’t know.”
My dad: “Is there something I can sign to prove I was here to pick it up?”
Rodriguez: “No, there’s only a log to be signed when I hand something back.”

That’s my secondary vision of the exchange that occurred from details provided by my dad. This happened roughly around 2:45PM. When the final bell rang at 3:00PM, I walked to the front office to make sure my dad received my iPod, completely unaware of my dad’s interaction with Mr. Rodriguez. I was in for a surprise when Mr. Rodriguez told me he couldn’t find it. This time, however, he redirected me to the Principal’s Secretary, a Ms. Beverly Keeter.

Ms. Keeter took down some of my contact information, including my name, student number, description of the iPod, and an estimated cost. She assured me that if the school was unable to locate my iPod, they would replace it. She asked me to print out the product from Best Buy to get an actual price.

The next day, I returned with a print out of the Best Buy page for iPod Nano of equal value to my iPod ($199, according to Apple’s original press release: http://www.apple.com/pr/library/2006/sep/12nano.html). When school ended that day, I went to check the progress of Operation iPod Locate with Ms. Keeter. She informed me that Mr. Medvin never turned in my iPod, nor does he recall taking it away. She also said it was now up to the principal, Jake Russell, to decide what happens next.

I’m hoping they don’t ignore me. That’s why I’m writing this post. They can’t ignore it. I believe they have my stapler iPod.

Edit 05/18/2009: They found my iPod. It was filed under the wrong kid’s name.

I did a bit of research on programs for Linux that allowed the drums to be played. I didn’t find anything that looked too promising, but this post opened my eye to a very useful detail: the Rock Band 1 drums are recognized as a joystick. That post goes on to display a C example of a drum sounds simulator using SDL. I don’t like C, because of all the problems it tends to effect (linking errors, the verbosity it requires, etc), so I went about writing my own drum program in snakes Python.

Using pygame, a Python SDL wrapper, I wrote a simple test program that associated drum pad hits with audio samples. When a pad or the pedal was hit, it would play a sound — quite basic. I Googled for drum sounds and discovered this page to my good fortune. With the drum samples found there, Yak’s Rock Band PS3 Drums was born. (I couldn’t think of a better name.)

Since writing that simple script, I have added the ability to record and replay beats and a rough GUI designed in Glade.

For the script and a screenshot, CLICK THE DAMN LINK!

As you can see, the GUI is mostly a picture of the PS3 drum set. When you hit a pad, it’s filled with its respective color. That’s all I can pull off in GIMP…

Anyways, I’ve zipped up the whole package, including the sound samples — I could not find any sort of copyright notice, so I’m going to assume that they are in the public domain *cough*. Yak’s Rock Band PS3 Drums requires Python, pygame, and GTK+2. While I have not tested the program on Windows, it should work.

Grab it here: http://y4kstudios.com/rockband.zip

Happy drumming!

Edit (02/15/2009): There was a *slight* problem with the first GUI release: the main loop used 100% CPU. I remedied that by having an internal clock with 30FPS. I believe that’s a high enough rate that the delay between hitting the pads and the sound being played is unnoticeable, or at least very hard to notice. (30FPS == 1 update every 33.3ms)

Bread clips are the bane of my fridge-going experience. Most of the time our bags are sealed with twist ties, but occasionally these rotten crapples pop in to send salutations and a slap in the face.

When the bag has a twist tie, the usage is as simple as untwisting, retrieving the contents of the container, and retwisting. Not for bread clips, though. Oh, no, they can’t be that easy. Trying to take them off yields ripped plastic and broken seals. One would be lucky to get the bag open enough to pull anything out. But if one is successful, failure is a sure shot when attempting to reapply the little buggers. However, if one somehow defies the Laws of the Kitchen and applies the clip, it’s already bent three ways to hell.

Basically, bread clipping is akin to waterboarding. Some may construe it as legal, but it hurts everyone in the end (possibly dead, too).

Fuck bread clips.

This little bit here prints out the process ID and process name of the process with the specified open port.

#!/bin/bash
ps -p `netstat -pantu | awk "\\$4 ~ /$1$/ { split(\\$NF,pid,\"/\"); print pid[1]; }"` -o comm= -o pid= 2> /dev/null

`netstat -pantu` prints the open ports using the UDP or TCP protocol and the process IDs of the processes that opened the ports. The awk line parses netstat so that it prints only the process ID. Then the ps line prints out the process name and PID. The ending 2> /dev/null stops ps from printing out its help text when there is no process with the specified open port.

The warning that appears above explains that one must `sudo` to see all the processes.

However, if you’d like to just know the PID of the process with the open port, remove the ps, like so:

#!/bin/bash
netstat -pantu | awk "\\$4 ~ /$1$/ { split(\\$NF,pid,\"/\"); print pid[1]; }"

Then you could do this:

Which will kill the process that opened the port. (When I ran that command, I ended up crashing Steam…)

[abs(x) for x in mylist]

I looked at the documentation for max() in ipython, and found an argument not in the online Python documentation: key. ‘key’ is a keyword parameter accepting a function with one argument. This function does whatever the hell it wants to every number passed to max() and then returns it. This simplified what I needed to do:

#!/bin/sh
for pid in `ps -eo pid=`; do 
    if `ls -l /proc/$pid/fd 2>-| awk '{print $10}' | grep -q "$@"`; then 
        ps -p $pid -o comm= -o pid=
    fi
done

ps -eo pid= prints out all the process IDs. /proc/PID/fd contains the file descriptors of all the files opened by that process ID. ps -p $pid -o comm= -o pid= then prints out the process name and PID of that process. Simple as pie!

Has this ever happened to you? It wouldn’t have, if only you had used a self-destructing link!

What’s a self-destructing link, you say?
A self-destructing link is a URL that redirects to a specified hidden URL until certain limits are reached, such as amount of views or time. If X amount of people have visited the URL or Y amount of seconds/minutes/hours/days/eons have passed, the URL will no longer redirect to the hidden URL.

Boy, theY4Kman, that sounds even cooler than falling and missing the ground. How do I create my own self-destroyerzing thingamadoodads?
Well, avid reader, I’m pleased to inform you that I’ve created such a site for your eyes only! Just head on over to LinkDestruct (http://linkdestruct.com), follow the instructions, and you’ll be off in no time growing generating your very own ch-ch-chia self-destructing links.

What was that link again?
http://linkdestruct.com

Er?
That number again was 1-800-DESTROY (1-800-337-8769)

Don’t forget to Share and Enjoy!

I tried to implement some algorithms far into the book, such as Huffman data compression, but after attempting that, I realized the need for lower-level data structures; those data structures introduced at the very beginning of the book. I restarted my perusal from the first few chapters, and I’ve now successfully implemented a Priority Queue using a Heap data structure. Code after the jump (I’ve always wanted to say that, but I’ve also always wanted to punch people in the face for saying that. I’m gonna have a hard time explaining this black eye to my friends.)

class HeapPriorityQueue
{
private:
    /// Our heap/array.
    int *m_pHeap;
    /// Length of our array/heap.
    unsigned int m_iMax;
    /// The largest used index in the heap at the moment
    unsigned int m_iN;
 
    /**
     * Uses the passed index to sort the item up the tree.
     * @param   k: index to the internal array
     */
    void upheap(unsigned int k)
    {
        if(k > m_iN) return;
 
        unsigned int j = k;
        int val = m_pHeap[j];
 
        while((k /= 2) > 0 && val > m_pHeap[k])
        {
            m_pHeap[j] = m_pHeap[k];
            m_pHeap[k] = val;
            j = k;
        }
    };
 
    /**
     * Uses the passed index to sort the item down the tree.
     * @param   k: index to the internal array
     */
    void downheap(unsigned int k)
    {
        if(k > m_iN) return;
 
        unsigned int j;
        int val = m_pHeap[k];
 
        unsigned int limit = m_iN / 2;
 
        while(k < = limit)
        {
            j = k + k;
 
            // Move to the right child if it is larger than the left child
            if(j < m_iN && m_pHeap[j] < m_pHeap[j+1]) j++;
 
            // If `val` is larger than both children of `k`, we're done.
            if(val >= m_pHeap[j]) break;
 
            m_pHeap[k] = m_pHeap[j];
            k = j;
        }
 
        m_pHeap[k] = val;
    };
 
public:
    /**
     * @param   max: The amount of items to be stored in the queue.
     */
    HeapPriorityQueue(unsigned int max) : m_iMax(max), m_iN(0)
    {
        m_pHeap = new int[m_iMax];
    };
 
    ~HeapPriorityQueue()
    {
        delete [] m_pHeap;
    };
 
    /**
     * Insert an item into the queue.
     * @param   val: Item to add.
     */
    void insert(int val)
    {
        if(m_iN >= m_iMax-1) return;
 
        m_pHeap[++m_iN] = val;
        upheap(m_iN);
    }
 
    /**
     * Removes the largest item from the queue and returns it.
     * @return: Largest item from the queue.
     */
    int remove()
    {
        if(m_iN < = 1) return -1;
 
        int val = m_pHeap[1];
        m_pHeap[1] = m_pHeap[m_iN--];
        downheap(1);
 
        return val;
    }
};