Code Optimism

When messy is meticulous: cleaning clutter like Gmail.

2009-11-11T04:51:00+00:00

When it comes to cleaning a house, or a room, few are quick to consider the strategy of throwing everything together, or at least they don't consider it a strategy.

That's too bad, because frequently it's exactly the thing to do. Too often I think, we plod through the task of organization without a realistic regard for impact on time. Programmers can see things differently. Consider organization as a function of time spent vs. time saved.

A hundred labels on a hundred envelopes for files you'll only access a few times is a colossal waste of time, despite the deceptively sly title of "organizing". In precisely the same manner, tossing together and tucking out of sight odds and ends you seldom use is fantastically practical.

Go ahead and gather up all of the clutter in your workspace! In your home! At your office, and wherever else you spend your time. Stick it all together haphazardly, in clear containers perhaps. Yes you may need to hunt, but rarely - that's why it's clutter. Furthermore it's together, and your workspace is clear of all but items relevant to your recent goals, enhancing your focus.

Often we're at a loss with what to do with our stuff, it's not worthless or we'd throw it away, it's unique or miscellaneous or we'd know where to put it. It could be organized or filed but it's awaiting our input. Throw it together! Sweep it into a box! You need it, you want it, but you haven't gotten to it, you don't want to see it and it's not immediately relevant. Instead of agonizing over organizing, reallocate your time, spend it on searching and not on sorting. Though inefficient in the long run, there will be no long run, as you search for an item to deal with it.

Obligatory technology tie-in: Everything has parallels in technology (and everything else), consider GMail's "don't sort, search". User interfaces are again similar. Items of frequent use and relevance are close by, and commands shouldn't be buried in otherwise empty multi-tiered menus in an inconvenient obtuse attempt at organization.

The user interface of your life: you, where you are, and the items around you that help you reach your goals - could use metrics of its own. Without mental measurement, are you sure you're building a time saver, or wasting time? Are you sorting when you should be searching?

A programmer's ethical dilemma.

2009-11-07T16:18:00+00:00

Not everything is black and white, not even when it comes to software programming. Way back around April 24th I asked the following question on Q&A for coders site Stack Overflow:

Can it be morally defensible to release a program which games an MMORPG?

I had written some code for a macro framework to automate actions in an up and coming MMORPG (something I enjoy), and I wanted to see if the community could contribute any constructive purpose for it, or if it was strictly evil™. Unfortunately I had my question worded "Is it" rather than "Can it be" when 99% of the answers struck, taking several answers quite awry. Still the input on commercialization was thorough, and the overall consensus on releasing a program of this nature? Bad thing.

In fact given the newness of the MMORPG I could only conceive of one scenario that could be morally defensible: A preemptive strike, a free, public release to preclude a worse one down the road.

Of course then you realize that this has all the ethical implication of pulling the trigger yourself. You may believe with certainty that an uneven playing field is inevitable, but can that itself justify action?

It may be very prudent to operate within a system of belief to affect change. Gentle nudges, progress at the pace of prevalent perception (I'm a fan of alliteration). Nuclear disarmament before cessation. Fight to end fighting!

It's a fairly rational approach, and I wasn't sure if there could be any other, until I encountered this:

"We need to be the change we wish to see in the world." - Mahatma Gandhi

Now there's an interesting concept. Being the change, I would not harm another in any circumstance - and quite obviously if everyone shared this conviction there would be no violence. Yet everyone does not, and more than a few people would reject my idealism, respond with belligerence to my priorities. It's understandable.

Still I find this latter approach the most resonant personally, and observing history, it appears to have great strength. I'm not yet sure what to do with my code, but I chose not to release it preemptively, I chose to be the change I wished to see in the world. What's your approach?

Breaking free from "sparkle before speed" with Windows Mobile

2009-11-03T15:16:00+00:00

As a Windows user and a programmer it's not a huge surprise that I have a Windows Mobile cellular phone, also AT&T (iPhone) hasn't quite established service in my area yet.

It's true that at first blush Windows Mobile offers an inferior experience. A stylus?! You must be joking. Scrollbars and miniature controls. Can you be efficient, have fun, keep up with the pace of life? Not so much.

Can you do stuff though, if you try really hard and take the time? Yeah, and just about everything. So much in fact, why, wait just a minute... you could even fix that horrible interface!

I'm not the first one to make that realization, there is a large and thriving Pocket PC community for both GSM and CDMA hardware.

Even among enthusiasts though I'm not quite sure they understand what they really want. "I customized this with a focus on speed and aesthetics." Okay, maybe a few more CPU cycles, but the animated transition ("aesthetics") between each of the phone's general functions is really cramping its speed, or are you not counting that? Well you should be, it relates to how fast you reach your goal doesn't it?

I'd much rather have my powerhouse of a phone working instantaneously than looking pretty. This isn't the old classic Windows vs. modern Windows comparison, because modern versions have the available hardware to run just as quickly while looking beautiful.

Do phones have the same luxury? Absolutely not. Yet what keeps occurring? Faster hardware, therefore... faster phone? No! Newer glitzy animations? Yes! It's great that we can have 3D support, but let's play with it when it doesn't have a noticeable impact upon performance.

It reminds me of a conversation I once had with my dad:

"Hey dad, I upgraded your operating system!"
"Oh really? So it should run faster then?"
"Well..."

Exactly. Of course this is fine when hardware is upgradeable, but the cell phone is very different, an existing paradigm is being transfered where it does not apply.

I hear the argument that it's what your average cell phone toting texting teenager wants, the demands of the market, but I disagree. Give them a phone which responds instantly and ask which they'd truly prefer, I have a suspicion even that demographic would capitulate. (Provided the phone can do interesting things in the first place.)

Of course I know what I want, and have the capability to achieve it. I'm right at home with Windows Mobile. It may take me day after day of installation and configuration - a deep flaw - to have a a device both incredibly powerful and highly usable but I get there, and I can enjoy it. A couple applications to achieve nearly full control of every hard button and strong consideration given to minimizing required input and I've got a device which doesn't rival the iPhone, but blows it out of the water. Well except for that awesome capacitive touchscreen, Apple's really got me there.

User interfaces... it's all about minimal user interaction.

2009-10-31T06:15:00+00:00

Designing user interfaces. It's not that hard.
Okay, it's really hard, but two central ideas strike me:

Users like to do things quickly, and if you're quick you can be efficient.
The more clicks or button presses it takes to accomplish what you want, the slower it goes!

Now complexity is its own bane - and it can be a worse one, but it's all about balance!

Ideally your most used functions should be within one key press / mouse click, lesser ones two, three, and so on, adding organization as you go.

I don't think this is very difficult to understand, which is why cell phone interfaces can be particularly frustrating.

What phone applications are the most time sensitive? Phone, Camera, MusicID, flashlight
Put them on hard buttons!, or at least a hard button that launches a wide menu which makes these options immediately selectable, but remember that when you go from one to two buttons you're doubling the amount of actions required, the most significant a one value increment can be.

Just keeping these points in mind is enough for much lauded user interface innovations to be obvious. Just take a look at new features of Windows 7 and you'll see what I mean. It doesn't take a company like Microsoft to come up with these things.

A while back I made an effort to emphasis the importance of minimal user intervention in relation to Vista and XP's taskbar, and it's interesting to compare and contrast those supplemental 3rd party tools with the Windows 7 taskbar.

Though I didn't mention it in that post, I had also written an AutoHotkey script to accomplish the Apple-esque (and now Windows 7) task of focusing an application's window if one existed, and otherwise launching a new instance of the program.

#NoTrayIcon

programPath = %1%
launchState = %2%
winTitle = %3%
excludeText = %4%

if 0 = 1	; left side is always variable
{
	Loop %programPath%
		fileName := A_LoopFileName
	Process Exist, %fileName%
	processId := ErrorLevel

	if (processId)
		winTitle = ahk_pid %processId%
}

SetTitleMatchMode RegEx
WinGet windowUID, ID, %winTitle%,, %excludeText%
if %windowUID%
	WinActivate ahk_id %windowUID%
else
{
	; replace commas with escaped commas
	StringReplace programPath, programPath, `,, ```,, All
	Run %programPath%,, %launchState%
}

Compiled as launchOneInstance.exe you would assign your launch/focus shortcut as follows:

"C:\path\to\launchOneInstance.exe" "C:\path\to\program.exe" Max "Program Window Title"

Max/Min/Hide or simply "" are fine for the launch state parameter.

Windows 7 is a wonderful experience when it comes to application launching, but cellular phones remain horrible, including Windows Mobile devices. Manufactures and carriers have their own influence, but even Pocket PC (Windows Mobile) user customizations seem to miss the mark again and again.

Minimal interaction, guys! Minimal interaction! Why pull up the task manager to check for an app when you can launch/focus it from the start menu in equal or less clicks? Why not launch the start menu from a hard button for easy access even within full screen applications? Add an extra column to that programs list if it fits easily, we don't want no damn scrollbars!

So not only should users not be required to think, but the less they have to do at all, the better. ;)

