This isn’t because it will always provide a great cup, sometimes it won’t even provide a good cup, but it will always provide an adequate cup.

And I do have good tea at my disposal — I have tea carried by hand from India and Nepal and tea from some excellent vendors (and I don’t just mean Teavana). I have a real teapot (which I bought from some cloistered monks), good infusers and a good source of fresh, filtered water. But I like Twinnings.

“Why?” you might ask. After all, they aren’t exactly known for quality. Not only are they bagged, but they aren’t even top quality bagged (and I have some of that, too). Well, because the tea is always decent. No matter how you abuse Twinnings (over-steep, under-steep, drink cold, drink hot), it will always be decent. If you over-steep good tea, or drink it after it cools too much, the tea starts getting bitter. The wonderful aromas mute and sour and the experience is more-or-less ruined.

Now, sometimes I do have the time to actually sit and wait for my tea to really brew. When I have that time, I will most certainly go and brew good tea. After all, I have time. But time is often a commodity, and waiting an extra 3-5 minutes for the tea to brew is not exactly the easiest thing in the world.

var Klass = function(){
    this.toView = function(){ return Klass.prototype }
}
Klass.prototype = Ti.UI.createView({
    /*... the rest of the parameters here (as usual) ... */
});
var view = new Klass();

Then, if you want to add the object to a window, you need to remember to call win.add(view.toView()), but it means you can now carry around the data object with *all* of its data.

var emptyFunction = function(){ return ""; },
      gebi = function(elm){
				return {
					nodeType: '',
					innerHTML: '',
					insertBefore: emptyFunction,
					removeChild: emptyFunction,
					appendChild: emptyFunction,
					getAttribute: emptyFunction,
					setAttribute: emptyFunction,
					getElementsByTagName: function(){
						return {};
					},
					style: {}
				};
		}
window = {
	document:{
		getElementById: gebi,
		createComment: emptyFunction,
		createElement: gebi,
		createDocumentFragment: gebi,
		documentElement: ntx.extend( {
			createElement: gebi,
			childNodes:(function(){
				var g = gebi();
				return [g]
			})()
		}, gebi() )
	},
	location: {
		href:""
	},
	navigator:{
		userAgent: ""
	}
};

My response:
The process is local post office -> central hub -> local post office. It means that all routes are 2 long, but it means you only need to support routes to and from that hub. At most, that is 2 * number of post office.

On the other hand, if they were to support “every post office to every post office” that would be (number of post offices)!.

So, if there are, say, 1000 post offices, the hub plan means that there are only 2000 routes at most. If each office were to send to each other office, that would be 1000², or 1,000,000…

Anyway, the location of the log files for Empathy in Ubuntu 10x-11.x is:
./.local/share/TpLogger/logs/

This is because while the default bundled IM client is Empathy, it is used as a part of Telepathy (hence the “TpLogger” part). It is annoying as anything to figure this out especially since (as of this date), the official FAQ does not come up as part of the top 5 search results on Google.

Two percent of the people think; three percent of the people think they think; and ninety-five percent of the people would rather die than think
— attributed to both Thomas Alva Edison and George Bernard Shaw^[1]

While I would love to maintain that I am always in that top 2%^[2], there is one place where I am decidedly happy to be in the non-thinkers category: user experience.

Now, don’t get me wrong, I actually care a great deal about the experience that people who use my software have: it is incredibly important that you treat people like me well. On the other hand, when I want to use something, I want it to be completely intuitive. And you know what makes something 100% non-intuitive? Changing the UI.

Big news of late is that Google has been changing its UI. Lesser news of late is that Ubuntu and Gnome have been updated ^[3]. While I am sure that there was some compelling reason that this was done, a change in UI is almost always a bad idea.

Why do I say this? Well, I could cite joelonsoftware, I think that numbers are more compelling. Think of it this way: Google is going through a major revision. I find that most tasks take me an extra second or two per day. Chump change, right? Well, not really.

Google had about 145 million^[4] people looking at its site a month^[5]. Now, look at that number. Assume 5 seconds per user are wasted on this site, multiply by number of users, divide that by 3,600 (the number of seconds in an hour). Then multiply the result by, say, $5.15^[6]. For those who can’t do 10 digit floating point math in their heads, that’s $1,036,865.67. That number is per month. And it is lost because of a UI change.

