MATTly

JavaScript: Base64 Encoder/Decoder

Matthew Clark — Sun, 29 Jan 2012 01:48:29 +0000

I recently had a need (or, probably more appropriately, a desire), to obfuscate some data which would be passed to a server in a URL. Of course, it’s impossible to encrypt anything using JavaScript since it executes client-side, but you can certainly obfuscate data enough to ward off most tinkering attempts.

I decided base64 would be the way to go because it generated a relatively clean representation of the data I wanted to pass. Plus, since I’m using PHP server-side, it would be simple to decode using the base64_decode() native function.

Simply use Base64.encode() to encode a string. Also included is Base64.decode() if you need to decode.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

Goodbye, sweet ol’ Jasmine

Matthew Clark — Mon, 23 Jan 2012 01:51:08 +0000

It is with great sorrow and a heavy heart that I share with you the passing of Jasmine, a small, black cat who lived a full and pampered life of nearly 16 years. She and Chantel (the himalayan/ragdoll mix pictured here with Jasmine) were the last family pets my brother and I had at home when we each moved out.

Jasmine came to us in 1996 as a stray kitten we found in our back yard. She was a tiny thing, full of hiss with jet black so all you could ever see were her green eyes. We took her inside, and if memory serves me correctly, she was only a guest until we could find her a home. But after only a few days, my stepdad had given her a name. I remember mom sharing the news, which she promptly followed with, “Well, I guess that means we’re keeping her!”

I remember during the morning hours of one of her first days with us, I went poking around the house to look for her. It didn’t take long, as I found her in my mother’s office tucked away under an office table where mom had some boxes and a folding treadmill stacked underneath. There was just enough room for me to see her eyeballs amid the furry shadow and to reach in a grab the kitten. She hissed as much as she could, but when you’re only a few weeks old, you haven’t yet mastered the ability to cast fear.

In the summer of the following year, we moved across town and Jasmine remained part of the family with two other cats. One of the others had to be given away after she destroyed my mom’s office, leaving just Chantel and Jasmine for the past 11 years or so. Chantel’s getting older, too, and may be with “the rheumatiz” so she tends to stay in her bed most of the time. With Chantel bugging mom less often, that left Jasmine with ample opportunity to befriend my mother and become her regular pal, accompanying her in her office while she graded papers or watched the Bunkers on TV. And Jasmine never let mom forget when 5 pm came around because she would not have a late “scoop”.

Recently, mom discovered some lumps in a few areas on Jasmine, and the veterinarian said she didn’t have much time left — weeks, possibly months. During my last visit at Christmas, I had a chance to feel one of the larger knots behind her ear, and it was terrible thing to find on a sweet, vibrant, and friendly little person.

This morning, I got a phone call from mom. She informed me that Jasmine had not been eating or drinking hardly at all lately and rarely left her sleeping place. Mom figured that Jasmine had no quality of life left and was only suffering now, and any more time was merely delaying the inevitable. She took Jasmine to the veterinarian’s office Friday morning, and we lost her. As youthful as she was, she probably could have lived another ten happy years. But cancer is no joke.

What a good kitty, Jasmine, Jazz, Jazzbone, J-bone, Bone, Jazzerminn… I’ll always remember the first laser pen I bought, and how focused and utterly determined she was while trying to catch the red dot. I’ll always remember how she nearly disappeared in a dark room, and how she could only ever muster half a meow. And finally, I’ll never forget how, while she just loved to be pet, she hated for anyone to touch her head — and I did it anyway. Bye, dear Jasmine.

Unreasonable People

Matthew Clark — Mon, 02 Jan 2012 10:34:31 +0000

We all do it from time-to-time, and some more often than others: allow our emotions to control how we react instead of using logic to properly deal with a situation. As a person who frequently turns to the Internet for information, I often stumble into forums and blog comments where one person says a little more than they should have, and then someone else takes it way out of context or too personal and ends up starting a volatile back-and-forth. Insults, name-calling, and cursing only stoke the flames and turn a campfire into a nuclear disaster.

With this in mind, I try my best to think twice about what I say and how I say it. First, I don’t want to cause a flame war, and second, should one start, it’s at that time I allow my logical mind to overpower my emotions and tell myself “This person cannot be reasoned with, so there’s no point in engaging them; just walk away”. This works pretty well, and I never end up looking like the fool.

But today, I got sucked into one, and I’m going to share it with you.

Earlier last night, the entire city of San Angelo became without water due to a problem down town. The city has a Facebook page, and they were sharing news and updates about the problem there. People from all over were commenting about how slow the city is and how horrible things are because the city is denying them the water. Others were chiming in with things like “Calm down, they’re working on it, just be patient”.