Defeating manual spam, or damn dastardly conniving commenters!

2009-10-19T21:17:00+00:00

I'm not especially keen on another meta-blog post, but the issue came up in email recently and I've this penchant for expounding at some length on interesting subjects, even in the least suitable medium, target audience: one. Fortunately I have a blog.

Not so fortunately, manually entered spam has been an issue. When you optimize for humans you regrettably include manual spammers.

Such spam is surprisingly devious, but here are some common characteristics:

Complimentary: "Wow this is a great post!"
Relative: "I don't like spam."
Unconstructive: Adds nothing of value.
Disingenuous: "I appreciate it because..."
Erroneous: "...this should keep spam out of my email inbox."

See! Manual spam is recognizably crude.

Of course the payload is the link, and they aren't all blatant advertisements, but even sites which might appear legit may advertise themselves unscrupulously. As expected they will lack real content.

Here with BlogEngine.NET the payload is put in the website field and not the body (the name field is the link text). Neither asking for your name nor indicating the website field is ignored by search engines made a difference.

Akismet did however, and thus far I've had zero false positives, only false negatives. Some have been crafted so cleverly as to be very close, but after investigating I've concurred. If Akismet marks a unique (but crude) comment as spam I expect the link to be unsatisfactory given that it's the defining constant.

My recent addition of reCaptcha seems to have made the largest difference. Most likely because there's now some difficulty involved. I actually feel pretty good about this because the duality of distinguishing computers from humans while simultaneously solving complex problems that computers do poorly absolutely fascinates me. Given that solving my captcha is now no longer a technical waste of time, I know some readers will begin to feel that it isn't as well. ;)

When you know you're coding in the wrong language.

2009-10-09T23:36:00+00:00

SphereServer is/was a fantastically fun piece of emulation software for the old and beloved Ultima Online MMORPG, from back in the day before emulation had even a mention in their End User License Agreement. I knew it originally as TUS (The Ultimate Server).

TUS was actually some of my first, ever programming, and SphereServer was my stomping ground for a long time, where in the early days I was extremely active. I've been out of that loop for some time now, but Sphere doesn't exactly have a tight release schedule and in all likelihood these experiences still apply - or they may not, I would be interested in hearing. For now I will speak from back a few years.

SphereServer's scripting language is interpreted, which in this case meant slow. Now I hear the argument, "Well so what? It was fast enough." And my response is, actually, no, it was too slow (and may still be).

Now if all you were interested in was tweaking loot tables, adjusting skill gain, invisibility cloaks and vorpal swords, then you didn't have much of a problem. If on the other hand you were creating complex housing, support, communication, battle and magic systems - like I was ("Swindler") - then more than likely you were using the wrong language in the wrong software.

In a contemporary programming language you're afforded the benefit of coding for readability, because many optimizations are micro-optimizations and simply don't matter. Not so with Sphere's interpreted language. Wanted to use one variable for exactly one purpose (new variables for new purposes)? Slow. Test a few different things in one conditional statement to avoid excessive nesting? Slow, Sphere doesn't use short-circuit evaluation. Nest like crazy for performance over readability? You still might not have had it! Parsing the additional lines was slow again. How about making good use of functions anywhere you could make a useful abstraction? Slow!