When you change your UI, you cause people to pause and look for the function that the individual would like to see. This means that they are spending time doing something which is non-productive and frustrating. It means that you are not only making them less productive, you are costing them (and possibly you) money. Even worse, a major change in UI not only invalidates the experience your users expect, causes them to invest time in unlearning, and not in that cool Yoda way, but more in that “I want to stab myself in the eye because this experience sucks” sort of way.

And Google is not the only one to pull this. Ubuntu 11 (and Gnome 3 by proxy) was even worse. One of the issues people had with Vista is that they had no idea where the heck anything was anymore (I’ll argue that Windows 7 was able to survive only because it was able to build on the foundation of, believe it or not, Vista).

All of this considered, I would think it would be considered in a company’s best interest to make it possible to view older forms of the UI. This might be a bit more difficult on, say, a desktop application paradigm, but it is something Google should seriously consider.

All of this necessarily brings the idea of Windows 8 to mind. It is another revolution, and MS has not consistently batted 1000 on these revolutions^[7]. But who knows, maybe I’m just not Metro enough.

1. ^[1] Note: Edison quote is purported to be 5% thinkers, 10% think-thinkers, and 85% non-thinkers ↩
2. ^[2] (and who knows, maybe I am? But my experience is that those who say this type of thing are snobbish and only count “those who think” as “people who are intelligent and happen to agree with me,” and “intelligent” is subjective there.) ↩
3. ^[3] 11.10, for those who are keeping score ↩
4. ^[4] Actually, that’s 144,959,861 ↩
5. ^[5] List of top 50 sites by unique visitor count ↩
6. ^[6] Lowest minimum wage in the US as of today’s date. ↩
7. ^[7] My experience is that the general consensus is that the new “ribbon” paradigm is considered awful by, I don’t know, everyone ↩

One of the absolutely worst things you can do in the entire world is being 99% consistent.

While this is especially apt in code, it is a general truth in life. Small inconsistencies are deadly. Don’t believe me? Two characters difference has cost the U.S. government $125 million dollars.

The human brain is the single greatest pattern matching device which has ever been created. We are genetically hard-coded to see things like 1,2,3,4,5,6,7,8... and expect that the next number in the sequence should be 9. (This is also why so many people are outright infuriated by the philosopher David Hume).

And this is right and good. It allows us to do things like accurately predict future events: fun fact, a professional athlete is able to know where the ball will be in the next second. Without this ability, there would be a good deal more errors.(I’m not sure if that would make the games more or less entertaining…) More importantly (for those who actively endanger everyone around them by picking up a ball, like me), this ability makes speed reading possible — much of speed reading is about allowing the eye to pick up substantially less extra information and allowing the brain to fill in the blanks. spreeder.com actually has a setting which gets rid of “stopwords” like “the” and “and” because the brain is perfectly capable of understanding without them.

But it also makes it substantially more difficult to spot small errors. This is why certain optical illusions work (suck as the Kanizsa triangle); it is why people don’t see exchanged letters in words^[1]; and it is why the text to the left is so infuriating to so many people (yes, there is an error, and you can see the footnote if you want the answer^[2]). In all of these cases, you are basically firing into the brain’s largest blind-spot: you are taking advantage of the brain’s almost obsessive desire to normalize data, the compulsive desire to make “D” follow after “C” even in cases it has no business being there.

To make matters worse, as the inconsistency gets to be smaller, the harder it is to spot. Amusingly, in situations where we can expect that there will be no pattern we actually do much better. My favorite example is PHP (inconsistent) vs. Python ( entirely consistent). Most people complain about the inconsistencies — some times PHP uses underscores, sometimes it uses CamelCase, other times it uses mixedCase, and sometimes it simply concatenates the names of variables and functions — but this is actually a strength. Why? Because you know that you can expect this and so you take time to learn when each happens. And while Python is far more consistent, Python 2 actually used a mixture of mixedCase, CamelCase, and underscore delineation. This means that trying to rely on the consistency of the language will actually set you up for failure!

