I’ve tried out a couple applications, and found each one lacking:

• Tweetdeck
• DestroyTwitter
• Seesmic

There might be a decent application out there that I haven’t found, but these are the most popular ones available to Windows. It almost feels like people only want to make cool stuff for Macs.

Tweetdeck

Although it’s hugely popular by many, I can’t help but get annoyed at parts of Tweetdeck. To be fair, it’s the closest I have found that meets my needs, but that’s not good enough for me. It can easily handle auto-completing of replies, inserting photos and shortening links. It’s built with the idea of lists in mind, which I particularly like. I’ve currently got a list about MooTools and a list about games. Unfortunately, I have no option of telling the main list to ignore tweets from anyone in a separate list. I don’t want my main list filled with tweets about stuff I’ve already put into it’s own list. I just want a list of “everyone else”, but without having to create such a list and add every new person I follow to it.

I also have gripes about it’s UI. Marking Tweets as “Read” requires clicking individually on this tiny, 5px wide circle. And then after doing that, I must click at the bottom of the list of a tiny icon to “Clear Read”. And I often accidentally click on “Clear All”, since they’re right next to each other, and they’re so small it takes to long to visually register what each icon is.

The notifications system is buggy. Sometimes it hides the summary behind a window, sometimes not. Clicking the notification will bring up Tweetdeck. But sometimes, the notification won’t dismiss itself. Ever. You can hide Tweetdeck again and have a frozen notification sitting in the corner of your screen. The only way to dismiss it is to click it again. The usual behavior is that it should dismiss regardless after a few seconds.

And it’s an AIR application. Now, granted, AIR is pretty cool. It lets front-end developers create apps for the desktop. But given a choice, why would I want to run something in a Flash player all the time? It chews on my memory like a puppy that is teething. It lacks plenty of things that I’m used to having in a Windows app. And it’s integration is buggy (see above about notifications). Next.

DestroyTwitter

While it’s also an AIR app, which means I have similar complaints in that regard, it’s actually less buggy than Tweetdeck. Notifications don’t stick. I still miss my normal Windows feel though.

It has a much nicer way of handling Mark as Read: just check the option in settings to Mark as Read on rollover. And overall, the UI feels much nicer to use than Tweetdeck. You don’t have to hover over the avatar to find your common actions like replying or retweeting.

However, it doesn’t support lists at all. None. Just a single stream of tweets. No thanks.

Seesmic

A native Windows client, and it doesn’t have the Windows XP look either. It generally looks sweet, feels rather Windows-y. I like that it has useful context menus when I right click on things. It’s design is decent excellent. But it’s severally lacking in features. Severely.

It can’t load images from common sources like yfrog, it just launches the browser. While it doesn’t have automatic URL shortening, it does have an Insert Link ability. But my attempts to use it show that it handles errors poorly:

<?xml version="1.0" encoding="utf-8"?>
<bitly>
	<errorCode>0</errorCode>
	<errorMessage></errorMessage>
	<results>
		<nodeKeyVal>
			<errorCode>101</errorCode>
			<errorMessage>Unknown error</errorMessage>
			<nodeKey><![CDATA[http://google.com]]></nodeKey>
			<statusCode>ERROR</statusCode>
		</nodeKeyVal>
	</results>
	<statusCode>OK</statusCode>
</bitly>

Seesmic just dumped that straight into my message. And then it kindly warns me that I’m 282 characters over the limit.

While it supports lists, it has the same issues as Tweetdeck in that regard. But, clearing the timelines can also be wonky. I’ve clear my MooTools list timeline, and then added a new person to the list, and it just went out and refilled the entire timeline. Er, thanks.

And it’s bugtastic. Maximizing the window hides away the normal minimize/close buttons. You have to just click in the area and hope you guessed correctly. Even with notifications turned on, I have yet to see a single notification. It regularly errors when trying to get more tweets, and leaves me without updates for long periods of time.

web

Ultimately, at home, it’s just easier to use the web client. None of the clients I have found are good enough to do light browsing with. I do most of my reading at work, so when I bother to log on at home, I just want the latest part that I haven’t read yet. None of the applications I’ve tried seemed to have syncing. Loading one up at home would just dump the whole days worth of tweets into my timeline, and that’s useless to me.

Since the web application defaults to showing me the latest tweets, that’s usually all the ones I want to see anyways. Replying and retweeting are easy enough, although it would be great if it automatically shortened URLs for me.

“That” Twitter App

The application I’m looking for is a native client to Windows, doesn’t look like it came from the year 2000 in terms of UI, and has many of the features you’d hope to have in a Twitter client: URL shortening, image loading, notifications, and lists. I’d love the option to remove all listed people from my main timeline, but whatever. If it has those features, looks pretty (and is intuitive), and isn’t the buggiest piece of code in the world, I’d like to use it. But it really seems like so many developers only like making things for Macs now. There’s got to be developers who still work on Windows… or maybe I should just break out the C#-fu….

Follow me on Twitter

I have little spurts of ingenuity on Twitter, follow me: @seanmonstar.

Less Random, you say?

Yea, seriously. We really don't want a real random number, because random is too random. Backgammon players rage on about how un-random virtual dice rolls are, and programmers can go to extreme circumstances to provide the right kind of random.

Role playing games have to overcome this too-random problem as well. In an RPG, you might be getting a random number to determine if the player character hit the monster. And considering the situations you find yourself in when playing an RPG, this dramatic but randomly generated experience can really suck:

A blade spider is at your throat. It hits and you miss. It hits again and you miss again. And again and again, until there's nothing left of you to hit. You're dead and there's a two-ton arachnid gloating over your corpse. Impossible? No. Improbable? Yes. But given enough players and given enough time, the improbable becomes almost certain. It wasn't that the blade spider was hard, it was just bad luck. How frustrating. It's enough to make a player want to quit.

—Randomness without Replacement

It’s really quite interesting how much we really don’t want real randomness. Because real randomness is not biased. Pure randomness doesn’t care if that’s your 20th "1" in a row. It can lead to frustration, and cause people to blame the game for sucking, when really it was just a bad sequence of random numbers.

How We Perceive Random

It turns out, when we say random, as a player, we actually mean controlled random. Compare these images of dots plotted on a grid:

Which picture looks like the random we want? Apparently, the first is too random for humans. What I mean is, it doesn't look random. We quickly identify patterns in the truly random picture. We see groupings and think there must have been numbers that were favored to get that result. We want to believe that randomness will evenly distribute it’s results across the spectrum. No patterns, no missed numbers, no repeats. Even.

The truth behind these 2 images is that the left image is a true random plot. The image on the right was controlled.

The plot on the right is […] composed of 64 smaller squares, each of which has 4 points placed at random. People don't like the leftmost plot because it has several clumps of points that seem non-random. In fact, true randomness consists of a mixture of clumps and non-clumps. Randomness is different from homogeneity.

—Warning Signs in Experimental Design and Interpretation

A programmers solution

The way to handle controlled randomness is actually pretty simple. It’s commonly called a shuffle bag. The principle is that you take a bunch of tokens and put them in a bag. Then when you need another value, you pull a token out of the bag, and use that. Once the bag is empty, you fill it back up again.

You can control the percentage of a positive or negative result by setting the ratio of tokens you insert into the bag. You can also control what sort of “sprees” you can get from you bag by inserting duplicate values.

For example, with 1 hit value and 1 miss value, you have a 50% (1/2) chance of hitting. You also have the possibility of getting 2 misses or hits in a row. If you changed that to contain 5 hits and 5 misses in the bag, you could possibly end up with 10 in a row.

import random

class ShuffleBag(object):
	
	def __init__(self, values):
		self.values = values
		self.list = None
	
	def next(self):
		if (self.list is None) or (len(self.list) == 0):
			self.shuffle()
		return self.list.pop()
	
	def shuffle(self):
		self.list = self.values[:]
		random.shuffle(self.list)

The usage would be pretty simple. If I want a 20% chance of getting a critical hit on a damage roll, I would implement that like so:

bag = ShuffleBag([1, 0, 0, 0, 0])

while attacking:
	is_critical = bag.next()
	if is_critical:
		dmg = MAX_DMG
	
	doDmg(dmg)

Who’d have thought that you needed to do something special just to get "fun" random numbers? I think the root of it has to do with how statistics are all just a lie.

Follow me on Twitter

I have little spurts of ingenuity on Twitter, follow me: @seanmonstar.

So instead, I delved into JScript to find a way to let me iterate all global variables. But first, here's a few ways you could declare a global variable.

var a = 1;
window.b = 2;
c = 3;
(function(global) {
    this.d = 4;
    global.e = 5;
})(window)

Only if you specifically set the property of the window object does it get attached. The cases that are declaring variables instead of properties get added to a Variables Host object instead. Frankly, this is awful. But we come to expect this kind of shenanigans from IE.

This causes this iteration bug:

for(var i in window) {
	i; //besides the usual, we'll only get
	   //b, d, and e.
}

Thankfully, some other people have noticed this before me. Eric Lippert did much more extensive research than I needed to fix the issue. But his research assisted Thomas Frank in a way that solved my problem as well.

This should get all our global variables, but doesn't in JScript/IE.

var x=[];
for (var i in windows){x.push(i)};
alert(x.join("\n"));

Well, it turns out this doesn't work in JScript/IE at all, because non-native variables are not found when we try to enumerate the window object.

—Find your global namespace

This might not necessarily be the best solution, but using a cache, I only have to eat the execution cost once. Thomas' solution was to search all script tags for all variable declarations. This works because even though a in my first example doesn't get iterated through, it can still be found through a property lookup on the window global object (window['a']).

The first thing I had to do was to write a workaround for IE browsers. In IE it is possible to get the complete script source for a page by looking at the document.scripts array.

If an element has no innerHTML value, then it is an external script and we can load the source with a simple AJAX request. We then use a little bit a regular expression magic to extract every "word" from the source(s) and check if these words exists as global variables. This works suprisingly well.

Using his approach, modified to store all the "word" possibilities in a cache so I don't have do more ajax requests, I've cooked up the following bit to implement a sort of indexOf (or keyOf) for the window object.

var keyOf = (Browser.Engine.trident) ? (function() {
	var xhr = function(path) {
		var request = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
		request.open('GET', path, false); //asynchronous = false
		try {
			request.send();
		} catch(e) { return null; }
		if (request.status == 500 || 
			request.status == 404 || 
			request.status == 2 ||
			(request.status == 0 && request.responseText == '')) 
			return null;
			
		return request.responseText;
	}
	
	var cash = {};
	
	var ie_search = function(obj) {
		var key = search(obj) || search(obj, cash); //search does a for..in loop on window.
		if(!key) {
			//IE doesn't enumerate `var a = 'x';`, so we need to explicitly
			//declare those vars on the window object
			// credit: http://www.thomasfrank.se/downloadableJS/globalVars.js
			var scripts = document.scripts,
				src = '';
				
			for(var s = 0, len = scripts.length; s < len; s++) {
				if(!scripts[s]._lookedUp) {
					if(scripts[s].innerHTML) {
						src += scripts[s].innerHTML;
					} else if (scripts[s].src) {
						src += xhr(scripts[s].src);				
					}
					scripts[s]._lookedUp = true;
				}
			}
			var idents = src.replace(/\W/g, ' ').replace(/(function|if|for|while|true|false|null|typeof|var|new|try|catch|return|prototype|this)/g, '').split(' ');
			
			for(var i = 0; i < idents.length; i++) {
				var iden = idents[i].trim();
				cash[iden] = true;
				if(!key && (iden in window) && window[iden] == obj) {
					
					key = idents[i];
				}
			}
		}
		return key;
	}
	return ie_search;
})() : search;

The first time you call keyOf, it will collect all the Javascript source for the page, and then store every possible identifier that was declared. On subsequent calls, only new scripts will be gotten and parsed. Since the values of the global variables could change at any time, I could only store in the cache their names. The search function tries all those names on the window object.

A definite downside I see to this method is since it uses XHR to collect the source, it wouldn't work on scripts that aren't from the same domain. But for my framework, since it uses a loader anyways, it's sufficient for me.

Follow me on Twitter

I have little spurts of ingenuity on Twitter, follow me: @seanmonstar.

var tabs = new MGFX.Tabs($$('.tabs li a'), $$('.tabs .content'));
tabs.random();

So MGFX.Tabs 1.2.0 is available on the Forge.

Follow me on Twitter

I have little spurts of ingenuity on Twitter, follow me: @seanmonstar.

We use a proprietary text replacement program instead of sIFR or Cufon or anything else out there. We call it Typostream. On one of my recent projects, we had several features of the web-site requiring extra Javascript functionality, along with a good portion of text being replaced. Originally, I had all of this Javascript being executed on DOM ready event, as best practices recommend. However, viewing the site in Internet Explorer revealed some amazingly laggy results.

Doing a lot at domready can suck

In IE (even IE8), the time it took to execute all the Javascript was way too long, in the realm of a several seconds too long. Now, the ultimate cuplrit was that we had over 100 elements on the page that needed to be swapped out for images of the same text. Eventually, we wear able to alter the design to require only a couple parts of the page to be replaced. But I discovered a more immediate fix for such a big flicker of content.

LOG: Total: 244, Since Last: 244
LOG: Total: 1992, Since Last: 1748

The timer was started at the top of of the Javascript file. The first profile call was at the start of the DOM ready event, and the second call was after the Typostream call.

Basically, with some logging, I found out where the big beasty functions were. On the inside, the common mechanism for dom ready implementations, is that every function you add as a "listener" to dom ready, just gets pushed into an array. Once dom ready fires, it loops through the array and executes all the functions. So basically, the dom ready event firing can become one giant function that needs to finish.

var $log = function() {
	if(window.console && console.log) {
		for(var i = 0; i < arguments.length; i++) {
			console.log(arguments[i]);
		}
	}
};

var $profile = (function() {
	var _start = new Date(),
		_last = new Date();

	return function(msg) {
		var now = new Date();
		msg = (msg || '') +' ,';
		$log(msg + 'Total: '+  (now - _start) +', Since Last: ' + (now - _last));
		_last = now;
	};
})();

This was my method of profiling. You could also use console.time and console.timeEnd, but this works in a pinch (and in older browsers).

Now, many things we do in Javascript are setting up event listeners and timers, so the major work at dom ready is usually fairly small. But the amount of work that was needed to swap out all those elements (and having to do slow selector lookups in the older versions of IE) was all trying to execute at dom ready. And while the DOM was being accessed and changed during that time period, the Javascript hadn't given up its execution to allow the browser to update the DOM.

The DOM was only able to update itself after that Javascript had executed. So even the smaller part at the start, like collapsing an accordion, wasn't happening until several seconds later. The solution was to remove how much Javascript was happening on the DOM ready event. I wanted to break it up, giving the DOM the ability to do all the changes for the accordion and modal boxes, before trying to do the heavy lifting of running up and down the DOM tree a hundred times.

Well, then move out of current execution

Along comes setTimeout. By wrapping the typographical replacement into a timeout call, I gave the browser an opportunity to run other browser stuff. It does its thing (like fixing most of the page immediately), and then calls my big function afterwards. Sure, that big function will still take a couple seconds to execute, making the text flicker, but at least its not as glaring as the section navigation collapsing 5 seconds in. And like I said above, we were able to drastically reduce the number of elements to change, thus fixing the problem even more.

But it's useful to know that you can actually clog up your domready event, and how to clean it out again. If you had a ton of things that needed to happen, you could probably set up a simple queue system that will execute everything you want in order, but setting a timeout for each one. Or you could try out web workers, if that fits your bill.

Follow me on Twitter

I have little spurts of ingenuity on Twitter, follow me: @seanmonstar.

import javax.swing.*;

I'm guilty of it too. You don't really know what you're doing is all that bad. You know what you want from Swing. You only need the JOptionPane. And sure, the compiler shouldn't be stupid enough to pack the rest of the Swing package into your jar file. In Java, at least, it won't. There's talk about whether certain bulk imports in Python will cause things to be included multiple times.

Collisions, or which List did you want?

However, in Java, you can get namespace collisions. coobird on Stack Overflow gives an excellent example:

Now, if we were to use a wildcard in the package import, we'd have the following.

import java.awt.*;
import java.util.*;

However, now we will have a problem!

There is a java.awt.List class and a java.util.List, so referring to the List class would be ambiguous. One would have to refer to the List with a fully-qualified class name if we want to remove the ambiguity:

import java.awt.*;
import java.util.*;

// 'List' from java.awt -- need to use a fully-qualified class name.
java.awt.List listComponent = new java.awt.List()

This problem is exactly what I was trying to avoid when doing working with some Java, and prompted my need to let people know never to do this again. I was trying to call a class from the YUI Compressor jar, and the constructor required several classes. Unfamiliar with a couple of the names, I didn't simply want to copy their import statements, since I already had written my own File class that was far more basic than Java's. No need for conflicts, please.

Your code doesn't have this problem? You're only importing from one package, you say? What about the future of your code? Your class is still auto-importing the rest of your class' residing package. What happens when someone creates a class called List? Or something else? Conflicted.

This leads to another frustrating reason not to use import star.

It screws Discoverability

Specifically, I was unsure which ErrorReporter was needed for the JavaScriptCompressor. The import statements at the top list 3 packages it could come from, and the only way for me to find out it to search each package.

package com.yahoo.platform.yui.compressor;
 
import org.mozilla.javascript.*;
import java.util.*;

ErrorReporter could be a class defined in this package (com.yahoo.platform.yui.compressor), or it could be java.util, or org.mozilla.javascript. It turns out it's in the latter, but discovering that took longer than it ever should have. Even the few minutes I had to spend to lookup which package contained the class so I could import it into my class file was minutes wasted. It's effortless to have to used a more specific import statement instead. Especially if you're using an IDE like Eclipse (which you are if you're doing Java development, just press Ctrl + Shift + O).

Flex Builder is an extension of Eclipse, so no excuses there either. I imagine Flash has a similar shortcut, though even if it didn't, just like in Python, it's really not that hard. Honestly, it takes no extra effort to write the name of a specific class instead of importing the whole dang package or module.

This reason is what I feel is the more important reason why you shouldn't use import * ever again. The more time it takes another programmer (or even yourself) to understand what in the world was going on inside your head at the time of writing, that's time (and thus money) you're costing your company.

Save a kitten: Don't write import * again.

Follow me on Twitter

I have little spurts of ingenuity on Twitter, follow me: @seanmonstar.

Here's what I mean:

var ItemsController = new Class({
view: function(view_name) {
if(!view_name) {
//viewname should default to 'controller/method'
}
},
list: function() {
$(this).grab(this.view()); // 'items/list'
}
});

Every method in a MooTools Class is wrapped in some decorators, that set the caller on the function object when called. By staring and counting how many methods back I needed to collect, I've accomplished my goal. However, this won't work if a standard function calls this method. It might be a good idea to protect this method, now that I think about it.

//inside view function
view_name = arguments.callee.caller.caller.caller._name;

Don't believe me? Test it right here. As neat as this is, I don't gaurantee this will work in every situation, and I haven't tested if any browsers break using this.

Follow me on Twitter

I have little spurts of ingenuity on Twitter, follow me: @seanmonstar.

1. Accessing a property in a dictionary with a variable
2. Setting properties on objects with a variable
3. Using While with a function call

Check in first

When looping through a list or dictionary, it's not uncommon to compare the current indexed value to a value in a different list or dictionary. However, doing that will quickly teach you that trying to access a key that doesn't exist will raise a KeyError.

After my first KeyError, I first tried to wrap the comparison in a try block. But that can start to look unwieldly:

try:
	val = params[key]
except KeyError:
	val = None
	
if val:
	#...

Alternatively, we can use the in keyword to check that a key exists. And similar to other languages, using the and operator will prevent the second expression from being evaluated if the first one is false. Hence we do this, and it's all pretty!

if (key in params) and (params[key]):
	# ...

You can just setattr

A while ago, when doing some initial Django development, I tried to naively handle submission of forms the same way I do in PHP. I loop through each key value pair in the POST dictionary, and assign it to an instance of the model I want to insert. No worries if extra information has been submitting, the model will send data that we have specifically set at fields in the class definition. However, objects in Python don't allow item assignment like PHP or Javascript. Every object does have a personal __dict__ that I could access, but then I can get KeyErrors as the above example shows.

Denis Otkidach showed me Python's setattr function, which lets me do exactly what I wanted.

for key, value in POST.iteritems():
    setattr(my_model, key, value)

While True, loop foreverrrrr

Often times, when you don't have a predetermined length of something, you'll use while to do your looping. A common occurrence of this is when reading in a file. You call a function, and store its return value, and as long as that value is usable, do your loopity loop stuff. However, in Python you can't do assignment inside a condition for a control structure like while, probably because Guido likes to prevent bad practices from being possible in his language, and that is usually a bad practice unless you know what you're doing.

There maybe a more elegant way of handling this, but i resorted to making an infinite loop that breaks on a bad condition:

while True:
	val = func()
	if val:
		pass
	else:
		break

Follow me on Twitter

I have little spurts of ingenuity on Twitter, follow me: @seanmonstar.

Crazy people think we don't need tablets

I can imagine something like the iPhone with a much bigger screen being a gorgeous device with great capacity, but I don’t know where I would fit that into my life

Another former Apple executive who was there at the time said the tablets kept getting shelved at Apple because Mr. Jobs, whose incisive critiques are often memorable, asked, in essence, what they were good for besides surfing the Web in the bathroom.

—Just a Touch Away, the Elusive Tablet PC

The Eventuality

Eventually, everyone will carry a tablet for all their needs, technological or otherwise.

• As a phone: We already use programs for telephony like Skype, and others access phone programs using touch screens via iPhones and Androids. If we're already carrying around 1 piece of technology, why be bothered carrying two. We could talk similar to speakerphone, or an ear piece can easily be worn that will let us talk using the tablet via Bluetooth or some other means.
• As a computer: Many people use their iPhones to access their e-mail, browse the web, and organize their life. It's just a plausible on a tablet. The reason for using the iPhone is it's portability; something the tablet will solve as well. With an on-screen, even typing comments, documents, and the like will be easily and portable.
• As a reader: Surely, people enjoy reading blogs and their RSS feeds portably, such as on an iPhone. And with readers like the Kindle, we see people enjoy reading books, magazines, and newspapers the same way. It only makes sense to want your one personal device to do both. Another plus: students will forget lugging around text books. The backpack will become redundant. The tablet will let you look at the material for class, and also let you write notes with a touch screen keyboard.
• As identification: Eventually, we'll use digital identification over our driver's licenses (or passport, etc). We'll have some sort of encrypted file that we can pop open for showing when need be. And likely a way to broadcast it, like the public side of a private ssh key. I would be surprised if we didn't take it further: our homes unlocking when we broadcast our ID near the door, our cars opening when we're nearby, and the like.
• As money: Paper money and even credit cards can be a hassle. Credit cards especially suck at letting us split the bill at a restaurant with 20 people. It'd be to everyone's advantage if a vendor could broadcast a bill (or a money request), and we could accept on our device. Or if a friend needs to borrow a couple hundred or a thousand dollars. Sure, here you go [press button]. It will happen.

Follow me on Twitter

I have little spurts of ingenuity on Twitter, follow me: @seanmonstar.