Unfortunately the text parsing of the script itself was a problem. Every line or character added for readability or maintainability detracted from performance, and not in a theoretical way, but a large and measurable way. There was a constant battle waged as balance was sought between readability (which will yield performance over time) and immediate performance.

The loser was quite evident though, that would be us:

[FUNCTION contents]
IF <RESCOUNT>
	VAR.COUNT <RESCOUNT>
	contents_r <ARGS>
ENDIF

[FUNCTION contents_r]
IF <VAR.COUNT> >= 200
        TRY FINDCONT.<EVAL <VAR.COUNT> - 1>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 2>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 3>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 4>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 5>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 6>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 7>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 8>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 9>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 10>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 11>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 12>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 13>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 14>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 15>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 16>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 17>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 18>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 19>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 20>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 21>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 22>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 23>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 24>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 25>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 26>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 27>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 28>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 29>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 30>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 31>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 32>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 33>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 34>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 35>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 36>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 37>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 38>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 39>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 40>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 41>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 42>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 43>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 44>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 45>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 46>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 47>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 48>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 49>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 50>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 51>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 52>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 53>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 54>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 55>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 56>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 57>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 58>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 59>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 60>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 61>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 62>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 63>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 64>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 65>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 66>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 67>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 68>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 69>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 70>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 71>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 72>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 73>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 74>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 75>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 76>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 77>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 78>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 79>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 80>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 81>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 82>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 83>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 84>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 85>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 86>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 87>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 88>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 89>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 90>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 91>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 92>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 93>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 94>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 95>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 96>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 97>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 98>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 99>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 100>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 101>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 102>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 103>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 104>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 105>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 106>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 107>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 108>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 109>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 110>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 111>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 112>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 113>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 114>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 115>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 116>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 117>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 118>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 119>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 120>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 121>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 122>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 123>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 124>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 125>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 126>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 127>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 128>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 129>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 130>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 131>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 132>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 133>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 134>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 135>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 136>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 137>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 138>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 139>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 140>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 141>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 142>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 143>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 144>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 145>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 146>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 147>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 148>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 149>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 150>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 151>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 152>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 153>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 154>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 155>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 156>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 157>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 158>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 159>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 160>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 161>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 162>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 163>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 164>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 165>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 166>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 167>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 168>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 169>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 170>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 171>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 172>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 173>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 174>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 175>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 176>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 177>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 178>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 179>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 180>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 181>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 182>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 183>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 184>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 185>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 186>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 187>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 188>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 189>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 190>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 191>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 192>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 193>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 194>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 195>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 196>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 197>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 198>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 199>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 200>.<ARGS>
	VAR.COUNT <VAR.COUNT> +- 200
ELIF <VAR.COUNT> >= 100
        TRY FINDCONT.<EVAL <VAR.COUNT> - 1>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 2>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 3>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 4>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 5>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 6>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 7>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 8>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 9>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 10>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 11>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 12>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 13>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 14>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 15>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 16>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 17>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 18>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 19>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 20>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 21>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 22>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 23>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 24>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 25>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 26>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 27>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 28>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 29>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 30>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 31>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 32>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 33>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 34>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 35>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 36>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 37>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 38>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 39>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 40>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 41>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 42>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 43>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 44>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 45>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 46>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 47>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 48>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 49>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 50>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 51>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 52>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 53>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 54>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 55>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 56>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 57>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 58>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 59>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 60>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 61>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 62>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 63>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 64>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 65>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 66>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 67>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 68>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 69>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 70>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 71>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 72>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 73>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 74>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 75>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 76>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 77>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 78>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 79>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 80>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 81>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 82>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 83>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 84>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 85>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 86>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 87>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 88>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 89>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 90>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 91>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 92>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 93>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 94>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 95>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 96>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 97>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 98>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 99>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 100>.<ARGS>
	VAR.COUNT <VAR.COUNT> +- 100
ELIF <VAR.COUNT> >= 50
        TRY FINDCONT.<EVAL <VAR.COUNT> - 1>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 2>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 3>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 4>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 5>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 6>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 7>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 8>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 9>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 10>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 11>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 12>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 13>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 14>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 15>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 16>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 17>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 18>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 19>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 20>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 21>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 22>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 23>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 24>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 25>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 26>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 27>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 28>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 29>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 30>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 31>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 32>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 33>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 34>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 35>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 36>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 37>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 38>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 39>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 40>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 41>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 42>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 43>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 44>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 45>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 46>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 47>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 48>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 49>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 50>.<ARGS>
	VAR.COUNT <VAR.COUNT> +- 50
ELIF <VAR.COUNT> >= 25
        TRY FINDCONT.<EVAL <VAR.COUNT> - 1>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 2>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 3>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 4>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 5>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 6>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 7>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 8>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 9>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 10>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 11>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 12>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 13>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 14>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 15>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 16>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 17>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 18>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 19>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 20>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 21>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 22>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 23>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 24>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 25>.<ARGS>
	VAR.COUNT <VAR.COUNT> +- 25
ELIF <VAR.COUNT> >= 12
        TRY FINDCONT.<EVAL <VAR.COUNT> - 1>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 2>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 3>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 4>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 5>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 6>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 7>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 8>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 9>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 10>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 11>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 12>.<ARGS>
	VAR.COUNT <VAR.COUNT> +- 12
ELIF <VAR.COUNT> >= 6
        TRY FINDCONT.<EVAL <VAR.COUNT> - 1>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 2>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 3>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 4>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 5>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 6>.<ARGS>
	VAR.COUNT <VAR.COUNT> +- 6
ELIF <VAR.COUNT> >= 3
        TRY FINDCONT.<EVAL <VAR.COUNT> - 1>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 2>.<ARGS>
        TRY FINDCONT.<EVAL <VAR.COUNT> - 3>.<ARGS>
	VAR.COUNT <VAR.COUNT> +- 3
ELIF <VAR.COUNT> >= 1
        TRY FINDCONT.<EVAL <VAR.COUNT> - 1>.<ARGS>
	VAR.COUNT <VAR.COUNT> +- 1
ELSE
	VAR.COUNT
	RETURN 1
ENDIF
contents_r <ARGS>
RETURN 0