All of the attempts to get consistent user experience, all of the attempts to give things “a narrative” boil down to the question, “How can we set and fulfill expectations?” Or, more aptly, “How can we create a pattern which the user can rely on?” Further, all of the questions about giving code a “consistent standard” are an attempt to make experience for the programmer as uneventful as possible — doThisThing v.s. DoThisThing is more than just a custom dreamed up by some theorist, it is a mindset and it is something which we must be able to trust.

And it is through consistency that large systems become learnable. It is in consistency that code is maintainable.

After all, the learning curve of a given program is directly related to maintainability of that code. Maintainability is directly related to code meeting the expectations of those who are maintaining it. Length and breadth, number of commands involved, and Cyclomatic complexity pale in efficacy in comparison to having code which works as expected, even if it doesn’t work.

Don’t believe me? Well, what do you think a “gotcha” is? It isn’t created by people being entirely consistent with themselves. No, it is in people being counter-intuitive. What do you think causes the “WTF/minute” standard? It isn’t thoughts like, “My word. He did something remarkably similar using similar vocabulary twenty lines ago!”

I suppose that at this point, I might do well to address the obvious objection, “What about the coder who consistently does things wrong? What about the one who thinks he is being consistent by naming three things ‘var1′, ‘var2′, and ‘var3′” Well, what about him? He’s an idiot. Assuming no other faults (a bad assumption) he has made at least one major inconsistency — things with like names do not serve like purpose.

The more we keep this rule in mind, the better off we will be. The more we aim for consistency as a mindset, the cleaner and clearer our code will become. And if we keep consistency as job one, it means that we can also expect that our architectures will be clearer too. And while I’ll not go so far as to call it a panacea, it is abundantly obvious that this is something which we need to keep as a golden standard and deviation should be avoided whenever possible.

1. ^[1] It’s true poeple generally fail to recognize that a word has had two letters transposed. ↩
2. ^[2] How many definite articles do you see? ↩

>>> view.tags.get_attributes('a')
('accesskey', 'class', 'contenteditable', 'contextmenu', 'dir', 'draggable',
'dropzone', 'hidden', 'id', 'lang', 'spellcheck', 'style', 'tabindex', 'title',
'href', 'target', 'rel', 'media', 'hreflang', 'type', 'onabort', 'onblur',
'oncanplay', 'oncanplaythrough', 'onchange', 'onclick', 'oncontextmenu',
'oncuechange', 'ondblclick', 'ondrag', 'ondragend', 'ondragenter',
'ondragleave', 'ondragover', 'ondragstart', 'ondrop', 'ondurationchange',
'onemptied', 'onended', 'onerror', 'onfocus', 'oninput', 'oninvalid',
'onkeydown', 'onkeypress', 'onkeyup', 'onload', 'onloadeddata',
'onloadedmetadata', 'onloadstart', 'onmousedown', 'onmousemove',
'onmouseout', 'onmouseover', 'onmouseup', 'onmousewheel', 'onpause',
'onplay', 'onplaying', 'onprogress', 'onratechange', 'onreset', 'onscroll',
'onseeked', 'onseeking', 'onselect', 'onshow', 'onstalled', 'onsubmit',
'onsuspend', 'ontimeupdate', 'onvolumechange', 'onwaiting')

It’s that simple.

Basically, it’ll let you create a tag object which restricts what properties you can assign it. This means that you’ll get an error if you try to assign a property which does not exist.

Check it out:

>>> tag = view.tags.Tag('a',href='foo',valid=['href','title'])
>>> tag.contents.append(view.tags.Tag('img',src='angry.gif',valid=['src','title']))
>>> tag
<a href="foo" ><img src="angry.gif" /></a>
>>> tag.src = "timbuktu"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "view/tags.py", line 28, in __setattr__
    elif hasattr(self,"attrs"):
  File "view/tags.py", line 35, in trigger_keyerror
 
KeyError: '"src" is not a valid attribute for a a tag.
>>> tag.href = "http://google.com"
>>> tag
<a href="http://google.com" ><img src="angry.gif" /></a>

Then there is the UnstrictTag, which will allow all attributes to pass:

>>> tag = view.tags.UnstrictTag('a',href='foo',valid=['href','title'])
{'href': 'foo'}
>>> tag.contents.append(view.tags.Tag('img',src='angry.gif',valid=['src','title']))
{'src': 'angry.gif'}
>>> tag
<a href="foo" ><img src="angry.gif" /></a>
>>> tag.foo = 1
>>> tag
<a href="foo" foo="1" ><img src="angry.gif" /></a>