One particular person posted the comment about how water service was being redirected to another part of town, and now other residents are without water. She was actually criticizing city officials’ maneuvers! Then, she commented again, flaming that we have no common sense! I decided to offer a retort, which I now fully admit was a bit over the line with sarcasm, but intended to convey the message that she was speaking on matters of which she has no factual knowledge of. I now know that my comment probably wasn’t well-received, but she could have been the better person and ignored me. Instead, she chose to totally lose her mind.

Below is the transcript:

You’ll see her accusations that I deleted my own comments, but I had not — I commented four times, and I deleted nothing. You’ll also see where my wife eventually jumped in, but her participation was solely out of an interest to see just how far over the handles this girl would fly. I chose to remain out of it for the most part due to the aforementioned reasons, and the few additional comments I did post were quite civil and mild, I thought.

Her claims that she knows me are only slightly correct, although at that time I had no idea who she was. I later confirmed that she’s the daughter of one of my co-workers — a detail she was trying to use against me. Yep. She was threatening to come to the office and tell her dad. I don’t know who she thinks I am, who she thinks she is, or who she thinks her dad is, but I get along just fine with her dad. Plus, I doubt he’s interested in this shit.

So what if she does come to the office? I already know what’s in her playbook, and she won’t be there to excercise civil conversation. Thus, I’m prepared to let her say what she wants, and I’ll just smile. When she’s finished, I’ll ask her to leave the building and calmly shut my office door.

Was I wrong? Yes. There was nothing I could say that would have served my purpose without getting her feathers in a twist. And there would have been nothing that anyone could have said to cause her to re-evaluate her comments. I was doomed from the beginning, so the thread above is actually my fault. However, she, too, had a responsibility to maintain her bearing, and she chose to throw it right out the window.

My point behind sharing this is to let it be a reminder to all of us that unreasonable people are out there. Try to identify them early and do not engage them because you will not win. But more importantly, do not be that person! There are already plenty of assholes in the world, and it’s well worth the effort to stop and think about what we’re doing to each other. My mother always says to me, “Be nice!”

The evolution of the geek

Matthew Clark — Wed, 28 Dec 2011 03:41:23 +0000

It will forever be a huge source of amusement for geeks that they are now officially deemed cool. It’s true. There have been surveys and everything. ‘Experts’ have been saying so since the early 2000s, but I don’t think anyone truly believed it until technology began to get ultra cool. Who was behind it? Geeks of course.

The social networks like Facebook, the online games like World of Warcraft and partypoker, the amazing improvement in film and game graphics, the iPhone. They have all come about thanks to the imagination of geeks, and the non-geeks of the world finally acknowledge that, ultimately, we rule the world.

In a recent telephone survey of 1,000 American adults, an impressive 57% said that they would take it as a compliment if someone called them a geek. It also found that 65% of those asked, agreed that everyone has a geek inside of them somewhere. 20% admitted to being one.

A lot of people don’t know the evolution of the term though. For example, did you know that a few decades ago, geek was used to describe a carnival freak? Think Quasimodo or the random dude who ate rats alive. Seriously, they were called geeks.

Years down the line, technology is invented, and with the rise of the computer, ‘geek’ became the word to describe a socially inept individual who loved the Commodore 64 computer more than food. And they weren’t popular for it.

Nowadays it is a term of endearment among technology lovers. Everyone loves a good gadget, so knowing a geek is a bit like knowing a doctor. You can go to them for your technology ailments and we can impart our wisdom on to you. And by that I mean, we get your tech out of a sticky spot.

In conclusion: once an insult, ‘geek’ is now seen as a term of endearment. It’s funny how times change.

Rails: clean old ActiveRecord sessions

Matthew Clark — Sun, 27 Nov 2011 02:54:35 +0000

If you use ActiveRecord for session storage, you’ll find that the sessions table fills up quickly. reset_session deletes the current session (say, when implemented in a logout action), but stale sessions can still build up when a user simply closes their browser. To combat this, here’s a simple solution using a class and a cron job (Rails 3.1 and Ruby 1.9.2 under RVM):

Create a file called session_cleaner.rb and place it in the lib folder:

1
2
3
4
5
6