Why did we stick with it for so long? Well aside from an acceptable level of relative completeness, its particular infrastructure meant code could be adjusted in almost real-time, a feature I reveled in as superior to competitive offerings from the likes of RunUO (which actually came much later). Of course this was a blessing and an absolute curse, I think we countered the not so uncommon effects of corrupted state with the careful application of not giving a fuck.

One of my close fellow enthusiasts ("Shadowlord") even went so far as to create his own language, PySphere, over Sphere's to abstract away some of the crazy. I liken this to JavaScript compression. While the resultant Sphere interpreted script is highly obfuscated, it's very fast. I thought he was nuts at first, and stuck to my hand optimization, but looking back I think it was me. (Well in truth we were both crazy to author such complexity.)

I eventually caught on, and so can you. If you're doing anything of substance in SphereServer, a budding programmer yourself, I ask:

Is Sphere fast enough for your code to be as readable as it should be?

If you aren't sure, give Code Complete a read, then try scripting and ask yourself again. You may not know what readable code looks like. ;)

Curse you focus stealing! What did I just authorize?

2009-10-03T03:08:00+00:00

Window focus stealing has been around for a long time, there's a Wikipedia article on it, it's been asked a few times on SuperUser and there's apparently a ForegroundLockTimeout registry value that may assist. But it probably doesn't.

The fact is that some applications don't respect system settings, and steal focus anyway.

You can probably write code to take your focus back, possibly even fast enough to avoid the thieving app from receiving dangerous input.

AutoHotkey, is, once again, ideally suited, and this problem is certainly under discussion on their forum.

So I stole the code from here (thanks SKAN and r0lZ) and a tiny bit from here (thanks Chris), and we've a means not to stop focus stealing (sorry, haven't given that a go yet) but at least to record a history of focused windows so we can see exactly what process / window it was that stole focus and intercepted our keystroke. What the hell did we just authorize? Well, we can know.

Install AutoHotkey, then download the script. Execute it and you've now a history of windows that have come into focus. Drop a shortcut to

"C:\path\to\AutoHotkey.exe" "C:\path\to\windowHistory.ahk"

into your start menu startup folder to always have it running. Now find and double click the new AHK icon in the notification area to open the script window, from the View menu select Variables and their contents. At the bottom you will see the variable winNum, which is the most recent recorded window index.

The last 30 windows and their processes are listed here, saved to these variables in a loop. Go to the one matching the winNum value for the latest and count backward to see the windows in focus prior (after zero you jump back to twenty-nine). The number after process names is the PID or process identifier, you can match this to an exact process in task manager (you may need to turn on the PID column from the view menu).

This is crude and not much more than a copy paste job, but it demonstrates that we don't have to live with these frustrations, we can take action. ;)

Reducing redundancy in (m)IRC

2009-05-28T18:53:00+00:00

The old but popular IRC client mIRC is richly featured but it has a style problem, so it gets teased, and really the user interface is the application.

XChat's alignment of user text inspired me to add the same feature to mIRC.

Then I realized there was no need to repeat timestamps and nicknames when nothing had changed, and my script became something more, something wonderful.

After this success I had to take it a step further.

When is it ever relevant to view join/parts in IRC?

When the user has recently spoken.
When they flood indicating the onset and end of a netsplit during which parties are cut off from each other.
When you're a participant and would appreciate a rough estimate of the visibility of your text, considering it could have been scrolled off-screen by join/parts visible to other users.
When a join/part flood is occurring and it's a bit too rocky for conversation.

Essentially when it's relevant to the conversation.

These are in fact the circumstances in which the script makes them visible. It begins in read mode with clutter minimized, only reporting departures of users whose text is most recently in your buffer. If you become active in the conversation the mode changes, and the dialogue is intelligently interspersed with brief updates of join/part line counts. Floods and netsplits are always reported, and tersely.

Other features:

Text is aligned, and the alignment point is easily moved.
Simple and customizable. The timestamp and nickname are checked independently for repetition, and look to your settings for how to format them in either of these cases. These screenshots are one very specific (and currently default) example.
Nicknames at the beginning of text are highlighted (formatted however you specify). There's room for improvement but it works pretty well.
UTF-8 Unicode support.

Download | Changelog

Installing the script is as simple as extracting the .mrc files from the zip somewhere, and loading the primary one into mIRC:

/load -rs C:\path\to\script\succinct.mrc

After which you will be greeted by lovely test output similar to this:

If you've similar results, other than the color theme and the highlight line which merely allows highlighting and states your primary IRC nick, then everything should be running smoothly.

Formatting and a few settings can be adjusted from mIRC's Variables dialog, take a look at the top of succinct.mrc for details.

Akismet support for BlogEngine.NET 1.5

2009-05-15T23:47:00+00:00

10-04-09 Not sure why I didn't notice before, but the Commentor extension has been around for some time! It solves what I still needed, a place to manage all of the comments from a centralized location. The code below still adds spam management to individual comments and they may work together rather without incident.

Since I previously mentioned comment spam I've experimentally bolstered the defenses of this blog in my update to BlogEngine.NET 1.5, and... received the same spam. It's manually entered, and highly deceptive, frequently a thanks, X helped me with Y or just ever so subtly off-topic, often only the spam URL giving it away. At least this has absolved naive captcha of blame (still a little randomization in field names for playback bots might be a good idea).

So, BlogEngine.NET community, let's do something about the manual spam problem and integrate Akismet with a spam moderation queue like the WordPress plugin.

I've personally tackled it in my usual lazy better-things-to-do hackish fashion and converted BlogEngine's entire moderation queue into a spam queue (essentially moderation enabled but non-flagged spam is immediately approved). Who wants to have to moderate everything anyway?

The actual Akismet comment checking is accomplished with Joel Thom's ASP.NET API you may need to download.

Following that, here are the relevant BC comparison reports:

BlogEngine.Core 1.5 with Akismet
BlogEngine.Web 1.5 with Akismet
Joel.Net.Akismet.1.0.1 for BlogEngine.NET

Don't expect perfection, in particular my error handling is probably unduly sparse. I'm sure I'll notice it when it breaks painfully.