I admit it does need an official test framework built, and the comments are missing. That’s for next week.

We’ve entered the age of the browser. Even without such things as Eyeos, we’ve come to the point where you can literally do anything without leaving Chrome, Firefox, or even Internet Explorer. Need email? We got that. What about RSS? Do you have a document you want to edit?

Heck, you can even get an SSH plugin for Firefox.

Does this strike anyone else as odd? I mean, when else do we have a program which does so much? Really, can you imagine someone coming up with a proposal which reflected a modern browser?

Yes, sir. We want something which can function as a document editor, but we also want to play games on it, and when it is necessary, we want to be able to communicate instantly with text. And make it hook up to the phone too. Oh, it also has to be able to re-size images on the fly, it needs to have an incredibly verbose scripting language and a simple interface

If I had a client who said that they wanted that as a desktop application, I would likely tell them to “get out of my office”. I’d like to think that I’m not the only one in that thought too.

This is, to be frank, a severe lack of separation of concerns. It flies in the face of everything we are supposed to teach and believe as developers, but it does not concern us in the least. Heck, we like it so much that it is becoming more common for our OS’s to be more integrated with the magical interwebs.

Five years ago, if I wanted to listen to music, I would open a music application. If I wanted to write a document, I would open a word processor (OpenOffice likely). My life was very GNU, I would use a series of tools, each of which did one thing, and did that one thing well. And yes, this did lead to some code duplication, and it took proportionately more space of the hard drive, but it made sense. Right now, we have exactly what the ideallists stood against.

I would be lying to say that this is shocking though. The browser is a great equalizer: you can build a legitimate webpage which will render in every operating system in 61 characters^[1]. While you can print hello world in as few as one character that requires an interpreter which might not be available in all platforms, or it might require a custom install script.

The browser has offered us not only a single entry point, but it has also provided a default set of tools to work with. HTML, CSS, and JavaScript are now the basic staples of the vast majority of developers who have to do anything involving a user. With the cost of development at an all-time low in browsers, actual application development is understandably going to take a hit — why publish with a limited domain unless you have to?

And isn’t it amazing? We came all this way. We made startling advancements. We can now access our data everywhere… and it basically means that we have wound up using Ctrl instead of Alt. Wow, I mean, wow.

But, now, instead of having a large number of programs, I have 57 tabs and nothing on. It makes me dream of a world^[2] where we can somehow get beyond this. Somehow we must push through this looking glass we call a “browser” and into something more.

The implication: the OS of the future will be nothing like the OS of the past. It will, in essence, BE a browser. It will solely exist to consume services and expose that functionality to the user. But we daren’t call it distributed, we can’t. The only real collection that exists is the list of products which we have signed up for, but those will simply serve as references to which services we use, they will not be those services in themselves.^[3]

Now, you might ask how I know this will happen. Well, it is already happening. In addition to the online applications which were mentioned earlier, there is the tablet. The tablet is the embodiment of this ideal, and as the tablet will almost certainly continue to gain market share, so will its interface.

Right now, we live in a world where there is exactly one type of program which is good at making requests like this and so it does everything. But the tablet has show us that we can simply push that issue back, we can make it so that the primary interface for making requests is the OS itself. Once that normalizes, once that becomes standard, we will live in a different world — one where there will be almost no distinguishing between the terminal and the network. And maybe, just maybe, I’ll be able to close one or two of these extensions and rely on only a few tabs at once.^[4]

1. ^[1] The minimum required for a legitimate HTML 5.0 file is 49 characters, but then you need the mandatory “Hello world.”: <!doctype html><html><head /><body>Hello world.</body></html> ↩
2. ^[2] Random song tangent: a place where dreams are born and time is never planned. Somewhere, out there, beneath the pale moonlight, there’s a place for us, somewhere a place for us. ↩
3. ^[3] The implications for things like digital rights management should be astounding: never again will piracy be possible: each user will simply maintain a specific connection to the web and there will be no way to use more than one instance at a time. ↩
4. ^[4] Who am I kidding? I’ll always have 50 tabs open… oh well, maybe the next revolution ↩