class SessionUtils
def self.cleanup
session_store = ActiveRecord::SessionStore::Session
session_store.delete_all( ['updated_at , 1.hour.ago] )
end
end

Then, in a cron job, you can simply execute the following however often you determine is adequate to prevent buildup in the table (higher traffic applications may want more frequent cleanup, but every hour should be a good start):

1	/var/www/my_rails_app/rails runner -e production "SessionUtils.cleanup"

Of course, substitute /var/www/my_rails_app with your application’s path.

Also, keep in mind that if your sessions table fills up very quickly (due to a high-traffic application), that deleting can be interrupted while sessions are being created or updated due to lock contention on the table. So don’t let your cron job run so infrequently that each invocation ends up having to delete millions of stale records! Do as little as possible more often.

Important note: if you’re using expiring sessions, you’ll want to ensure 1.hour.ago is greater than your session expiration time in order to give your idle users time to resume their active session without being kicked off prematurely.

Generate vertically-ordered HTML table in Ruby

Matthew Clark — Wed, 23 Nov 2011 14:15:59 +0000

In a major Ruby on Rails project, I recently had to generate a table of data which had to be organized with data flowing from top-to-bottom in each column before moving on to the next column, instead of left-to-right. This seems simple, but I had trouble getting my head around it for some reason (maybe it was a long day and my brainz were just tired).

Anyway, for those of you who are as easily confused as I am, here’s how to do it. Note: the instance variables in this example are used simply for clarity in identifying what controls the number of columns and rows.

1
2
3
4
5
6
7
8
9
10
11
12

<%0.upto(@rows_per_column-1).eachdo|row|%>

<%0.upto(@columns-1).eachdo|column|%>
<% index = row +(column *@rows_per_column)%>

<%end%>

<%end%>

<%= index %>

The above will yield the following if @rows_per_column = 5 and @columns = 3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

…which will render thusly:

1	6	11
2	7	12
3	8	13
4	9	14
5	10	15

If you are looping over a collection (say, from ActiveRecord), you can distribute your data evenly into a static number of columns with @rows_per_column = (@collection.count.to_f / @columns.to_f).ceil. Then, to ensure your last column doesn’t generate more rows than you have data, simply use ... unless index >= @collection.count in the table cell.

Keeping track of JavaScript timers

Matthew Clark — Thu, 20 Oct 2011 02:13:24 +0000

While working with a complex AJAX script today, I discovered a long-standing problem with an interval timer duplicating itself. I spent most of the morning trying to figure out ways to prevent more than one instance of the timer from firing, but since the timer could be stopped and restarted based on user interaction, there had to be another way. Well, I’m here to show you a nifty solution so you don’t have to learn the heard way like me.

Typically, when you create timers in JavaScript, you created them like so:

1
2
3
4
5
6
7
8

var delay = 5000;
setTimer(function() {
// Do something once after delay
}, delay);

setInterval(function() {
// Repeat something after every delay
}, delay);

And, as you may already know, if you want to clear a timer, you have to keep track of it by assigning its return value to a variable (which is an integer ID):

1
2
3
4
5
6
7
8
9
10
11
12
13

var delay = 5000;
var thisTimer = setTimer(function() {
// Do something once after delay
}, delay);

clearTimer(thisTimer);

var thisInterval = setInterval(function() {
// Repeat something after every delay
}, delay);

clearInterval(thisInterval);

But what happens if the variable you’re using to keep track of your interval is overwritten with another setInterval()? Well, now there’s no way to stop the first interval because it’s ID has been overwritten with the ID of the second interval. So now you have no idea how to get a handle on the old timer, so it will continue to run, and the only way to destroy it is to refresh the page.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// Set the delay to 5 seconds
var delay = 5000;

// Create the interval and assign it's ID to a variable
var myInterval = setInterval(function() {
alert("Hey, it's been " + (delay/1000) + " seconds!");
}, delay);

// Let's overwrite the old interval with a new one (uh, wrong)
var myInterval = setInterval(function() {
alert("Hey, this is a new interval!");
}, delay);

clearInterval(thisInterval); // <-- This will stop the second interval, but the first one will keep going!

Now this may seem like an easy situation to avoid: simply call clearInterval() before re-using the variable. But in the case of a function which not only controls a timer, but also loops onto itself and acts based on user input, there could be a condition which would cause an additional timer to spawn in the loop without clearing the one(s) which preceded it.

But I have a very easy solution, my friends! Instead of assigning the timer to a variable, let’s push it into an array!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// Set the delay to 5 seconds
var delay = 5000;

// Set up an array to contain all timer IDs
var allTimers = []

// Create the interval and assign it's ID to a variable
var allTimers.push(
setInterval(function() {
alert("Hey, it's been " + (delay/1000) + " seconds!");
}, delay)
);

// Let's add another timer without losing track of the other one
var allTimers.push(
setInterval(function() {
alert("Hey, this is a new interval!");
}, delay)
);

Now we have an array, which will contain something like [64,66]. Cool! Now we can keep track of both timers. But you may be thinking, “Big deal! I can just use different variables for each timer, so this doesn’t solve anything!” Woah, there, ace. Here’s the other cool part about storing timer IDs in an array:

1
2
3
4
5
6
7
8
9
10

// var allTimers was set earlier

function killTimers()
{
// Use each timer ID to stop that timer
for(var i=0; i<allTimers.length; i++) clearInterval(allTimers[i]);

// Then empty the variable to keep a clean house
allTimers = [];
}

Now, all you have to do is call killTimers() and all timers that you pushed into the array will be cleared. So now you may be asking again, “So I still don’t see how this is better than assigning each timer to its own variable.” Yes, I know, but here’s why…

Lets create a scenario based on these assumptions:

You have an AJAX loop which repeats itself with myAjaxTimer = setInterval()
You have a button that a user can click which will perform an action (say, open a dialog box), and stop the timer in the meantime clearInterval(myAjaxTimer)
The dialog contains a form which posts data and waits for an AJAX response before closing itself
You want to restart the timer after the dialog has been dismissed (yep, myAjaxTimer = setInterval() again)

The problem here is that the timer can overwrite it’s previous ID, which can happen if, perhaps, there was a significant enough delay between the time the dialog dismissed (timer restarted) and the user clicking the button again (clearing a timer which hasn’t been started yet). The longer the delay during this time, the opportunity to have a rogue timer is more likely.

By assigning your timer IDs with array.push(), you’ll never overwrite another timer. Hopefully, based on this scenario, there will only ever be one timer ID. When you want to clear your timer, the killTimers() function will clear it, along with any others that may have started for whatever reason.

I realize this may have been a bit difficult to follow as I used some quite basic examples which don’t really illustrate the problem well, but if I’d used actual code from my script, there would have been way too much to look at and get distracted with (hence why I spent all morning debugging my rogue timer problem). There are all sorts of ways to fix this problem with looping AJAX calls and preventing them from duplicating themselves, but in my particular situation, this was the most appropriate solution. I just had to share it in case it may help anyone else.

Define “plugged in”

Matthew Clark — Fri, 14 Oct 2011 22:27:51 +0000

Did you see the movie Social Network (a.k.a. the Facebook movie)? It was about the founding of the most popular social networking site, and in it was a term used many times: “plugged in”. Well, I’m under no illusion that I am or can be among the elite when it comes to software programming, but the fact is I am a programmer, and I tend to become “plugged in” quite often. But what does that mean?

I may be forgetful from time-to-time… actually, I am forgetful. A lot. I remember one of my first jobs working as a clerk in a pastoral care department at a hospital. I can distinctly remember my boss handing me a stack of documents to copy, collate, and staple. She would tell me how many of each, and I would confirm her request. Just as I stepped into the hallway, I would totally forget what she just told me and I would have to pop back in and ask, “How many?”

As an IT professional (most of which is in the past, but I still practice), I’ve worked with IP addresses, MAC addresses, and other numbers — all of which I can forget before the person telling me finishes. Hell, there even been times when I forget where I am in the middle of dialing a phone number! We all have our quirks, I guess, and that’s one of mine.

I’m also not a very good multi-tasker unless the tasks are highly related to each other in some way. Like a lot of men (and you can Google this shit), if my phone rings, I have to stop what I’m doing, mute the TV, and tell everyone else to shut the hell up before I can answer my phone. If someone other than the caller begins to speak, then I can’t discern either person and I have to ask the caller to repeat himself.

But check this out: once I get into coding something, whether a website, iPhone app, or HVAC automation controller, I can lose time like a coma patient. I can’t tell you how many lunches have been completely skipped or how many times I’ve found myself completely alone in the office with sunset approaching. I’ve even missed scheduled phone calls, meetings, and even entire dates because I’ve been so deep into some kind of programming. And, it’s not beyond me to completely forget what day of the week it is! Oh, and I can’t imagine how irritating this must be to my wife, who doesn’t give me near as much hell as maybe I deserve.

Before I saw the Social Network movie, I’d never heard the term “plugged in” before. But as soon as I heard it, right there in the theater, I knew immediately what they were talking about and I became overwhelmed with joy. I now had a term to describe this ability to completely lose time while engaging in long bouts of geeky über-productivity. But having that ability comes at a price.

Being plugged in is not something that you simply “do” — something than can simply be toggled. Plugged in is a state that you reach, like terminal velocity; throw a penny off a tall building, and in time, it will finally reach its maximum speed as it plummets to the earth, but it certainly won’t start out at that speed. And to really drive this one home: ever watch a chainsaw juggler? He’ll start with a couple, and then throw a few more in as he gets his rhythm. But instead of chainsaws, a programmer works at getting his various trains of thought going with enough momentum to keep them all going as he hops from one thing to another.

While writing code, I can have several trains of thought running through my head. Each train of though can be associated with several open files, editors, compilers, command consoles, debuggers, log files, and browser windows loaded with reference pages. I can keep track of all of that, and I can be extremely productive! …until my phone rings. Kablammo.

When someone who’s plugged in gets interrupted, horrible side-effects are to be sustained immediately as well as long-term. For me, I find it very difficult to switch gears and get my little brain to focus on something different. I sometimes come across as rude and abrupt, and even annoyed even though I am not. I know this about myself, and I try to control it, but that’s part of the switching gears thing — a circular dependency. It takes me several minutes to get my mind off of the code I was writing and back into reality.

Meanwhile, all those trains of though that were running so smoothly and safely around the room come crashing down like a bad day at Amtrak. In fact, if you look closely at someone who was plugged in and has just been interrupted, you can see a faint haze of smoke all around and the smell of a caffeine fire being snuffed out. But the problem is not necessarily the interruption itself, but in the recovery. The longer the interruption, the bigger the mental mess.

A short interruption usually isn’t fatal and doesn’t cause permanent damage, and the trains of thought had enough momentum to keep themselves going, and I can catch ‘em and get right back to speed. But when recovering from a long interruption, a programmer like me is faced with several open files and windows, and if the interruption was long enough, he can find himself clicking around trying to figure out just where the hell he was. I don’t know about others, but for me, it’s like being in a horrible accident and not remembering anything before it. “Wow, all these open windows… WTF was I doing here?” So after a few minutes spent clicking and looking at what’s open and where files are scrolled to, I started to get a new idea of what I want to do and where I want to go.

Later on (minutes, hours, weeks), a programmer will begin to find bugs in his application. While this is normal in the software development lifecycle, some of these bugs will be obvious and cause the programmer to ask himself, “What he hell was I thinking when I wrote that?” Well, whenever that was written, he was probably recovering from an interruption! Now, typically, mistakes happen when the programmer is stressed, tired, or distracted. But the really odd, yet obvious mistakes are often a direct side effect of being interrupted while plugged in.

If a interruption lasts for weeks or months, even the faintest traces of thought can be eroded away long before I get back to the project. Getting started again can be very difficult without some sort of physical note on where I left off.

When someone is plugged in, the only safe way to stop is to find some sort of progress checkpoint at which he can safely terminate some trains of thought and pause the others. This is the only way to prevent future confusion, inconsistencies, and colossal WTFs. Sometimes after being plugged in for an extended period of time, we begin to “awaken” and realize that, for some reason, we need to stop… but can’t right now. So I continue to work, but now with a heightened sense of urgency like Mario trying reach the flagpole before the clock runs out. But, eventually, we’ll reach that moment of git push origin, and then we can join the rest of reality and relax. It’s at this point that something is overdue: sleep, food, or smooching the wife.

Being plugged in is a serious state. When a programmer is plugged in, he’s on a roll; don’t mess with him.

Goodbye, Steve

Matthew Clark — Thu, 06 Oct 2011 03:03:05 +0000

I still can’t believe it. He’s gone — a legendary business man who created a market for people who were more interested in a product that worked, rather than how it worked. He stepped down from Apple as the CEO only a few weeks ago, and I knew it was because of his un-winnable battle with pancreatic cancer, but I didn’t think it would take him so soon. I’m still in shock.

Apple’s website remembers Steve with the following:

Apple has lost a visionary and creative genius, and the world has lost an amazing human being. Those of us who have been fortunate enough to know and work with Steve have lost a dear friend and an inspiring mentor. Steve leaves behind a company that only he could have built, and his spirit will forever be the foundation of Apple.

It was one of my secret wishes to meet Steve Jobs. I guess it was unrealistic, but still, it’s almost like losing a friend.

RMagick on Mac OS X: segfault?

Matthew Clark — Sun, 02 Oct 2011 05:43:08 +0000

Here’s a quickie for ya. I recently found that using the rmagick gem causes a nasty segmentation fault on my Rails 3.1 development machine, which happens to be a Mac running OS X 10.7 (Lion). I use ImageMagick from MacPorts with Ruby 1.9.2, and here’s what I had to do to get rmagick working:

gem uninstall rmagick
sudo port uninstall ImageMagick
sudo port edit ImageMagick
Add --disable-openmp to the configure.args section
sudo port install ImageMagick
gem install rmagick

This may also apply to 10.6 (Snow Leopard).