You will need a WordPress API key to work Akismet in the first place. Get one and specify it with your blog URL at the top of BlogEngine.Web\User controls\CommentView.ascx.cs.

Further you'll have to compile the changes to Core, update the dll in Web's bin, add a reference to Core in Joel.Net.Akismet, compile, copy dll assembly, and reference that from Web as well, but you already knew that because you're a programmer and the using references give it away anyway. Right? ;)

Or you could use this tidy package I've provided, keeping in mind to only replace files/assemblies you haven't modified from the stock download, and merge the rest. (If you've no interest in source code you may ignore the BlogEngine.Core and Joel.Net.Akismet.1.0.1 folders, the compiled assemblies are already in BlogEngine.Web.)

You must also Enable comment moderation.

Additional Details

Commenters are notified if their comment requires moderation immediately (the JavaScript now provides, very hackishly, an isModerated case).
Moderated comments have a new administrative Ham link for submitting false positives back to Akismet (this also approves the comment).
Approved (visible) comments have a new administrative Spam link for submitting false negatives back to Akismet (this also deletes the comment).
These links have been added to the corresponding admin comment notification emails as well.
Comment moderation has been toggled on in settings.xml (for XML data source blogs).
The Joel.Net.Akismet API has been modified to take the HttpRequest and BlogEngine.Core.Post directly.
Only labels.resx has been updated, this package is not localized (and could be a little cleaner for that), I'm but one English speaking man.

Please improve upon this, make it an extension (I don't think it can be 100%), or otherwise more directly incorporate it into an official version. I mostly just have time to blog about it. :)

Implementing a naive captcha in BlogEngine.NET

2009-01-30T07:53:00+00:00

10-04-09 Keith Ratliff went to the very involved work of converting BlogEngine's comment submission process from JavaScript-centric to postback and standard ASP.NET validation, thereby enabling a more or less drag and drop installation of reCAPTCHA. Hooray Keith! Fantastic work.

A couple years ago Mad Kristensen implemented an invisible captcha into BlogEngine.NET, but as my blog has attested to, this is not enough.

Instead of inconveniencing readers with a captcha, you can use your own clever validation trick. The more unique it is, the less likely it will be automatically discovered and circumvented. When it is, you need a new trick.

A naive captcha is basically a captcha that's always the same image, and works off of the principle that you're site isn't important enough for spammers to manually specify (how cheerful!), but if it's good enough for Coding Horror it's good enough for me.

Of course being an image itself resists the automated discovery of this particular trick, and if it is discovered, manually or otherwise, it's easy to change the image (it need not even be of text).

Implementing my own naive captcha here has been quite effective so far. My next step may be Akismet for manually entered spam.

Implement your own

The patched (against vanilla BlogEngine.NET 1.4.5) files are available here. For making the change to your existing and customized blog, take a look at this comparison courtesy of Beyond Compare 3, or view the compact version below, this post needed some color.

You'll want to change the paths and formatting in CommentView.ascx to suit your liking, also the word "chicken".

Oh, and don't forget that my code sucks, sometimes intentionally even, because I'm lazy. Someone please be my guest and make this a properly coded BlogEngine.NET extension. Furthermore my first attempt was with the strictly-server-side RegularExpressionValidator control you see commented out below, which I couldn't get to work, so I used existing mechanisms instead.

Modified (mostly new, really) code is in red. New code is in blue. The rest is context.

Gaming the game: Cheat Engine, AutoHotkey, and Jedi Academy

2008-12-31T10:23:00+00:00

Pretending to be a Jedi can be a lot of fun; it makes you feel awesome. But what's even more fun is writing code to actually be more awesome. And that, my friend, is the most awesome thing of all.

Which brings us to Jedi Academy. If you fall, you need to get up. If you're force choked, you must retaliate or be strangled to death. It's predictable, it's repetitious, and you could be a whole lot more awesome at it. Why press a combination of buttons to execute a special move when you could use only one, with complete reliability? It's like what a programmable controller did for my Mortal Kombat prowess, with an even faster reaction time.

This type of botting (gamer augmentation?) is a bit more like WOWGlider than an aimbot or trainer, but they're all fairly similar. It's essentially interaction with the game's memory that makes this type of coding difficult, but with the right tools and some good examples you can be on your way.

Cheat Engine

The most important tool in your arsenal is the memory scanner (and more), Cheat Engine. Knowing the circumstances of your character, opponents, and environment means reading the game's memory, and with CE you can find the appropriate memory addresses for things such as health, position, and action/animation.

I tested a lot of memory scanners, and CE was easily the most powerful and useful, capable of many advanced features. To get your foot in the door using CE try the built-in tutorial, which is also explained on the forum. Becoming truly proficient with CE is hard work, you'll need to reason about data types and arrays of structures representing characters and items, learn to master pointer scanning and pointer integrity testing, and certainly remember to save your work. You might need to break out Hex Workshop to compare memory dumps: "Ah, this value is the same for each tauntaun, and a different value is the same for each health pack, must be entity type!".

AutoHotkey

Of course you'll need a language/program to code in. I chose AutoHotkey because it's designed for sending mouse and keyboard commands (as well as manipulating windows, controls, and plenty of other things) and I'm familiar with it. Some further information:

it's very lightweight (<2mB)
it's phenomenally well documented (in fact, the best I've seen!)
scripts aren't natively compiled, but should be as fast as you'll need
scripts can be bundled with AutoHotkey to make stand-alone executables (.exe)
Dll support, such as the standard Windows API, via DllCall
Graphical user interface (GUI) support
Large community

Now AutoHotkey doesn't have built-in memory management functions, but that's why I wrote my own.

Jedi Academy

Here's a list of some fun things my script can currently do:

Allow you to execute a special move (lunge attack, flip attack, and cartwheel) with one keypress, while retaining your character's movement. (This was trickier than you'd think, and it's really cool.)
Allow you to hold down a button for mindtrick, and have your Jedi confuse whomever you look at, without wasting force if they're already tricked. (This is really fun and makes specifically mind trick level 1 quite powerful.) The already-tricked routine needs some work though, see code.
Automatically kill whomever you look at if you so desire.
Automatically retaliate with force pull if choked.
Automatically jump up if knocked down.

Some additional ideas I was only able to rough out:

Instantly kill an enemy with a force choke smash into the ground.
Perform a sideways cartwheel attack but actually fly forward, not left or right.

It's also fairly easy to add code to:

Make dynamic doors disappear by changing their item type, and walking on through!
Change item types so health packs give you grenades, etc.
Move certain level elements by changing their coordinates. (Unfortunately only works on already animating things, like the rather wickedly deadly vent fan at the intro of the prisoner rescue mission. I'm sure it's possible to make it work on any entity somehow.)

Some crazy ideas I hope someone attempts:

Perform a flip attack but spin around to actually continue facing forward.
Determine the most deadly attacks in the Jedi's arsenal by recording average duration of animation sequences vs. damage inflicted.
Automatically scan for certain nearby items, turn to face, perform an action. For example, automatically force pulling nearby health packs and grenades, without interrupting the player.
Automatically saber throw accurately into groups of enemies (okay, this one is another level up in complexity).

Let's have it!

View and download the code here ("View raw file", File->Save As), it's licensed under the GPL. To get it to work you'll also need to download my memory management script into the same folder, and install AutoHotkey. Then edit some configuration values at the top of the main script, and run it. After that your Jedi Academy game should be "enhanced". :)

Everything here is pretty much aimed at a programmer audience, and writing this script was just a hobby of mine I finished ages ago that I thought was worth sharing, so I'm not sure if/how it will work for others, but if you're having trouble leave me a comment and I may be able to help. It's designed for singleplayer, and changing things requires programming knowledge.

If you do anything really cool with it let me know, maybe record a video I can put up, or we'll get your code committed. I'm pretty much washing my hands clean of this now that it's public, I have newer projects to work on. :)

Group/Sort Tabs Firefox extension

2008-07-19T23:17:00+00:00

This extension adds group and sort support to tabs in Firefox.

8-07-08 In addition to having been approved by Mozilla (hooray!), this project has a new support/discussion/feature page on UserVoice! Please drop by and leave me a suggestion, the site is very easy to use, and no registration required.

The source code and changes are still available on Google Code. />

The earlier FF2 version of this extension is "Sort Tabs By ...".

Download | Support

Features

Optionally group your tabs by hostname. (More to come.)
Sort your tabs by last opened date, hostname, or last browsed date.
Intelligently handles the opening/restoration of multiple tabs at once, only sorting when the URL of all opened tabs is known.
Sorts tabs immediately upon navigating to a different URL, prior to full page load.
Tabs can be manually moved into other groups.

Requirements

Firefox 3.0

Known Limitations

The entire host before the first / is matched when comparing host names, so sites with different subdomains (like addons.mozilla.org and developer.mozilla.org) will not be grouped together. This can be undesirable with certain URLs (such as img161.imageshack.us and img299.imageshack.us).
You can only manually move a tab into another group if you drop it somewhere in the middle of the group (no edges). I'd like an easy and intuitive method of grouping/ungrouping tabs for the future.
Manually rearranging tabs out of the sort order is not a feature of this version. I've worked toward supporting it, but decided to release without it. Also, I may be overestimating its importance.

Recommendations

Using ChromaTabs or ColorfulTabs configured to color code your tabs by URL.
Similarly the 'close similar tabs' or 'close other tabs from this host' features of Tab Mix Plus and Closy may be useful.

The Elder Scrolls IV: Oblivion Leveling Assistant for optimal stat gain.

2008-05-01T20:03:00+00:00

I've been playing Oblivion recently, and it's been fun, but I was slightly irritated with the leveling system, so I fixed it.

Here's an overview of how (power?) leveling works in Oblivion:

You select 7 "major skills" and the rest become "minor". Skills advance as you use them. Major skills are no different from minor except for an initial bonus and every 10 major skillpoints gained is a new level, at which point you must sleep in a bed to level up and continue gaining skillpoints. Leveling up has you select three of your stats to increase by respective bonuses, but here's the catch: the bonus depends on your advancement in the three skills related to the stat.

This leads to a sort of reversal of priorities. Your "major skills" are more of the opposite, as you postpone them, and thus leveling, to achieve the necessary gains in "minor" skills to maximize the stat bonus when you do finally level. Selecting your least naturally used skills as major skills is in fact to your advantage. A bit strange, but not a dampener on the fun - you can, after all, go all out in the 14 other skills without fear of accidentally leveling and botching your stat bonuses.

There is quite an annoyance with this approach though. Once you reach the maximum +5 bonus in a stat, skillgain in that area is no longer worth your time until you level up (you'd only be advancing a skill, instead of a skill and a stat) - and aside from gratuitous number keeping, there's no way to see exactly how close you are aside from leveling up, noting the advancement screen, and then restoring to an earlier saved game. Something which becomes extremely tedious considering you must advance to just prior to leveling, save, travel to a bed, use a skill to reach the level point, sleep, level up, pick 3 stats and confirm so you can get to open the main menu, and then restore to your saved game.

An annoyance until now anyways! Enter: Oblivion Leveling Assistant.

Utilizing the ever helpful and entertaining Cheat Engine, I put together a little AutoHotkey program which displays the current points you have towards a stat since your last level. It takes 2 skillpoints for a +1 stat bonus, and +5 is the maximum, so all you need to do is focus on reaching a value of 10 (or more, but don't waste too many) in the three stats you would like to apply the bonuses to before you gain that last major skillpoint, and that's it. Be sure to put those 10 required major skillpoints towards the stats you'll be selecting as well, or you'll be doing extra work!

Download
Oblivion Leveling Assistant (exe)
or
Oblivion Leveling Assistant AHK Scripts (zip)
(scripts require AutoHotkey,
and are equal in performance)

This was a tricky update, so if clarification is needed ask me in the comments.

5-08-08 There's also at least a few mods for Oblivion which overhaul the system to something more acceptable, these might be a lot more useful so you should check them out. (Especially if you play fullscreen and/or use a single display.) Take a look at other mods as well, there's sure to be some you'll consider essential.

I also only just discovered the UESPWiki and its wealth of Oblivion and Elder Scrolls information (including much more in-depth leveling guides), so hopefully I've learned GameFAQs is no longer the one-stop-shop in this new wiki world. />

General productivity enhancements for Vista (and XP): Taskbar

2007-11-18T05:51:00+00:00

This is the first installment of my own personal list of general productivity enhancements for XP/Vista, many of which involve small, resource friendly 3rd-party tools. My general criteria for OS supplementation tools is as follows: They should be simplistic, small, and speedy. It's not much use if it doesn't feel as if it's a part of the operating system itself.

Unfortunately problems and incompatibilities can arise, and there will be a section at the end to address these.

The Taskbar

If you're like me you would prefer to have all of your notification area icons visible. However you may find yourself with less than sufficient room on the taskbar for the tasks themselves. This is especially true if you have a rather wide quick launch area - which can be very valuable, as you'll see in a moment. Some attempt to alleviate this issue by expanding their taskbar to two separate rows, but the additional bulk at the edge of your screen isn't very pleasing, nor will your pointer movement be as precise now that you've introduced a soft edge instead of the single hard edge of your monitor.

Likewise XP/Vista's similar task grouping feature has always struck me as a rather primitive and ineffective solution since you lose quick access to all of your tasks.

A very neat way of opening up space on your taskbar is to move minimized windows to an auto-hidden dock using RocketDock: a minimally intrusive, adequately configurable, speedy little Apple-esque application dock.

Configuring RocketDock version 1.3.5 as a Minimized Window Dock

Although RocketDock is primarily an application launcher, it can be configured to only display minimized windows, as well as be out of your way. Windows minimized to the dock are not displayed on the main taskbar.

I went to the trouble of exporting my RocketDock registry settings and comparing them to the defaults. What remains is a Windows Registry file of only the relevant settings for the particular transformation you see pictured above. I have annotated each of the settings in the file, and you may download it here: RocketDock v1.3.5 minimized window configuration.reg (3.07 kb).

I strongly advise that registry files from every source be previewed in a text-editor before being imported to the registry, due to the awesome and unchecked power that registry modifications can have on your system. Previewing the above file you should be able to note that the only registry key affected is RocketDock's current user settings at HKEY_CURRENT_USER\Software\RocketDock.

Be advised: Holding the Ctrl key when minimizing a window is designed to bypass minimizing to the dock. Holding Ctrl+Alt+Shift will toggle whether or not to minimize that window to the dock normally (these are stored in the registry as the process and window class names I believe).

2-16-08 On Windows Vista systems RocketDock utilizes Desktop Window Manager (DWM)'s public API for reliable live window thumbnails. However, rather unfortunately, in this mode the application's icon is no longer overlayed on the thumbnail. If you can stomach semi-frequent inaccurate thumbnails, then adjust RocketDock.exe's properties and enable Windows XP compatibility for the old (and in my opinion, more useful) behavior seen in the updated screenshot. Or, as I will be doing, you could register with RocketDock's bugtracker and gently persuade PolyVector to add the icon overlay to Vista DWM thumbnails as well.

Your taskbar is on the wrong edge

This may be a subject of contention, and you should of course use whatever you prefer, but in my opinion the taskbar is on the wrong side of the screen. It should be on the top, not the bottom. Although perhaps jaded from all of the separate versions of Windows happily placing the taskbar at the bottom, I had a moment of clarity in which I questioned the traditional, and I moved beyond. Why is the top edge the better edge? The reason is fairly simple: that's where everything else is. Application menus and buttons have a long history of residence near the top, as well as address bars. I find it preferable that my eyes and pointer need no longer unnecessarily traverse back and forth between edges.

Now it's true that this will place a buffer between the top edge and maximized windows - potentially slowing down the time it takes to target the titlebar (for double-click restoring) or the window buttons, but I find those too slow anyways, and don't use them (subject of a future post). (Also, maximized windows aren't quite as useful as they once were.)

Use a persistent stand-alone OS toolbar for mouse application launching

The Quick Launch toolbar is underrated. What appears to be a small space for launching a few specific applications in an unorganized manner need not be any of these things. It is rather apparent that the quickest application launching possible with the mouse alone would require the least input and thought from the user. The start menu is not in the least suitable, requiring far too much scrolling, clicking, and searching for company branded folders, all with the same generic folder icon. Quick Launch is always immediatly present and visible (unless you use autohide) and it's a one click solution. Once we've learned to associate an icon with its respective purpose they are much faster to process and far more compact than text.

Unlock your taskkbar if it's locked (context menu). On XP you could simply grab the Quick Launch toolbar by its border and drag it anywhere you would like - leaving it as a floating toolbar, docking it against an edge, or adding it to an existing toolbar. On Vista you can't drag around toolbars like this - but you can drag the folder itself to an edge to create a toolbar, and then as in XP, add additional folders to this toolbar with Toolbars in the context menu.

So to give Quick Launch its own stand-alone toolbar in Vista it may be fastest to right click the current Quick Launch toolbar, select Open Folder, navigate up to its parent, and then go ahead and drag "Quick Launch" to an absolute edge of your desktop. Be careful not to drop the folder on your desktop itself. Note that there is no cursor change or other indication for this, which is a bit bizarre.

On my 22" widescreen monitor at 1680 x 1050 resolution I can fit a maximum of about 70 icons across the bottom (the natural place for the toolbar, since my taskbar is at the top).

"Now wait a minute Chris. 70? You said organized."

70 maximum. Use as many program shortcuts as you find agreeable, and would like to launch in a single click. For everything else there's a two click solution:

Never navigate your start menu again: Quick Launch pop up menus

You can view a little video of my full configuration for organizational ideas.

I know of two beautiful universal pop-up menu applications. ShortPopUp and menuApp. They both operate the same: they show a pop-up menu of the contents of the folder in which they are run. Therefore creating a shortcut to either of these programs and specifying a folder full of shortcuts (or files) as the folder to "Start in" yields a fantastic menu for your toolbar. There are essential differences between the two.

menuApp v1.04

Pros: very fast with a background server and cache (but server crashes under Vista)

still faster than ShortPopUp under Vista with server disabled

easily use separate configurations in one ini file

very little configuration, would "just work" if not for the Vista problem

support for special folders, like a task list

never displays shortcut arrow overlay on menu items

sorting always works

Cons: context menu problems for menu items (untested on XP): Properties doesn't work, Delete doesn't give a confirmation, etc.

non-shortcut file extension text is always visible ".txt" etc. (if bothersome you can always create shortcuts to work around this in small instances)

ShortPopUp v4.1

Pros: highly configurable: display, sorting, etc.

easily use separate ini configurations

invalid shortcuts display disabled

can access Properties, etc. of menu items through context menu

easily hide any or all file extension suffixes

little bits of humor in the documentation (okay, this doesn't count)

Cons: context menu problems for menu items (untested on XP): they can't be escaped/dismissed without a selection, and selections click through to the underlying menu

can't hide every shortcut arrow overlay

slower than MenuApp

requires configuration (default is very bare bones, no icons, etc.)

sorting seems to fail in several cases, I have yet to understand why, different sorting configurations don't seem to fix it

When I made my decision between the two some time ago, I believe I chose ShortPopUp, configured to be quite similar to menuApp, because it was more stable. I seem to recall that menuApp would not work at all in some common cases unless I used Vista's compatibility mode - but this slowed it down. However, while compiling this list I deleted menuApp's configuration file and allowed it to be recreated (there was at least one peculiar entry in there), and I also have Windows Aero enabled (having it disabled has given me compatibility problems before). I compared each of my menus with each program, and menuApp's speed is just too appreciated; it is my tool of choice.

Middle click close and rearrange tasks with Taskbar Shuffle

Taskbar Shuffle is a fantastic lightweight tool which enables you to rearrange tasks with drag and drop, and most importantly, middle click close. (If you don't already use the middle mouse button to open and close tabs in your web browser, you may want to start.) Taskbar Shuffle also provides the means to rearrange notification area icons via holding down Ctrl.

A small issue or two, which may or may not apply to you

Unfortunately there are some minor problems with these recommendations.

Upper edge taskbar: Many programs attempt to be helpful by positioning themselves at the very top of your screen in an unintelligent manner. If your taskkbar is at the top edge then these windows will be obscured and you'll have to resort to using the keyboard to reposition them (or temporarily repositioning the taskbar). Right click their task in the taskbar, select Move, and press a directional arrow key on your keyboard. The window will now be attached to your mouse and free to reposition. (As Alt+Spacebar opens the same menu for the focused window, I tend to use Alt+Spacebar+M+directional arrow.)

I'm sure this can in fact be automatically worked around with an AutoHotkey script for instance. Since I have a bit of a love affair with AutoHotkey I don't find this too inconvenient of a solution, and will likely whip up a script when I have time.
RocketDock and UltraMon: Unfortunately the extremely helpful Move window to next monitor hotkey feature of UltraMon (which isn't discussed in this entry) has a very annoying issue with RocketDock, where windows, while technically moved, are minimized to the dock. Neither program is really to blame for this problem.

I indeed crafted an AutoHotkey script to fix this, but then realized a much simpler solution was to include Ctrl (but not Ctrl+Alt+Shift, see above) in the hotkey, since minimizing a window with Ctrl bypasses RocketDock. So that's an easy fix. However, since this means Ctrl must be held down until the window is minimized, you can't make a mouse binding (or some other automation) which rapidly sends the hotkey and expect it to work. Since I use a mouse binding I may be resurrecting an extremely simplified AutoHotkey script which merely waits for the minimization before releasing Ctrl.

3-25-08 Fix available here. Requires AutoHotkey. Modify the opening lines for your (true) hotkey and UltraMon's, respectfully. It even refocuses window controls beyond UltraMon's ability.

Investigating Vista's broken file type indexing dialog à la Mark Russinovich

2007-10-08T16:56:00+00:00

So the Thursday before last I set out to configure Vista's file indexing to only index file extensions of type lnk and exe, as I already had it configured to only index the locations on my computer which contained program shortcuts, but I wanted to extend these locations to include a folder of standalone executables and launch them from my start menu as well.

But lo, I encountered this:

Just where exactly did all of my file types go? You can see from the screenshot that the list stopped at .ado.

Well, like any good Windows troubleshooter, I turned to Sysinternal's essential Process Monitor. I re-opened the file type dialog, this time with monitoring enabled, and performed a search for the last file type on the list, .ado.

As you can see from the lines I highlighted in the screenshot above, Vista was failing to read the next file extension in the list, .adobebridge, and presenting an Access Denied error.

Using Process Monitor's oh so useful Jump To... context menu feature, I jumped straight to the registry key having difficulty, and sure enough:

How interesting. Using the key's context menu to view and modify its permissions presented me with this amusing (but accurate, I suppose) little message box before presenting the actual Permissions dialog.

Using the Ownership tab under Advanced to take ownership of the key allowed me to see the permission settings:

As you can see, there are no permissions set at all. Adding the Users group and granting them Read privileges was enough to fix the dialog, but it takes write privileges to be able to actually toggle indexing on and off for the file type, so I made sure to add the Administrators group and grant them Full Control. (UAC prompts you to allow the Advanced settings dialog to be launched with administrative rights when you first enter it, as denoted by the icon on the button: ) As it turned out that there were a dozen or so other keys the dialog choked on which required the same modification. They didn't all have blank permissions, but none of them had read access for my account.

I'm not sure what's broken here, perhaps the software or installers which added these file extensions did so improperly, or maybe it was intentional and they didn't realize the entire file type indexing dialog would break when it was denied access. Either way I would gander that the dialog behavior is most certainly a bug.

Unfortunately I'm not an expert when it comes to Windows Permissions setting, as I've never interacted with them on more than a casual basis, and I've done very little in the way of inheriting and propogating permissions, so I'm curious about the most appropriate and efficient solution to a scenario like this. Include inheritable permissions from this object's parent was enabled for the registry keys with the problem, and other working keys claimed to be inheriting permissions from their parent, but I looked at the permissions on HKEY_CLASSES_ROOT and there appeared to be none to propogate. So perhaps that is not their parent? Any revealing information would be welcome.

(Note: Mark Russinovich of Sysinternals does an ever enlightening job of educating us on Windows internals, making copious use of Process Monitor in the process.)