TechnoSloth

Proactive Legislation

2012-01-25T18:43:00.000-08:00

The recent SOPA/PIPA debacle has me marvelling, not at the hamfisted nature of the MPAA, but at the vast, disparate collection of internet companies, startups, luminaries in the fields of CS, and privacy, and forward-thinking individuals and the effort that was brought to bear on our various legislators. For the most part, it was a loose organization of people and enterprises acting on their own, and the concerted nature of the blackout seemed to be a avalanche where small important actors triggered the event rather than ran it. And the amount of effort and energy that went into it was pretty staggering.

Just think if that amount of energy was put into writing legislation rather than merely blocking legislation?

Providing our congress-critters alternative legislation, completely drafted, seems like it could be far better than MPAA-, RIAA-, Big Oil, Big Whatever providing a significant amount of the guidance as to what the laws should be enacted. We should have our own groups put together ideas, crafting and analysing and reshaping laws to be ultimately given to legislators to introduce in their fora, and then be there to guide them as they try to reshape them to discuss our choices (especially when we chose otherwise).

The problem is that Big Whatever works. Fragmented groups of self-interested individuals and corporations never seem to form a cohesive movement, and only act in concert when threatened and then only from each of their own fears. There is no such thing as Big People or Big Citizenry. If there were, we'd ship the vast majority of Congress home and replace it with people willing to do our bidding, and change the laws to better ensure that they did so. As it stands, Big Citizenry politics is a study in waveform superposition -- it's only when there's enough people who happen to be aligned, when there's a "rogue wave" of citizen support for change, that we stand any chance of making progress. And Congressional rules increasingly impede progress, so that any such wave is likely to dissipate before any action is completed.¹ So we have to be strategic when such a wave occurs, and dismantle the structure Big Everyone-Else has created.

Projects like RootStrikers are on the right track, but the larger "we" need a game plan. First, we have to strike at the things that impede political change:

Cut the flow of money from lobbyists to congress-critters in all arenas: gifts, election donations, PACs, superPACs.
Replace or remove old and anti-democratic Congressional rules: (secret) holds, anything that means we have to have a supermajority to pass anything, anything that requires that every piece of legislation take some undue amount of time and prevent discussion/handling of alternative legislation.²
Improve the ability to hold congress-critters accountable to their campaign statements and their vows in office. This requires a bit more noodling on my part (and I'll take suggestions), but I'm thinking having some kind of contract-like device that allows something short of impeachment happen when they don't follow up at all or, worse, go directly against what they claimed they would do in office. (Can you say, "Transparency?" I knew you could.)

Second, we need to strike at the things that greatly facilitate Big Brother³:

Strengthen privacy transparency requirements. Companies need to be extremely transparent about what of your data is consumed (even if not the special sauce of how).
Strengthen minimum privacy requirements. Companies need to limit what they record about people that is ephemeral to their actual service, and not share it with other companies without explicit approval (that isn't buried in some arcane Terms of Service).
Decentralize. While this isn't a government thing entirely, nor should it be mandated, having a best-practices document and easy how-tos to ensure you don't have all of your online presence stuck in a company's monolithic service umbrella, and that some things are explicitly separated so as to ensure that collusion of several companies and the government (I'm looking at you, AT&T) are required to perform clandestine domestic spying.

Third, we need to strike at the things that inhibit technical progress:

Overhaul the Copyright office. Restore expiration terms to their original values, making considerations for increased lifespans of the creators. Set up iron-clad fair use examples and put the onus of responsibility on the creator to show at least some infringement before issuing take-downs. Make bad take-downs cost you (e.g., a Copyright version of SLAPP).
Overhaul the Patent offices. Require Software Patent Bonds, monies put in by big corporations when applying for patents, that get paid out to finders when said approved patents are later found to have prior art–don't make the system perversely set up to make it so that creators want to not look at the set of other patents to avoid the triple penalty for possible infringement (if someone finds out). Clean the house of bad patents and figure out how better to interoperate with international patents.
Fix the state of anti-logic/anti-science education. It's impossible to get things done when you're not operating with people even remotely attempting to be rational actors.

Then there's a swath of other things I would get at (healthcare, taxation), but I'll save that for another day.

The remaining question is who or what group(s) is/are best set up to provide a cohesive set of legislation to enact these things, and full logistics support to shepherd them through a narcissistic, divisive Congress? And how do we rally the Big Citizenry to support them? How do we start this avalanche?
--
¹To some extent this is a good thing, so that rational thought and consideration drive change rather than instinct and reaction, to avoid the perverse and destructive tendencies of the latter two (e.g., post-911 security theater), not to mention the cost of vacillation when the needle swings back the other way. I just think the knob has been adjusted too far.
²Even the operating system vendors have finally gotten on the bandwagon of not running blocking operations on the main/UI thread. Legislation should have deadlines for congresspeople to consume, understand, and hear back from their constituents, but it shouldn't require spinwaiting; the filibuster should not stall other legislation.
³Government or even corporate strongarming via data collection, aggregation and mining will always be possible. Making every internet service required to have some backdoor putatively for "organized crime" or more recently "the terrorists" just allows entities like the FBI/NSA/CIA/police to selectively target individuals or communities it takes issue with for harassment in the form of selective prosecution.

2011-12-14T18:29:00.000-08:00

Courtesy of BoingBoing, it appears there is sloth orphanage. That is all.

[Non]recourse loans

2011-03-03T09:47:00.000-08:00

NPR’s Planet Money had a podcast describing differences between nonrecourse loans, which Americans traditionally have, and recourse loans, which everyone else traditionally has. The pros for nonrecourse loan systems is that borrowers are more willing to take risks, and thus capitalize on them, increasing the general wealth, at the cost of finding it slightly harder to find banks willing to make loans and general extra volatility of the system with regards to speculative prices. The pros for recourse loan systems is that banks are more willing to make loans, so finding them might be easier, and the consequences of a default give incentive to the potential borrowers to be more conservative, reducing volatility.

What is left out of the discussion is that these systems are not in isolation. The fact that the vastly increased volatility of the nonrecourse mortgage market in the United States has been the single largest factor in the most recent financial crisis weighs in on the pros and cons, since the negative effects of that crisis has sent ripple effects across the Atlantic.

The problem, as I see it, is that we have an iterated prisoners’ dilemma: Whereas the recourse-loan-based societies might enjoy relative stability of their markets if they were in isolation, the fact that we’re all in the same boat means that if other societies “defect” to become nonrecourse-loan-based, then the volatility spills over, the value the recourse-loan-based societies are expecting from stability is decreased. In effect, it means that there’s a new pressure to cause further “defections”—the reward for increased capital risk now costs less, since they’re already incurring some volatility.

Unexpected Mach port refcounts

2010-08-19T17:29:00.000-07:00

I recently found two cases where it was not obvious to me that I would have had ownership of a reference of a Mach port, and resulted in a Mach port “leak”:

mach_thread_self() implies adding a MACH_PORT_RIGHT_SEND on the thread port. It must be followed with a matching mach_port_deallocate call when the reference is no longer needed.
Mach messages received from the kernel after registering with thread_swap_exception_ports may contain Mach ports, depending on the flavor of message. Any such ports must be deallocated by the receiver. If you pass the message along, then you can get away with just transferring ownership along as well, presuming that the next mach port in the chain wants a sufficiently similar flavor of exception message as you do.

In our case, the extra un-deallocated references to the thread port would eventually turn into dead names after the thread died, but would never go away. As a result, if you went through enough threads over enough time, you’d starve your application for Mach ports and it would go unresponsive, crash, or otherwise terminate. In addition, we would incur (via the exception messages) ever increasing refcount on the task port, with somewhat unclear implications.¹

Although I was able to use the dtrace example earlier to do some early diagnostics, since mach_port_allocate was not the only generator of Mach ports in the process (e.g., the kernel when sending us exception messages), it was not sufficient. Instead, I ended up using Apple’s own sample, MachPortDump, in combination with some strategically placed breakpoints in gdb to try and narrow down when the ports were coming into existence, and what the ports actually were.²

It really is too bad that Apple deems these APIs to be unworthy of documenting. Admittedly, only a few developers really need to get down into this nitty-gritty, but if the only choices are reading the 17-year-old Programming Under Mach whose API references are out-of-date and whose code samples don’t deallocate these ports either, reading the darwin source (not an option for me), pestering ADC, or stumbling around in the dark, I can wager what will happen, and what the quality of the resulting products will be on the OS. Perhaps the consumers will lay the blame at the application developer’s feet, or at Apple’s, or both. In any case, it makes it hard to do things the right way, which I’m pretty sure we all want. (Or at least want slightly more than doing it the wrong way — not doing it at all isn’t an option.)
----
¹What does happen when you wrap the refcount number on a Mach port? Hm…
²MachPortDump just lists what ports are in the process and what kind/rights it has, not what the port is related to. You have to be a little creative to figure out what the port being incremented belongs to, e.g., (mach_port_t)pthread_mach_thread_np((pthread_t)pthread_self()) to figure out what the current thread’s port is. AFAICT, there’s no Mac OS X analog to netmsgserver to annotate ports.

Recording the thread ID in Mac OS X Instruments

2010-08-11T12:39:00.000-07:00

Hidden in the depths of the man page for dtrace(1), there is a reference to a new built-in variable, tid:

tid A uint64_t thread ID of the currently executing thread…

What this means is that it’s trivial to log the thread ID associated with a call, which is incredibly useful for multi-threaded applications. (Can you say, “GCD?” I knew you could.) In a custom probe, you can record it as follows:

Thread-based thread-level Mach exception handler and debugging

2010-08-09T13:05:00.000-07:00

Apple implemented an awesome feature in their version of gdb in Xcode 3.2 (SnowLeopard is minimum OS requirement) for those (I hope few) of us¹ who (1) have implemented a thread-based Mach exception handler, (2) actually use it with a mask for EXC_BREAKPOINT to conditionally self-handle breakpoints, and (3) still want to be able to debug the result: thread dont-suspend-while-stepping. The problem that occurs is that when gdb is stepping (either by user specified command or in an attempt to get to a safe-to-read-objc state), it freezes all the other threads in your task. Normally, this is exactly what you want—isolation from the other aspects of your program while you inspect and complete something under the watchful eye of the debugger.² However, if one of those threads is the thread that is set up to handle a thread-level exception by looping receiving messages off of a Mach port, its Mach port gets sent the message (before gdb’s, which is a task-level exception handler, which gets second shot at such exceptions), and the thread never is woken up to handle it, so gdb deadlocks. Enter thread dont-suspend-while-stepping. You tell it to not bother suspending your exception thread, and now it is awake to handle the exception message, deal with it, and respond back to the kernel. Then, unless it intercepts a temporary breakpoint or a single-step exception that wasn’t set by it, the Mach exception message will then be sent to gdb’s handler, and then gdb will resume control nicely. If you want to do this automagically, you can set yourself a breakpoint on thread entry function for your exception-handling thread, have it prevent its own suspension, and then continue on. The general code to run would be:

thread dont-suspend-while-stepping on -port ((mach_port_t)pthread_mach_thread_np((pthread_t)pthread_self()))

pthread_self() will return the current pthread, and then pthread_mach_thread_np will return the Mach port given a pthread.
----
¹ At the moment, I suspect that the people who are actually doing this are

us, i.e., Mac CoreCLR
Java
Flash

It’d be interesting to know if there were yet others, especially if there’s any likelihood you’ll find yourself in a browser process-space. There are some unfortunate interactions that occur when each of these apps either stomp on each others’ exception handling registration, or try to forward messages along the “chain” of handlers. To wit, if you’re calling thread_set_exception_ports, you’re definitely doing it wrong, and if you’re calling thread_swap_exception_ports, it’s only that it’s very likely that you’re doing it wrong. Less so if you’re doing it on entry/exit of your special code. Much more so otherwise.
² It’s not a panacea, in that if you have complicated timing issues between two threads, you’ll need to be a little more inventive.

Dipping my toes into Cocoa again

2010-08-05T11:58:00.000-07:00

Last time I did any significant Cocoa programming was prototyping a Installer-plug-in-style modular pane system for implementing one’s own Setup Assistant, in our case, a Mac Office Setup Assistant. I think it was a toss-up between the Hypercard-like architecture of the system or the product ID field editor which I liked more. But I left the team to head to the CLR before it was complete, and it’s unclear how much of that work was used, cherry-picked, or thrown out for Mac Office 2008.

Since then, the clients of my code have almost all been C++, and my memories of .nibs and actions and outlets have faded. Last week, though, one of the partners using Cocoa reported an issue. I sat down to try and write a simple Cocoa version of our C++ client (with some actual UI) and knew enough to know I didn’t remember enough to sit down and do it. Perhaps if I had spent more than a few months developing Cocoa UI a few years back, it would have stuck better. I popped open my Cocoa® Programming for Mac® OS X (2^nd ed.), and bogged down nigh immediately: quite a bit had transpired in the Interface Builder world since 2004. I don’t remember any @prototype or @synthesize. So, I shelved the project, ordered the 3^rd edition (published in 2008), and worked on other projects.

Now that it’s arrived, I’m looking forward to sitting down with it, Xcode, and Interface Builder and making a simple CoreCLR loading application. It will have use beyond this simple reproduction case, I wager.

No such thing as a Microsoft permalink, part 2

2010-08-04T10:26:00.000-07:00

While I’m at it, let me remind us all of some interesting HTTP result codes¹:

301: Moved Permanently
307: Temporary Redirect, or alternatively 302: Found (elsewhere; continue to use this link in the future though, as it may get moved)
410: Gone

Microsoft has enough storage capability and page-identity capability (GUIDs anyone?) that we could always respond with one of the above HTTP results for any link that we have ever put up on our public websites. The first would be in the event of a reorganization of content. The second would be for whatever forward links we’d created, even if “Temporary” would be a bit of a misnomer. (i.e., it’s rather “perhaps temporary” or “not guaranteed to be permanent”). The last was for content that ended its lifecycle and it and its forward links have finally become deprecated.

In fact, we could go one further and provide warnings in some fashion to “near permanent” and forward links that are about to become deprecated. We could take advantage of the §14.46 Warning header, e.g., Warning code 299: Miscellaneous persistent warning, where the warning text warns (in the character set of the sender) that this particular URL will “die” on such-and-such a date, and give another constructed URL to use to get more information. (And that URL could give the Microsoft’s content deprecation policy, if any, along with perhaps a form where you can give it a URL and it can return its deprecation date.) Alternatively, we could do something more simply, and have any such to-be-deprecated links redirect (via 307) to a URL whose namespace specifically indicates its imminent deletion, e.g., http://www.microsoft.com/to-be-deleted-20010804/someidentifier.aspx. Either of these two mechanisms could be used by external parties who wanted to ensure the persistence of Microsoft content upon which they depend.

Heck, we could go even one further, and spin off a 3^rd party Windows Live/Azure service that did the persistence automatically for a fee, so that Microsoft is no longer responsible for ancient, deprecated content, except in that it supports our own cloud services: Microsoft Web Vault.

In any case, 3^rd party publishers could use these mechanisms if² they wanted to ensure their publications don’t become obsolete too early.
----
¹ See also RFC 2616 §10.
² Not always a good assumption. Publishers like people to buy successive editions of their software documentation at least as much as software publishers like people to buy successive editions of their software.

No such thing as a Microsoft permalink

2010-08-03T17:03:00.000-07:00

As far as I can tell, anyway. While reading 3^rd party documentation¹ about our own technology, I often run into links to msdn.microsoft.com that are 404s. I know that internally, we use redirection links when we expect content to move over the course of the lifespan of a product that might need to use it (e.g., for help support), but it seems silly to force publishers to do the same. Should it also be their responsibility, in the case where MSDN does a content reorg and deprecates old content, keep a local cache on their own website to support their own books? It would be seriously nice if there were (1) a way to request a permalink², and (2) be able to instantly tell whether a URL link was a permalink or an ephemeral link, to know whether or not it should go into a publication / blog post / etc.
----
¹ e.g., Professional JavaScript, which I ended up borrowing from one of the authors. Thanks, Stuart!
² Or at least one that had a specifically determinable lifetime that the publisher could then caveat in the introduction, or take steps to do the caching I mentioned before.

Monday is the day to take on the hard task

2010-08-02T11:16:00.000-07:00

Having read recently about The Top Idea in Your Mind (thanks McMichael!) and reading about getting things done, I am positing that the best day to work on the hard task is Monday. (And yes, I realize that I’m procrastinating right now—baby steps.)

I’ve gotten to the point in my work/life-balance where I can actually put my work down at the end of the day on Friday (eventually) and largely not consider it until Monday. This is an improvement over having my wife wondering why I’ve sequestered myself in the office to connect to work over VPN and twiddle some bits. On the other hand, since I don’t do a prep-time for work Sunday night (and I may yet adopt this behavior), on Monday morning, I’m generally thinking only of personal Deep Thoughts™ rather than the work break-through I might be needing.

This comes to, until now, what had been my general Monday workday makeup: 75% reading through new e-mail and re-reading through last week's e-mail and piece-wise following up on the low-priority but small-cost items that I could accomplish. 25% contemplation of the actual task for which I’m either planning, or worse planning to plan. My estimation is that I don’t actually “page in” enough context by the end of the day for good analysis, and so it’s only Tuesday where I actually start useful work on the hard problems.

Thus, I have the intuition that pushing the small bits until Tuesday (or later) is the right way. Even if I don’t make real progress on Monday, spending enough time to fully consider the problem allows for a Monday night dream-solve and Tuesday morning shower-revelation, and probably sets the stage for even better progress on Tuesday.

The little bits are always something that can be dealt with in the interstices that inevitably occur during planning and development. (There’s a reason to have multiple machines and/or multiple source control enlistments simultaneously—parallel processing for the win!) And since they don’t need the same context switch, or have the same priority, best to postpone them until you’re already on a roll.

Now, to buckle down and implement this plan…

How little Johnny application doesn’t play well with others

2010-01-29T12:20:00.000-08:00

Spotted this post on the ranchero.com RSS feed about New World vs. Old World computing, making the argument that Old World desktops are all-purpose machines, vs. New World computers (currently, mainly the iPhone/iPod) are more narrow-purpose machines, and even when they have more than one purpose, the purposes tend to be siloed and sandboxed.

Notwithstanding the arguments about the computational and energy savings of only running one app (and limited system services) at a time, there’s a good reason for the siloed/sandboxed nature of these applications, and that is that by default, applications do not work well together on an Old World desktop. Despite the best attempts by platform designers to engineer a product where you generally don’t step on other apps’ toes, and best practices published that try to bridge the gap between the platform’s strictures and programs’ capabilities, apps step on each other all the time. They incorrectly rely on shared state¹, or worse, destructively edit shared state that happens to work fine (for them). They are not uniform in the way that they share data between applications (copy/pasteboards and the formats provided, file system and the file formats of the files, sockets and the protocols that run over them). The data you want in one app might be data (perhaps slightly tweaked) that you want in another app, but unless you’re a Excel or Perl² wizard, getting from A to B is a whole lot of work. Even in systems designed by the same company to work together sometimes fail in these regards, especially as their feature sets and complexity grow³. Lastly, there is no nice model for assigning execution control to applications; customers rarely know when some hidden plug-in is monopolizing their system and causing scrolling or typing to slow to a crawl. How many times have you just wanted to read one e-mail, but some untold number of system agents conspire to time-share your processor enough to steal time from what you really need to do?

And that’s when you actually trust the application to run on your box. For most software manufacturers, you can generally trust that they didn’t mean to do any harm (and yet they still do). Then there’s the class of app-makers who write apps that are just-useful-enough that you install them and all the malware / exploits / junk that came along for the ride. Since the average Joe doesn’t know the difference necessarily, he’s either afraid to click on the utility that might just solve his problem, or he’s opening up his system to possible attack vectors by clicking on the utility, or he’s incurring the not-insubstantial overhead⁴ of running anti-virus/anti-spyware programs.

The siloed approach capitalizes on the generally limited way these programs communicate their data by making that the choke point–data flows can be to internet site(s) or the user through UI, and that’s it. No tromping on other apps’ data. No mismatched communication with another app on the same box through the traditional pathways (and even web services don’t work since you won’t have both apps up at the same time). There still may be issues about spyware, and it’s unclear whether an app validation service such as Apple’s could clearly tell whether a user’s privacy would (possibly) be violated. But for the most part, you running an app means pretty much that you can only really take down your own app, and spend as much battery as you want doing so. Siloing means pushing the problem of communicating that data between local services to be between cloud services (e.g., Facebook and twitter integration), where there’s now a whole new playfield where cloud apps won’t play well with others. But it does mean that your local box will do as well as its purpose-driven cloud support will do, and without interference. And that means a lot.
--
¹Can you say, “registry”? (Or machine state, but that’s not a problem solved by New World machines either.)
²Insert any reasonably advanced script language that parses (regexes) strings and byte data and permutes the same.
³Not that Microsoft has any examples of these. ;0
⁴Both in money and human/computer time.

Running ClickOnce apps at startup

2010-01-29T10:15:00.000-08:00

We use an internal tool to keep a watchful eye on the various bug databases we might have bugs in, to get notifications when new ones come in and to provide a fairly reasonable summary UI. This was internally released as a ClickOnce (Wikipedia) application using .NET. I thought it best to put it in the startup group to run on login, but found after working a number of times, it stopped launching at some point. Turns out, this is because you can’t put the application reference in the Startup items since it might move as later versions get installed. Instead, follow this article by Keith Elder to create a regular old internet shortcut and get the right behavior.

Ellen's Black Beans and Rice recipe

2010-01-08T18:45:00.001-08:00

---begin-tinykitchen---
Title: Black Beans and Rice
Serves: 8-10

1 lb black beans
1 lb smoked link sausage
0 - ham hocks (optional)
2 - onions (diced)
1 can RoTel tomatoes & green chilis
1 tsp Tony Chachere's Creole seasoning
1 can chopped tomatoes (large can)

Prepare black beans according to instructions on bag for quick cooking, drain, then cook in pressure cooker. Fry/steam the smoked link sausage in a frying pan, drain, and cut into small pieces. To the beans add the sausage, ham hocks, onions, tomato & green chilis, creole seasoning, and chopped tomatoes. Cook long and slow, simmering until sauce thickens. If you use a crock pot, leave beans uncovered so sauce can cook down. Serve over rice with salsa and sour cream.
---end-tinykitchen---

Delta is my friend

2009-11-16T15:11:00.000-08:00

I think it was a couple years ago when working for the CLR and running into what appeared to be a compiler issue in a newer version of gcc. Zipping up the entire enlistment and shipping it to Apple would have been a rube mistake: (1) Microsoft doesn’t really want its source disseminated unnecessarily, even if the partners have a limited non-disclosure agreement. (2) Even the youngest tester knows the mantra: get a small, simple repro.

Suffice it to say that our source code is rather complex (and probably a small factor more than it need be). Generating a giant .ii file and then culling it manually to keep the reproduction while shedding intellectual property is a soul crushing problem. You can make some educated guesses at what is causing the compiler to behave oddly, but sometimes those guesses are ill-founded, and there’s no easy way to get to minimal repro.

Enter Delta, which Mike Stump of Apple pointed out to me. It takes the tedium out of reducing the reproduction down to a minimal one, making the obfuscation/renaming process usually much easier (unless something about the names themselves are problematic).

You start with your giant reproduction: g++ flags flags flags -c file.ii, where file.ii is the preprocessed version of your source (i.e., replacing the “-c” with “-E” at the gcc line). In our cases, this can be something like 1.8 MB of text file. You then write a simple “interestingness” decider script, e.g., that gcc succeeds in compiling the source, but that the output contains a particular warning. Then you run Delta in several iterations, and it selectively removes parts of the source file, tests the file for (continued) interestingness, and if it is still interesting, it caches the smaller result, and keeps going, looking for more text it can remove and still have the repro intact. Several hours later (of the computer’s time rather than your own), it can knock the size down to a few K of text, and then the whole problem becomes much more tractable.

I’ve probably had to post only six or so bugs that fell into this category, but Delta has saved me tremendous time and effort.

Getting background pictures on disk images to “stick”

2009-11-16T10:23:00.001-08:00

As a part of working on an installer for TeachTown, I ran into a problem where we were trying to make an automated build process for the installer and making a nice disk image for the installer: the process of assigning a background image via AppleScript would work in the moment, but after you hdituil detached the image, it would vanish. e.g.,

osascript -e 'tell app "Finder" to set background picture of icon view options of container window of disk "disk_name" to POSIX file "full_path_to_image_file_on_disk_image"' hdituil detach /Volumes/disk_name

We found that running sync wouldn’t help, but that if we waited a while (e.g., sleep 5), it would usually “take.” Well, Apple replied with the Magic™: The Finder doesn’t commit the changes made to Finder metadata immediately to disk, and whereas if you told the Finder to eject the disk, it would know better, write its metadata and then eject, but for whatever reason hdiutil detach would just unmount the disk image out from under the Finder and it wouldn’t necessarily have known to write the metadata first.

Workaround and/or fix: Use the update disk verb to force the Finder to write out the metadata. e.g.,

osascript -e 'tell app "Finder" to update disk "disk_name"'

That should make sure that background image and icon size/placement settings that you made get committed before the detach.

Avoiding strange gdb errors in SnowLeopard

2009-10-13T16:17:00.001-07:00

If you’re suddenly experiencing the following warnings when loading a binary

unable to read unknown load command 0x80000022

and the following error when running your binary

Error calling thread_get_state for GP registers for thread 0x14855lxerror on line 207 of "/SourceCache/gdb/gdb-768/src/gdb/macosx/i386-macosx-nat-exec.c" in function "fetch_interior_register": (os/kern) invalid argument (0x4)

then it’s very likely you’re running the wrong version of gdb. In my case, I have both Xcode 3.0 and Xcode 3.2 installed, since the former is the “officially supported” toolset (i.e., what the build lab is using to produce our products). Unfortunately, our build environment, in an attempt to keep you from accidentally using the wrong tools / SDK to build the product, will set the path to include the official toolset’s /usr/bin (e.g., /Xcode3.0/usr/bin) before /usr/bin. Thus, I was accidentally getting the older version of gdb, which doesn’t work quite right on SnowLeopard.

Fix: Use the Xcode 3.2 (or later) version of gdb.

Rich support for multiple (versions of) OSes: autoconf?

2009-08-31T21:23:00.000-07:00

After many years of working on multi-platform applications (and now also multi-platform platforms), I find it incredibly difficult to try to be rich on all of them, and not either drastically increase the cost of production (with regards to testing resources) or reduce overall quality (screwed up boundary cases, where the “boundary” is much, much closer than one’d like to customer uses). One of the longer term issues that especially affects the Mac platform for Silverlight is our mechanism for building the CoreCLR.

What we’re building today is highly related to Rotor v1 and Rotor v2. The Rotor project was the shared source release of the Common Language Infrastructure, aka SSCLI. Rotor v1 was fairly multi-platform because Microsoft really wanted to show that their new CLI was a realizable technology on alternative platforms. It was released under the shared source license so that academics could peer under the covers and that, despite a facile JIT-compiler and garbage collection mechanism, the system would work and also how it would work. Figuring they’d proved their point¹, the Rotor update to v2 was hamstrung further — they needn’t have it work on all platforms. The nice framework they had built and managed to allow for building Rotor v1 on multiple platforms had suffered bitrot and would build on nothing but Windows.

Fast forward several years and past an internal project that never saw the light of day, and you get to the inception of the Silverlight project. They had a mechanism that would (mostly) build something for FreeBSD, and with some minor tweaks, would build for Mac OS X². Furthermore, another (defunct) team had gone through the effort to port the commercial JIT-compiler for x86 and the commercial garbage collector to GNU, so they had most of what they needed to start working³. Several teammates and I worked on this for a couple of years before it was picked up by the Silverlight team for the 2.0 release. Over the course of that time, some effort went into not completely destroying the ability to build on other OSes. That said, the only shipping product that was using the Rotor project at all was the Mac version of the CoreCLR⁴. I am positive that not only that you could not build our CoreCLR on other platforms using our source, but that I, myself, included code and/or improper #ifdefs that would make it not work. Not by design, but simply by not having a product for that platform.

Mono/Moonlight is both a blessing and a curse in this regard. As much as I might have wanted a business proposition that would have put a Microsoft-written CoreCLR on more platforms than just MacOS, the environment was/is not ripe for such an idea. The great deal we have with the Mono project means we’re likely to get the platform on many, many more OSes than Microsoft proper would have been willing to fund. On the other hand, the “curse” side is that there really is no other platform than MacOS for the autoconf-based/multi-platform-aware/multiplatform-capable build system to build. No reason at all to have all this extra gook.

In fact, this gook gums up the works somewhat. We broke a whole bunch of original assumptions when we finally released the Mac OS CoreCLR. We went from the autoconf premise that you’re building on the machine that the built code is meant to run on. Instead, we wanted to run on systems 10.4 and up, independently of whether we were building on 10.4, 10.5, or even pre-releases of 10.6⁵. Furthermore, we wanted to be warned of potential future issues on 10.5 and later. As this to the idea, before it was deprecated, that we might build x86 on ppc and vice versa, that there are build tools that we need to create to actually build the product, and then there’s the product itself. The former need to run on the current operating system (even if through some kind of emulation — e.g., if on x86_64, ppc (if Rosetta is installed) and x86 are valid build tool architectures) and the latter need to have the cross-OS-version behavior we want (i.e., not using any deprecated APIs for one of the later OSes, and selectively using new-OS APIs via dlsym or CFBundleFunctionPointerForName or weak-linking. If we had gotten it right (bwahaha), we’d’ve cached config.guess files for other architectures and made sure the built products would Actually Run™ on the platforms for which they were built⁶. As it stands now, we have this overly complicated system that, yes, allows us to actually use 10.5 compilers to build the stack canary support into the applications we use on 10.4 (and not when we're building using the 10.4 compilers, which is purely an internal testing mechanism), but it also means we pass all sorts of extra grik around:

Mac OS SDK
Min ver (currently 10.4)
TBD: Max ver (as max as we can get it)
-arch flag for gcc (since autoconf cannot guess this with any utility uniformly across 10.4/10.5/10.6)

Plus, we use this external mechanism to enforce these same things on our partners’ Xcode projects (not everyone made the decision to use the same build system for both Window & Mac, much less the NTBuild system that we inherited) — we invoke xcodebuild with the specific SDK and various other #defines we want.

However, even when we get this right, and we use the old APIs for older OSes and the new APIs selectively, i.e., on the OSes where they’re supported, there’s no default mechanism for demonstrating that we’re doing it right. Nothing to call out that we have these references to specific APIs that are deprecated, but only in OSes where we expect them to be usable. No handy mechanism to segregate out these uses so that they can be deprecated when we change our own internal requirements to support a newer OS. It’s all internal manual review. I suppose things move slowly in the OS world, but I’d prefer that we’d be able to qualify all of these call sites with the right metadata — use this on downlevel OSes and this on modern OSes and effectively remove it when it’s no longer necessary, with some kind of deprecated code not included warning to let us know, so we can remove it at our leisure.

Notwithstanding these cross-OS-version issues, there’s still the issue that the autoconf-centric mechanism gets stale by default. We regularly create or view new Xcode projects in newer versions of the Xcode toolsets just to see what flags get sent down to gcc/ld so we can emulate the new behavior in the configure.in scripts. There’s a fairly rational argument to be made that we’d require less intervention if we just used Xcode projects for everything. The counter-argument is that if we did, we probably would not have to be as introspective as we are about how projects are built to get them to build, or, more importantly, to Work™ — we’d blithely build and sort out the bodies later.

There’s still no real solution to having multiple config.guess files for the multiple OS versions your app supports and some summarizer that converts that into static code changes for the things that are determinable (like all versions of the OS support dlfcn.h functions), and into runtime code checks plus disparate behavior for things that came into existence with a particular OS version. At this point, is autoconf too unwieldy to keep? Should we move to a simpler mechanism and live with the stuck-to-this-OS-ness it implies? Hard to tell. Any change will require some work. The only question is, is it more work than we would otherwise need to do over the long haul.
--
¹Actually, I don’t actually know what they were thinking; this is supposition on my part. It predates my joining the CLR team by a couple years.
²In fact, one of the reasons I got the job is that I complained to them saying that their Rotor v2 release had broken the Mac OS X build, and that I had some patches that would fix some of the damage. This put me in contact with one of cross-platform devs (from which I inherited most of the Mac responsibility ultimately) and the dev lead of the project, who was willing to give me contribute access, even though I was from another Dev organization. When they realized they needed a Mac guy, they talked to me. As it turns out, they might have benefited more from a Darwin/FreeBSD guy, since my knowledge was more old-skool Toolbox than a born-again *nix guy (since I had done *nix work in college when I wasn’t working on 68k code). At least at the time. No longer. Plus now they know more about CoreFoundation than they ever wanted to know.
³Sadly, they didn't have a commercial-quality JIT-compiler for the PowerPC, so they just recirculated the good ole FJIT. (The “F” stands for “fast”, and by “fast”, I mean JIT-compiler throughput, not JIT-compiled-code execution speed.) The results were pretty shoddy — it worked but the word “performant” wouldn’t be seen in the same room as it.
⁴The build system for Windows Desktop CLR maintained the rotor project for quite some time beyond its last release, in the event it would be shipped again. However, in the spirit of “testing just enough” (i.e., testing sparse points of the matrix), we stopped building the Window rotor project some time ago, presuming we were doing better testing by having a real Mac rotor project that we had to actually ship.
⁵Don’t even get me started on that you cannot code on Mac OS X to be OS SDK-independent without Major Hackery™. Regular changes to function prototypes break our warnings-as-errors compilations.
⁶In the days before PowerPC was removed from our list of shipping targets, we had the capacity to build the opposite architecture on the same machine to make sure you hadn’t hosed the other side due to your changes. Well, it was all fine and good, except that it would not run at all. It did a fine job of catching compiler warnings, but at the top of the world, the endien #defines were all wonky because the values for the current build machine had bled into the target architecture. In the event that PowerPC was ever made little endien (not just little endien mode, like the G4 and earlier), perhaps this might have worked.

Failure to clean

2009-08-04T16:21:00.000-07:00

While considering what to do for MQ¹, I ran across a presentation (video) that Peter Provost gave for NDC 2009. He has an awesome analogy between coding and cooking at 31m into the presentation:

I was very fortunate to work for a good chef, and one of the things that he taught me was to be constantly cleaning up as I was cooking… [If you are forced to have the big clean up at the end,] as you’re constantly piling on the scraps of food all over the counter, and the dirty knives and plates, it totally gets in your way. At the end you stop and say, “We can’t cook any more food for an hour; we got to clean up the kitchen.”

If you can imagine that a version six product (where a product cycle is about two years long) is like a kitchen where people have been constantly working in for twelve years, and at no time has anyone actually cleaned it up all the way, and finding clean space to work in and clean tools to do the work with is getting progressively harder and harder, then you have a very good idea of what writing software² is like.
--
¹MQ is Microsoft parlance (perhaps others too) for a “quality” milestone. Milestones is one way to divide up a large set of tasks that you want to work on during the course of a single product cycle, and the ones which add features are generally M1, M2, etc. MQ (or M0) generally starts (or is in the interstice between) product cycles, and generally focuses on infrastructure and code-quality improvements—things that only have a secondary impact on whether customers will want our software, i.e., that we are efficient in making those other changes.
²Well, writing software in a non-agile or limited-agility way.

Entourage is taking a work break

2009-07-21T17:18:00.000-07:00

I honestly don’t remember when I first started using Entourage. I suspect it was back before Project Athena was named Entourage, and was simply the Mac version of Outlook Express. I’d hooked up my work Exchange server account via IMAP, and later Entourage’s built-in Exchange support. Yesterday, for the first time in many moons, I can’t use Entourage to access my work e-mail.

The reason: We’re moving on up. Many Microsofties’ accounts are getting migrated to Exchange 2010 so we all can dogfood, dogfood, dogfood. And WebDAV in Exchange 2010 has gone the way of the dodo¹.

Never fear, intrepid Mac Office users: in lieu of switching to the aging, legacy, Windows-centric MAPI, the Mac Office folks are designing forward to the newfangled Exchange Web Services (EWS), the faster replacement for WebDAV. EWS works on Exchange 2007, and will have expanded capabilities in 2010.

Nonetheless, we dogfooders are stuck choosing between hot dogfood-on-dogfood action (i.e., the latest builds of Entourage EWS against the pre-release Exchange 2010) or waiting until Mac Office makes their release. Since I’m no longer on the team (i.e., not building and debugging it day in and day out), and it’s both about my home and my work data, I’m inclined to sit this one out, and wait on pins and needles until they come out with the new coolness.
--
¹A better list of changing APIs for Exchange 2010 can be found here.

Home networking and its woes

2009-07-11T16:08:00.000-07:00

A couple weeks ago, I updated all of the Ethernet hubs in the house to support gigabit ethernet. It’s not that I have many devices that would take advantage of this, but I suspect more and more as time goes on will. Nonetheless, this most recent upgrade still didn’t quite work out perfectly: the Netgear ProSafe GS108 in the office connecting to the Netgear ProSafe GS105 up inside the Leviton Structured Media™ box won’t train to gigabit speeds, always falling back to 100 megabit. Grr. Not sure exactly how to diagnose the problem. (The same problem doesn’t occur between the 105 and an identical 108 unit in a different room.)

At the same time I updated the hubs, I decided it’d be nice to actually have more than one working telephone jack available. (I mean, it’s downright tragic to have this awesome patch system in the Leviton box and yet only have one real phone line—connected to the modem itself.) I could put little DSL filters in front of them, but that posed a problem for the only other (prospective) phone in the house — a wall-plate-mounted kitchen phone. We didn’t have a DSL filter that would fit that and have it stay on the wall. So, I did some research and found that of course Leviton makes a DSL filter board (47616-DSF) to stick into the box. When I got it, I realized that I didn’t have (nor really know how to use) a punchdown tool. Fortunately, one of my friends who is a hardware geek did, and gave me the explanation on how to use it. I rewired the phone to go through the board first, but got zero love -- no signal seemed to come out of the “to modem” (or at least it never reached the modem), even though the phone lines still seemed to work correctly. Double grr. Now it’s re-patched to the original configuration, and there’s still no phone in the kitchen.

After all this, we started noticing that our internet service seemed seriously degraded. We have Qwest “Platinum Package” using Drizzle as our ISP. Today, I looked at the modem’s web interface, and it said that our 7 Mbps connection was connected at 3360 Kpbs. That seemed rather unreasonable, so I did some research and found some ugliness — the current description of “Platinum Package” advertises “up to 7 Mbps” (and that makes sense to some extent, seeing as though they could have the fastest modem connection ever, and the ISP may still be the slow link), but they only guarantee at least 3 Mbps! I don’t remember that being part of the deal when I signed up; perhaps they changed the policy? (It’s not like they publish the historical policy changes so that you can see when the terms of the service changed out from under you.) I thought that it was possible that it was my forays into rewiring the punchdowns that caused the problem, but after connecting the modem directly into the telephone test jack where the phone comes into the house, it got even worse training. Putting it back where it was retrained it to 4400 Kbps, but then I updated the firmware on it (which required a reset and retrain), and now it’s back to 3700 Kbps. Let’s just say that our instant-watch Netflix movies on the Xbox 360 went from 4 bars, sometimes dropping to 3, to starting at 2 bars and bailing out entirely within a couple minutes. Really rather frustrating. Qwest’s web page talks about a “Quantum Package” (aka Fastest) that goes “up to 12 Mbps” (with a guarantee of what?), but their availability query suggests it’s not available for my phone/address.

I am tempted to jump the Qwest DSL ship (or at least them running the show — using Speakeasy or something) and venture into cable-internet. I just really want to have something akin to a guaranteed 1 MB/s (8192 Kbps) down and not have it preclude the ability to connect from the Internet into a machine on the home network.

With all of these sequential failures, I’m even less inclined to continue to plan an updated wireless network, complete with a guest VLAN. I had hoped that perhaps the ReadyNAS NV+ would support some RADIUS service so I could just make the denizens use 802.1x, and route guests only to the internet. Maybe someday.

Silverlight 3

2009-07-10T10:30:00.000-07:00

Our partners over in the Silverlight Runtime (SLR, formerly Jolt) have done a bang-up job working on Silverlight 3, which is released to the public today. There are scads of new features. Go check it out!

We did some very targeted features in the CoreCLR for Silverlight 3, but it is largely the same engine as it was before. One of the important parts for Mac users is that there are some changes to be compatible with Snow Leopard in there. (Silverlight 2’s CoreCLR mostly works, but there are some edge cases that might show up issues, depending on the Silverlight application.)

Over here, we have our heads down for the most part, putting the finishing touches on the Visual Studio 2010 (aka Dev10) release. We’ve already released a Beta 1 of the new .NET Framework v4 (including our CLR bits). Finally, the desktop CLR will see some of the stuff that we’ve been showcasing in the CoreCLR! Furthermore, Visual Studio will have several improvements to support the design and debugging of Silverlight content.

It’s always nice to see one’s work finally make it to the public.

Proof positive that the GPL kills kittens

2009-07-09T20:51:00.000-07:00

Daniel Jalkut, over on Red Sweater Blog, recently had a good rant about the GPL. Ok, maybe not proof about the kittens, but still…

Back in action

2009-05-20T13:10:00.000-07:00

Just received a replacement hard drive, the 500GB Seagate Momentus 7200.4, and after spending 40m yesterday taking out the old 320GB 5400RPM drive that would periodically stop responding, I’ve been spending time getting my MacBook Pro back into action.

Transferring my Mac OS X partition with Disk Utility and my WinXP bootcamp partition with WinClone went very smoothly, and now I’m finally at the point where I'm going to put a code enlistment back on it. DevDiv for this release is using Team Foundation Server for our source control, and for the Mac side, we’re using the Teamprise client to access the server. It’s churning along in the background considering what files it’ll need to pull down to replace my deleted enlistment.

On the cool side, due to our data-at-rest policies for laptops, I’ve recreated an encrypted sparsebundle disk image for the purpose of storing my source. Historically, I would have just used the -encryption flag to hdiutil and relied on the security of my local machine’s keychain to keep the secret. However, since Gemalto has released Mac OS X tokend plugins for its .NET v2+ cards, I can use the certificate off of my Microsoft badge as the security, now requiring thieves to either crack the stock encryption or to also steal my badge and my PIN. (Good luck with that.)

Building services are going to be replacing the carpet and putting a fresh coat of paint on the walls this evening, so I’m putting all my books and peripherals into boxes. I only hope that my sync is done by the time my office is packed so I can go work in the new commons.

The shackles of IP taint

2009-04-19T15:58:00.000-07:00

or
How it’s easier to drink the Kool-Aid™
if it’s the only drink you’re allowed to have.
The problem: If you, as a developer, introduce intellectual property into Microsoft’s distributable software portfolio¹, and the ownership of that intellectual property is under dispute, Microsoft may come under (additional) threat of lawsuit.

The “solution”: Make the policy such that Microsoft employees have no way of copying any external IP—make it against the rules to read Open Source code by default, even outside of their job.² To a lesser extent, except for specific competitive reviews, even using alternative products (esp., if it’s a development product) is frowned upon lest you absorb possible IP in the visible framework code.

The ramifications for your average Microsoft software group aren’t that problematic. They’re generally consuming the Windows OS (Microsoft), using the Visual Studio tools to build their project (Microsoft), and the majority of the analysis and testing tools are Microsoft. Furthermore, if you don’t understand an API’s MSDN documentation, you can just load the symbols and debug right into it and find out for yourself what is going on (or going wrong).

But it does mean that you are limited to what the “state of the art” is to what the Microsoft-available solutions are, and furthermore to not really know what you’re missing.³

As soon as you get on the fringe, the all-Microsoft strategy starts to slip. As a MacBU developer and now as a CLR developer working at least part time on the Macintosh CoreCLR, very little is in-house. Trying to track down something in a closed-source Apple product is just as bad as Apple trying to track something down in our closed-source products, so we get a taste of what it’s like to be a third party. But even when it’s open source, we still can’t download it and look at it. Even if it would be expedient to do so to figure out what our (mis)use of it was. Even when the documentation is sketchy or ambiguous.

So as it stands, we rely heavily on ADC. We can’t peer into the code, but they can and give us hints, or code samples. And obviously, they go and fix bugs we report in their software, as well as in the family of open source projects that are released with Mac OS X. Which leaves us back again working in our own sandbox.

It sometimes takes years for external ideas and outstanding tools to penetrate into Microsoft, and it seems to me, almost entirely through people who are new industry or college hires, bringing in their previous backgrounds (taint notwithstanding⁴) with, generally, open source community. The rest of us have to work hard (and run a rather annoying gauntlet) to keep from relaxing into navel-gazing.
--
¹As opposed to in-house tools that are not distributed.
²Unless it can be demonstrated that there are sufficient business reasons to justify the expense of having the legal team review the licensing, and incur the additional risk to Microsoft.
³On the other hand, we also have the problem that there are usually many different (sometimes nigh identical) solutions to the same problem that aren’t well publicized and thus proliferate.
⁴If a new hire made significant contributions to an open source product, then they’d be barred from working on any Microsoft product that would be of similar ilk, presuming that that would be the IP they might leak from external sources into the MS codebase. Unfortunately, there’s no good mechanism to determine what the overlap is, so it’s just a matter of how much risk the dev managers and legal team think they’d incur.

Baked Mac & Cheese

2009-04-07T22:48:00.000-07:00

I’ve never really been particularly good in the kitchen. I tend to need a recipe and to have all the ingredients, and generally to only work on one thing at a time. That and I’m never quite sure where everything is, and generally have to look in three separate places.

Nonetheless, recently, I’ve been making a particular dish multiple times, and am getting better at timing things to be ready Just In Time™: The Joy of Cooking (‘97 edition)’s Baked Macaroni and Cheese.

My friend Mason, author of the Tiny Kitchen iPhone application, swears by the Cook’s Illustrated version (the older, adult version), and I will have to try it eventually. Nonetheless, his app has helped me on more than one occasion to set up a shopping list so I can remember to get everything I need for it.

Towards that end, I am adding it here, in Tiny Kitchen form, sans Joy’s copyrighted description:

---begin-tinykitchen---
Title: Baked Macaroni and Cheese (Joy of Cooking)
Time To Cook (in minutes): 45
Tags: dinner

----
2 cups elbow macaroni
3 tbsp. butter
2 tbsp. flour
2 cups milk
0.5000 - onion (minced)
1 - bay leaf
0.2500 tsp. paprika
2.2500 cups sharp Cheddar or Colby cheese (grated)
- - black pepper (freshly ground)
0.5000 cups bread crumbs (fresh)

----

Guid: 4EC3A73B-5A81-4EA2-A600-8C20A84AC72F
---end-tinykitchen---

I’ve tended to shop at Trader Joe’s for the ingredients, and use these specifics:

Like Cook’s Illustrated suggests, I use a blend of mostly sharp cheddar (extra sharp Celtic or extra sharp Wisconsin, for more orange-y look), and some Monterey Jack.

I use fusilli rather than elbow macaroni.

I use (organic) whole milk.

I also buy frozen chicken breasts, and broil two to add a little tasty protein to my fat and salt.

I’ve used Tiny Kitchen’s recipe scaling feature multiple times, having prepared it in a single batch only once. More often it’s in two or three times quantities. I’ve found it difficult to figure out what the right amount of time, or really, the right creamy consistency to reach before pulling it off the stove and adding the cheese. Also, trying to add salt and pepper to taste for varying quantities seems hard to get right.

I made it again this past weekend in a double batch, half for us, and half for our newly-parents-again friends S. Ben, Meghan, “little” Nathan, and now Eliza. From my own tastebuds, it was a good run.

IP for loans?

2009-04-04T13:56:00.000-07:00

With the big three auto manufacturers repeatedly asking the government for loans to stay alive, I think now is an excellent time to use our leverage to make those loans with the condition that they sell the IP rights on selected parts of their patent portfolio into the public domain in exchange for some amount of debt forgiveness. Whereas it’s going to be impossible to clean up the patent law in any near term, it would be interesting if some of those defensive patents became available for use without licensing. I wonder how much is in there that inhibited competition?

On the other hand, as an alternative to releasing them into the public domain, it might behoove American citizens to have the government retain these patent rights on our behalf. In today’s world of cross-licensing deals, and having one patent-infringement case always spawn a host of counter patent-infringment cases (in a MAD sense), perhaps it’s better to have a defense for the public.

Right now, if you, as an individual, infringe on a patent without the requisite licensing, you may get a cease-and-desist order (if they find out), and may have to pay a rather hefty fine (with treble damages if you knew you were infringing). Companies can get hosed, because if their product is based in part on the infringed patent, then, depending on the licensing that is available, it may no longer be a viable product once that happens. In the case where they’re simply copying the idea, that might be a good thing, but in the case where it was parallel discovery¹, then they’re just out of luck.

If, like the companies with big patent portfolios, the government managed this portfolio on behalf of its citizens, they could do some interesting things. Try out this thought experiment based on the following licensing strategy:

Every citizen gets license to use anything it the government managed portfolio for non-commercial use. This equates nicely to the same effect of having the patent be in the public domain.

Any commercial entity can acquire a low cost license to use the patent, iff they agree to cross-license anything in their portfolio to the entire American public for non-commercial use as above for as long as they use the license.

Any commercial entity can retain licensing privileges for their IP, but there will be a much higher licensing cost to use a patent in the government portfolio.

Furthermore, the government can renew the patent as long as anyone else could.

Using this mechanism, we improve on the benefit to the public over these patents going into the public domain by (1) giving incentive to the companies to open their portfolio to the public, and (2) providing extra government income, which could be earmarked for the maintenance of the offices managing the government portfolio, as well as the patent office itself.

Personally, I think the IP system needs a fairly large overhaul to fix the issues of (1) the increasing (and varied) pace of discovery and obsolescence, (2) the volume of ideas and the general lack of cross-referencing². Nonetheless, in lieu of a big rewrite (which is unlikely to occur wholesale), this incremental fix might be worthwhile. And GM could start us off.
--
¹Parallel discovery is actually very likely to occur. Since there are treble damages for knowing you’re infringing, it behooves one to not know. Ultimately, companies stick their head in the sand and hope not to infringe, while their legal teams, separated from the rest of R&D by a Chinese wall sit ready to do patent searches if a lawsuit comes in the front door.
²I expect that the patent publications are like dry versions of the Whole Earth Catalog rather than a hierarchically organized, indexed, and cross-referenced document that leaves little doubt whether you’re product infringes and/or your claim is a new claim.

When the government speculates

2009-04-02T22:08:00.000-07:00

I’ve been listening to the Planet Money Podcast recently, since its recent cross-over broadcast on This American Life (375: Bad Bank). They’re doing a brilliant job at explaining the complicated financial strangeness that’s going on. In a recent episode, #23: In Search Of Bad Guys, about half-way through (14m 9s), they talk about solvency vs. liquidity. Check it out, and then come back.

The upshot is that the mortgages the banks are holding aren’t worth the full fair value, as not everyone is going to pay them. The banks want to sell them at as little loss as possible in exchange for reducing risk. The question is, is the price at which people will buy these (the bid price), artificially reduced by the market’s general lack of available funds to invest.
If we had prescient bean counters today, they would foretell that the real value is going to fall in one of these three segments.

Above what the bank is willing to sell it for—This is a real win for all folks involved, though least for the banks. The banks take a loss to reduce risk, but remain solvent. The investor-taxpayers make money on their investment while also staving off general economic problems caused by the closing of an insolvent bank.

Between what the bank is willing to sell the “toxic” asset and what the current market says it’s worth—This is the big hedge. The idea here is that the bank has already lost money on the investment, and the taxpayers are going to eat further losses in exchange for keeping the bank solvent, as insolvency presumably would cause even bigger losses than these across the whole economy. However, it’s still not as bad as the market currently looks (which is what the banks are currently arguing—whether it’s lack of liquidity or lack of good forecasting, the market is unnaturally depressed).

Below even what the current market thinks—This is the true ugliness, where we, the taxpayers, are eating even more of the bank’s losses. The bank is, for all of its previous losses, getting a great deal here, basically being given taxpayer funds to pay for its bad bets. As these costs increase, it becomes harder and harder to justify keeping the bank alive vs. just letting it fail. (I suspect the FDIC costs would be pretty easy to calculate; it’d be the derivative issues in the economy that would be hard to figure.)

There is an awesome self-reinforcement built into this system. If the government produces a program to buy toxic assets and preserve the banking infrastructure, then the economy is likely to improve (or at least improve sooner) resulting in an increased likelihood that the mortgages that are so toxic will actually be paid on. Now, if only they could show how we’re going to pay all this back and how long it will take.

iPhone-to-iTunes Fail

2008-12-02T21:10:00.000-08:00

The May-December relationship between my new iPhone 3G and my G4 cube has quickly and suddenly given up the ghost. Two days after getting the 2.2 software on my phone (which I would have done with my G4 cube, but its 802.1b connection was way too slow to download the software, and I used my 802.1n on my MacBook Pro), my phone showed the graphic that I needed to plug it into iTunes. Le sigh. So I try to connect to the G4 (which has finally downloaded the software by now), and I get:
Well, carp. I go back to my MacBook Pro and restore the phone. At this point, I suspect I should be able to hook it back up to the G4, but no. iPhoto realizes it needs to launch, but iTunes spends most of two minutes showing the beachball and finally pops up the same error. Unfortunately, my MacBook Pro, which is a working machine (many enlistments in lots of source), has a pittance of the music / podcasts / playlists / etc. compared to that of the cube. I’ve finally given up and copied my various applications over to its iTunes installation, and am about to sync using the laptop instead.

Also, is it too much to ask to have the backup remember the text correction data that it's learned? I’ve taught it not to correct certain words and now it appears I get to do it again. :(

Updated (12/3):
After spending a week of trying to get this to work (rebooting the cube, rebooting the iPhone, force quitting the iTunes Helper app, etc.), and finally getting worked up enough to post about it, last night after posting, it finally worked. For some reason, connecting the phone while iTunes was up was causing the error, but connecting the phone first, and then booting iTunes got me to the “You need to put in your phone password” error, and thence to actual connection (again, having to quit iTunes and ensure the phone was connected and unlocked, and then launching iTunes again). Now, after several hours of USB v1 synching, my phone is mostly back. For some strange reason, the AppStore thinks all of the applications are out of date and is now downloading replacements, but whatever.

Redefining free

2008-07-07T13:20:00.000-07:00

From the ASP.net website,

ASP.NET is a free technology that allows anyone to create a modern web site.

and from the getting started page,

All you need to get started with ASP.NET is the free .NET Framework and the free Visual Web Developer.

I am now wondering whether Microsoft is now issuing also free licenses to Windows, so that as a Macintosh owner, I can actually use the technology. No, not so much. Perhaps they need a superscript asterisk^*.
--
^*Requires the purchase of a qualified Microsoft Windows operating system.

Setup woes

2008-07-02T11:25:00.000-07:00

Could someone explain to me why installers are often the least thought-through part of the application development process? And more importantly, why, especially at Microsoft, the people who write the software and thus know the limitations it has on file layout (including files comprising the application and its support libraries, but also plugins, caches, temporary user data, persistent user data, configuration files or *puke* registry keys) are usually not the people producing the software installation packages? And even when they are, they think first Test Matrix and second Customer Utility.

Installation is the very first user experience (after opening the box, in the case of full package product, which rarely happens anymore with web downloads), and is a regular experience as upgrades come out, or more likely, security patches. Getting your installer right enables people to install your application where they want it to. Whether that means an alternate volume (other than the boot volume) or in a user-specific directory (in the case where they’re not an admin and don't have access to the root of the volume), or on some network share for multiple people to use, they should be able to get it there, and installer writers are notorious for arbitrarily limiting this.

Furthermore, custom installer scripts do the most insane things, requiring you to quit apps that have nothing to do with the thing you're installing, or to reboot because they couldn’t figure out how to gracefully install in a way that lets running apps continue to work correctly. Gaah!

I downloaded the RDC update (well, from v2.0 Beta to v2.0 RTW) and tried to install it. It wouldn’t allow me to install to my data volume. Why? No reason that I can fathom. (It doesn't have the same installation requirements promise that Mac Office 2008 made; it's an RTW product and free–they could change it to be whatever they wanted, even 10.4.10. Heck, that would even reduce the all-important testing matrix.) Even if I use the same hack to fix that, the package was not marked as relocatable, so it would have installed the thing to /Volumes/OtherVolume/Applications, rather than let me nicely select where to put it (i.e., to replace the Beta version that was on the data volume and running fine from there). So, I decided to install it “normally” and just move it after the fact. While running, it asks me to quit Entourage. Why does it need to quit Entourage? There’s no shared libraries between Entourage and RDC. Ah, but it needs to install Microsoft AutoUpdate, and Entourage uses that. There are two obvious problems here: (1) There was nothing in the package that said it was installing two different items, RDC and AutoUpdate. If AutoUpdate is not in the package of RDC, then it should be its own separate line item to be installed. Even if the developers wanted to enforce an (unnecessary) dependency between RDC and AutoUpdate, having it called out would be actually useful. (2) Why does Entourage have to quit in order to update Microsoft AutoUpdate? Even presuming that there was an actual update that was occurring (which seems strange considering I just updated to Office 12.1.1, and would have expected that any updates to AutoUpdate would have been in that package as well). The best part is that your only choice when Entourage is running is to quit Entourage, because the only button available to you in the installer is “Continue”, and if you click that while Entourage is still up, it just causes the dialog to reappear. I suppose there’s always Force Quit.

So, in summary, the installer fails on several fronts:

relocatable installation
- different path
- different volume (unless the volume happens to be a system volume of 10.4.9 or later
non-admin installation to ~/Applications

and is a little annoying about hiding multiple packages with weird installation requirements.

Guess I’m back to fighting the uphill battle.

Install Mac Office 2008 updates to a data volume

2008-06-24T16:43:00.000-07:00

The Office 2008 installer package was shipped with an intentional deficiency–the ability to install to other volumes than a system volume, and furthermore a system that supported the minimum OS requirements of Office 2008–to work around problems with the OS installer. Those problems only existed on certain versions of Tiger and they were fixed before Office was shipped, but not until after minimum OS version support was announced.

The unfortunate problem is that, even though the problem existed on a particular version of the OS, the installer logic denies you the ability to install when you’re on a version of the OS that doesn’t have the problem, which includes 10.4.11 and 10.5.x. This could be handled by logic in the .dist file hiding in the updater package, but to date (including the 12.1.1 update), is not.

Here are some instructions that I have successfully used¹ to get Office updates to install to my data volume, which is where I moved it immediately after installing it:

After auto-update runs the installer, OK the dialog asking if it can run a script.

Command-Click on the title bar of the installer and choose the folder containing the Installer package, usually named “Temporary Items”. This should reveal it in the Finder.

Copy the installer package to the Desktop using Option-drag. This is so we can edit the copy and have it in a known, long-term location.

Quit the Installer, since the stock package won’t install.

Right click the package on the Desktop, and choose “Show Package Contents”.

Double click the Contents folder.

Open distribution.dist in your favorite text editor.

Replace the body of volumeOs1049OrHigherTest with return true;

Save the file; it’s read-only by default, so you’ll have to force it.

Double click the installer package on the Desktop and install it as normal.

One might imagine that if there were a particular problem with the installer in 10.4.9, that one could rewrite the check s.t. the volume check succeeds if (!systemIs1049() || volumeOs1049OrHigher()) && volumeHasUpdatableVersion() and still get the limited behavior where it causes problems with the system, and the unlimited behavior where it does not.
--
¹YMMV. Void where prohibited. These are not official Microsoft instructions; I’m acting as merely another customer of Microsoft using publicly available knowledge about .dist files.

On tools and how to sell managers on tools upgrades

2008-06-24T07:36:00.000-07:00

You would think that because Apple provides their developer tools gratis that that means they’re “free.” There’s a rather marginal cost involved to actually physically making the switch in the build system for your product, larger if you aren’t using Apple’s whole toolchain¹, but in and of itself, that’s still pretty cheap.

The real cost is the ineffable “baking time” cost for QA to be sufficiently happy with knowing that the toolchain change did not introduce any regressions². You can immediately run all of your existing unit tests and scenario tests and have a good idea of the quality of your product, true. But, all the manual tests need to be run by hand, and depending on the size of that corpus, it can take a while. Furthermore, not everything gets tested in these official tests³, and some amount of ad hoc testing is generally desired. How much depends on the complexity of your product, the (apparent) understanding of QA of that complexity, and the general paranoia level of QA.

The best time to sell managers on tools upgrades is at the beginning of a project release, though, for long-term projects, the tools may change multiple times over the course of development. In that case, strategic tools changes even after beta releases may be desirable, but you have to sell them on the strategy: what is the benefit? In some cases, the benefit is inobvious–e.g., we know they improved the optimizer, but does that actually help us in our scenarios? These need private releases using the new tools just to measure performance changes before there's a benefit demonstrated. In other cases, new compiler or SDK features imply the ability to have a better feature, e.g., conditional linking of 10.5 APIs without having to clunkily redeclare them in your source that's otherwise tied to the 10.4 SDK, or for 10.5/Xcode 3.0 specifically, the ability to add DTrace custom probes. For us⁴, unless we posted the bug, it’s unclear what set of bugs were addressed in a new tools release to know whether any of them would affect us, save through testing. Ultimately, management can weigh the benefit with the known/estimated costs and choose to make the jump, or wait until we start the next release.
--
¹For example, the delta for switching between the 10.4 headers and the 10.5 headers consisted only of having to add a few explicit #includes that we had gotten away with not having because another system-level #include had done that work for us. Deltas between compiler revisions is another story, since the compiler gets monotonically more strict over time.
²Whereas it is significantly more rare that a toolchain change will introduce a regression due to a compiler/linker bug, it is much more likely that such regressions are a product of substandard design that (1) took reliances on unspecified compiler behavior or (2) was luckily not revealed by a previous compiler.
³It should be no surprise that testing matrices are far larger than we have time to test. (Think along the line about testing until the heat death of the universe.) Official testing may only sparsely fill the matrices along tuples of interesting-to-combine technologies.
⁴Whereas some of these toolchains produced by Apple are Open Source, since Microsoft is also in the business of making compilers, it behooves us not to inspect code changes made in a specific revision of the tools.

WWDC bound

2008-06-06T22:52:00.000-07:00

Miller, Mabry and I are headed to SF tomorrow, and I’ll be staying through the week for WWDC. I suspect that there will be scads of iPhone developer wannabes¹. Me, I’ll be focusing on hardware exception handling, tools support for servicing, and Windows integration. Maybe I’ll find a few highly technical Mac/Unix heads in the Seattle area who want to come work for Silverlight, either with me in the CLR or on the WPF/E team. I really hope, though, that I’ll shake this cold before Monday.
--
¹I’d be a iPhone dev wannabe, but the CLR team doesn’t have an ARM JIT compiler, and the .NET Compact Framework, which does, would probably be the most likely product to support a CoreCLR-like piece of software for the device.

Hex

2007-12-07T18:10:00.000-08:00

Maybe I’m old-fashioned. I’m still using Mathemæsthetics, Inc’s Resorcerer 2.4.1 to peer into random files as hex (or ASCII or Unicode). I used the heck out of it in the days of resource forks, which is clearly less important now. Nonetheless, I’ve not happened upon an outstanding OS X GUI hex editor. (Not that I’ve done that much research, mind you.)

Anyone have their own pet program? (Does it do regexp? Does it support binary-format scheme files that you can attempt to apply to the data?)

My SE/30 is alive!

2007-11-29T01:14:00.000-08:00

Earlier this month, Miller informed me that Freecycle Seattle members can recycle their old machines for free, and indicated that we might be better off without extra old hardware floating around. I countered with the offer that I would get rid of any hardware that wouldn’t work (or wasn’t worth repairing/saving). I had mused earlier that it would be sad if my SE/30 didn’t work, and now doubly so. But, I got it out of its long storage spot and turned it on and got the blinking question mark diskette icon! Well, all that means is my hard drive isn’t spinning up any more. I was able to coax my System 7 era Disk Tools 3.5” diskette in (boy, the ejector sounds like it is really having a difficult time working), and got it to boot.

I pointed it out to Miller, and we both agreed that it’s nice to see that some thematic elements that make a Mac a Mac are retained even to this day.

So, now that I’ve wiped off the crud that had grown(?) on it while in storage, is it worth trying to find someone to fix the hard drive? Or is it just something that I should replace? Anyone have an ethernet to old skool Appletalk solution and/or is it worth it to try and hook it up to the internet again?

Tomorrow, I get to see if my Duo 280 will boot in its docking station.

Multipartition Bootcamp

2007-11-29T00:34:00.001-08:00

I have pretty much always lived with at least two OS partitions and one data partition, because I’m always testing some kind of pre-release OS or side-by-side testing app functionality on multiple OSes. Thus I want to be able to share applications and application data between the two OSes on the data partition. The advent of Bootcamp got me to give up my standard operating procedures to test drive running Windows on my laptop. It was great! Well, as great as running Windows is. I could have stayed there, even to the point of using MacDrive to treat my HFS+ Mac boot volume as combination boot volume and data disk between Mac and Windows... but no, I got greedy.

Having looked at first this post, and then later this hint, I decided to bring back multiple boot partitions. I tried using the disk utility mechanism to resize the volumes to no avail. I think it always corrupted the MBR that the bootcamp utility set up. I ended up buying iPartition and playing around with it a bunch, but most of my edits would cause Windows to no longer boot either. However, I did manage to come up with an order of operations that makes it work.

Boot from your Leopard disk into its copy of Disk Utility.

Format the disk as HFS+Journaled entirely

Install Leopard.

From Leopard, run Bootcamp.

Resize the partition that Bootcamp suggests so that the Leopard partition is the size you ultimately want it to be, and that Windows takes up the rest.

At this point, instead of rebooting and installing Windows, I booted onto a external USB drive with iPartition installed. (You could boot onto the iPartition boot CD instead.)

Using iPartition, I shrank the Windows partition to its ultimate size, and added after it two extra HFS+J partitions for my other OS partition and my data partition.

I put in the Windows Vista RTM DVD and rebooted holding down “C” to install Vista. It saw the shrunken partition, let me reformat it, and installed.

[These instructions are specifically for starting from scratch. If you’re trying to do this with pre-existing volumes, I suggest backing them all up to an external device using Disk Utility or better yet, Carbon Copy Cloner, and WinClone for bootcamp partitions. You should then be able to restore after the partitions have been finally resized. You may have to still boot from a Windows disk if only to format the bootcamp partition as NTFS (and not bother installing further) before WinClone can restore your backup.]

The only thing that is somewhat frustrating about this now is that, even though I can boot between Tiger, Leopard, and Vista, as far as Vista is concerned, the drive (disk0) is a MBR drive and has three main partitions, the EFI partition, the Leopard partition, and the Vista partition; the remaining space is “unused”. Disk Utility while booted into Mac OS X, on th e other hand, happily lists the other partitions. This isn’t usually annoying, but MacDrive only sees and can mount the Leopard partition. (Mediafour claims the the partition maps “are incorrect or damaged beyond MacDrive’s ability to handle.”) So if I wanted to still have an available-to-Windows data drive, I’m going to have to back up everything, and restart these instructions, only making the original Leopard partition large enough to accommodate the data partition, and move the ultimately Leopard partition to the end. *sigh*

If you all have better options, please let me know.

P.S., Since all this, yet another post describes how to do this, and add linux to the mix.

Cocoa-to-.NET bridge?

2007-11-28T23:59:00.000-08:00

David also asked, “if a developer of a Cocoa application wanted to use a CoreCLR engine, but a Cocoa UI, would they just ‘load the CoreCLR.framework’ or is there more to it than that.”

There is no technical limitation of CoreCLR that would not allow calls from it into Cocoa (ObjC[++]) or vice versa, in the same way that Cocoa can call into C/C++ normally. The CoreCLR, like the desktop runtime, supports a hosting interface that allows .NET to be hosted in an application environment. Unlike the desktop runtime, CoreCLR is currently only ever hosted (e.g., in the browser control called Silverlight). You can ask the hosting interface to create a function delegate, which will take a managed function and turn it into a C-style function pointer, which, were you to call it, would marshal all the arguments into the managed world and run managed code. Beyond that, you could theorize creating something like the ObjC-Perl bridge, where managed objects were made visible directly to the ObjC runtime¹.

That said, there are a couple of things that would stymie the average developer if they wanted to do this:

At the moment, only internal (i.e., Microsoft) clients of CoreCLR have access to the hosting interface.

The security model of CoreCLR, at least in the Silverlight timeframe, is changing so that only Microsoft trusted libraries have access to sensitive OS operations, and normal developers’ code would be sandboxed (much like it would be if it were running in Silverlight).

I don’t have too much insight as to whether these things might change in the future. However, there are a bunch of details that would have to be resolved first, e.g., how to ensure 3^rd party CoreCLR users keep their CoreCLR serviced with the appropriate security fixes. If you’re interested, let your request be known in the feedback forums up on http://silverlight.net.
--
¹Although, at this point, you’d end up with double garbage collection. If an ObjC object held a reference to a managed object, and then lost its last reference, then eventually the pool would get collected, which would then release the (possibly) last reference to the managed object, which would then get collected when the CLR GC occurs.

Trimming .NET

2007-11-28T23:25:00.000-08:00

As I mentioned in a previous post, Silverlight 1.1 will have the CoreCLR component in it to provide a subset of .NET support to control WPF/E (as an alternative to JavaScript, which is available in the currently released Silverlight 1.0). Since David asked “how you go about selecting which parts of .NET (which is huge) you decide to port to the CoreCLR framework you are developing,” I ended up having to do a little research.

I joined the CLR team in August of ’06, and the work to “trim” the desktop runtime engine and frameworks down to the for-use-in-Silverlight CoreCLR runtime engine and frameworks had already been completed. Back in June(!)¹ I talked with Jonathan Keljo, who was the program manager working on this problem, about what went on during this period.

Ultimately, we cribbed. Instead of trying to figure out for our (CLR) selves, we ended up looking at the pre-existing product that was already a slimmed-down version of .NET: the Compact Framework². We looked at their surface area and decided to see if we could match theirs. They had foregone features, and we chose similarly. One of the many ways CF manages size changes is just limiting the number of convenience functions.

When we prototyped the CoreCLR surface area, we ripped out some stuff based on instinct–what were the biggest (in terms of data and code size) features? We took out the top few (fusion, COM Interop, server GC, debugging support³), and strangely enough, we were close to our size goals.

On the framework side, we had inherited some subsetting already from the Rotor project. Since the platform adaptation layer (PAL) did not support all of the APIs we were calling in Win32 in the desktop version of the CLR to support some managed libraries, some of those managed layers were removed. In certain cases, we expanded upon the pre-existing PAL. The PAL had been written to be simple and very cross-platform, but knowing we wanted to support the Macintosh, we could supplement it with Macintosh-specific implementations of certain important APIs so as to not have to overly subset.

It’s not the cool-use-of-advanced-software-refactoring-principles answer I might have wanted, but it’s reflective of the environment we often find ourselves in–partially constrained by our desire to leverage previous work, and partially enabled by that same desire.

--
¹Yes, I know I’m behind.
²I knew this was going to be a cop-out answer, which is why I waited for so long to post. Perhaps I’ll get a chance to interview someone from CF and figure out how they went about their trimming procedures.
³Debugging support isn’t so much removed from CoreCLR as split out from the main product so it can be downloaded separately as an SDK.

Back from parental leave

2007-11-02T20:28:00.000-07:00

I took off from September 21^st on what was going to be a six-week parental leave scheduled to coincide with Miller returning to work, which in her case means teaching Arabic at the UW. Microsoft has a great benefit of one full month of leave is paid, though you can take up to three. I was planning on taking six weeks so I wouldn’t spend either a lot of vacation days or being unpaid for a while, since we still haven’t sold the condo we moved out of when we bought a home at the end of March. Miller, the trooper that she is, managed to switch to the “working mom” stage rather well. I, on the other hand, managed very few of the many pet projects I had exuberantly planned for myself while staying at home and watching Mabry. (Let’s just say I was frequently interrupted.) In any case, the whole child care thing got settled, and I’ve been kicked back to work two weeks early.

After getting back to work, I made it a point to get out from under the heap of mail I’d accumulated over the course of several years before starting any new projects. Some 8,000 semi-read Inbox e-mails later, I now only have a 400 message “reviewed” folder, which will probably have to have another categorizing pass made on them¹. In some cases, it was a matter of realizing I was no longer (if in fact I ever was) in a position to affect some issues, and even though they may have been personally irritating, that I had to pick my battles. I still think I’m still going to have to figure out a better way to track conversations to ensure that things get handled correctly.

Among the pending things to do is to respond to some questions posed by David Weiss, and so I think I will do that now and have one less thing on my list…

P.S., Mabry has just turned three months and has been vocalizing at me as I’ve been writing this. Maybe now might be just after I play with her a bit. ☺
--
¹During this purge, I think I stumbled on to some what must be n² or longer algorithms in Entourage, as deleting large swaths of mail when visible in the UI would sometimes take ages.

My wife’s next OS won’t be Mac OS X…

2007-11-02T17:01:00.000-07:00

… and I cannot help but think I am partially to blame, because this is no fault of Apple’s, but rather due to deficiencies of Mac Word.

Here I am, a guy who hasn’t been without a personal Mac since ‘90 (and had regular access to them as early as ‘87), a proponent of Mac software at Microsoft since joining in ‘95, and through my own development efforts, making the Microsoft Office experience better on the Mac, and my wife is choosing Windows because of limitations of our Mac software¹.

Admittedly, Miller’s particular requirement is one that is not shared by a large percentage of the users or potential users of Mac Office²–she needs to collaborate with her students, fellow TAs, and professors on electronic documents written in Arabic. This is by no means a new requirement for her. She began her Arabic study four years back as a requirement for her masters degree in Comparative Religion, and decided to parlay her studies into a doctoral program in Arabic Studies.

The problem? Most all work is done in Microsoft Word documents, and Microsoft Word for the Macintosh does not support any right-to-left languages (aka, “bi-di”). If she works in Mac Word in Arabic, she gets completely disconnected characters³. She has unseated me many, many times at my Windows box in our office so that she can use Windows Word and actually get work done.

Having worked in the MacBU as a fellow developer, I had a great “in” to try and get this addressed. Unfortunately, every time I would bring it up, we’d do the back-of-the-envelope calculation of development cost⁴ versus the number of users who would use it (upgrade incentive for current users, and new users buying in due the feature). The internal statistics for Mac adoption in Arabic-using (and, to a lesser extent, Hebrew-using) nations did not make for a pretty picture for the “leverage” this feature would provide–our development dollars would probably be better spent on other features that had a impact * user-base value.

Of course, I’ve made alternate suggestions based on the software she does have on her Mac. In 10.4, at least, Pages had issues loading/working on Word documents with Arabic. (I know not whether creating documents from scratch work better; I suspect so, since even SimpleText, er, TextEdit does a fair job, AFAICT.)

The next question is, of course, why use Word documents then if another doc format has better Mac OS X (and theoretically cross-platform) support for Arabic? Answer: Other document types don’t don’t have ubiquitous, well-known editors. In Miller’s specific case, all U.W. students have access to Word for both platforms, and the labs have more than enough Windows boxes. Most Arabic students/professors don’t have this problem because they don’t use Macs. (Nor is this really an incentive to do so.) They do not have any reason to switch document formats for the (apparently-)minority class of Mac users.

I suppose, though, the issue isn’t completely closed. It’s possible someone will comment that we need to try some specific software to solve the problem. OTOH, it still may be that Miller may end up with a Macintosh computer for her next machine, but if so, it’ll probably be BootCamped to some form of Windows.

Updated: I wanted to show some examples, but not knowing Arabic, I needed some assistance. So, the Arabic word romanized as “mumkin” (meaning “possible”), looks like in TextEdit, but like in Word. Thanks to Miller for helping me out with these.

--
¹Arguing protectionism here would be a little silly. Windows Word gets a fair amount of this functionality from Windows, so if Microsoft Office was a 3^rd party, the Word team would have been in a similar pickle on Mac OS X, at least until relatively recently.
²And if you have hard data otherwise, please, please, please let me know so I can convince the Powers-That-Be that there’s a business case to addressing the problem.
³Arabic writing is like cursive in that characters look different if they begin a word, are in the middle of a word, or are at the end of the word. However, unlike cursive, they are seriously different, and the word becomes very hard to recognize, not to mention the layout problems that are caused (because they no longer are the same width).
⁴The cost has changed significantly over the course of years. Seven years ago, our best bet would have been to port the entire Windows support for ligatures (which Windows Word uses without having to implement itself), and bi-di support from Word. That would have been quite expensive. Nowadays, despite not being able to just replace the Word layout engine with ATSUI (so that we could continue to guarantee identical layout across versions/OSes), we could theoretically offload some of the work to ATSUI and then ask it what work it did and translate that into our own layout world. This is obviously less expensive, but still involved and prone to being a bug farm.

Little Mabry

2007-07-30T05:29:00.000-07:00

Miller and I (officially) became parents over the weekend. Mabry Parker Herring was born Saturday (7/28) at 6:28pm PDT. She was 6 lbs., 10 oz., and 20” long. She and her mother are both sleeping while I’m taking night duty, and stealing a little computer time. There’s a photoset up on Flickr.
Photo provided by Rob

Iced americano and a little brie

2007-07-07T14:27:00.000-07:00

I’m (mostly) taking a day off from tech today. It’s another fabulous summer day in Seattle. Started the morning off with baked eggs from the Hi Spot, found my way onto a number 2 to downtown, wandered through the Freeway Park for I think the very first time(!) to the Convention Center, to The Stamp and Coin Shop, where I finally purchased a coin album to finally get my coins out of the shoeboxes and converted chocolate boxes and into something nice.

Another number 2, and I’m back at home, and somewhere I get the desire to go jogging. (Where did THAT come from?) Made it all of five blocks before switching back to walking and headed home. While our housemates were hosting their birthing class reunion, I finally got the hammock my parents had given me many years ago for my birthday (when I lived in a condo with nowhere to put it) installed in our back yard. On my way back in, I pilfered a little brie from the remnants of the reunion treats, and now I’m off to take Michael’s folding bike, which Miller borrowed on my behalf, to 2020 Cycle to get patched, and I’m thinking a little iced americano from Katy’s will go well with the remaining taste of brie. Mmm… good day so far.

MacBook Pro HD upgrade

2007-07-02T13:44:00.000-07:00

I’d been running into problems recently, having my builds run me entirely out of existing hard drive space on my 160GB hard drive, so I broke down and ordered a 250GB drive from MCETech. This is maybe the fourth time I’ve done the whole move-the-internal-drive-to-an-external-enclosure-and-transfer-partitions process, so one might think I’d have it down by now. Alas, not quite.

First, an annoying detail I hadn’t noticed about the drive enclosure–it requires two USB connections: one for power, and one for data (and probably more power). This makes it a little more unwieldy, and furthermore, since I often use a USB-based laptop mouse, problematic. However, I generally live without external storage, so I’m not too put off.

The actual hardware transferring process was actually pretty much a breeze. I’d dug into my TiBook before, but the MBP is new, and so it was nifty to get in and see how it was put together. I have to say that the side, back and sunken bottom screws seem to be a much better system for maintaining a secure case. Kudos to those Apple hardware guys. My only two problems here were that I didn’t know exactly how much force it would take to detach the case top from the clips (and was probably overly gentle and thus not getting anywhere for several minutes), and that I was missing one of the rubber grommets that hold the hard drive in place. (In the latter case, it is entirely possible that it jumped ship as I removed the old drive from the case, but a search of my workspace did not reveal it.)

The rest of the process has been a bit of a drag though. The first concern was converting from a BootCamp-enabled setup (a BootCamp-created partition and then everything else on one HFS+ partition) over to a different layout more inline with my historical preferences: at least two HFS+ boot partitions (>= 20GB) to host the current released OS X and one for a pre-release OS X, one large data partition to host data. I ended up taking that template and adding a small case-sensitive partition for some testing purposes, and room enough to maintain the previous BootCamp-created partition. After some small amount of figuring, I tell Disk Utility to do its magic, and I’m ready to start transferring.

Even though I only had the one big HFS+ partition for Mac OS X things, I had still maintained some segregation left over from the TiBook days. So I moved everything in my “Stuff” directory and my source enlistments to the new data drive. This ended up dying in the middle because, despite the fact that Microsoft Entourage was shut down, reminders were still turned on, which meant that the background Database Daemon kept a lock on my identity’s database. Not quite thinking correctly, I re-dragged the Microsoft User Data folder over to the new partition. See, it had succeeded moving some items, but not all items, and as such, I blew away other parts of my identity, including my rules¹. I had been moving rather than copying, because I would need to trim down the original drive because it wouldn’t fit on a 25GB partition. Drat. Well, the rest copied successfully, and then I was able to Carbon Copy Clone the original OS disk over to the new, smaller partition. This too was problematic, in comparision to older times–having the two boot partitions means that you can boot off of one to transfer the other, but I ended up having to use target disk mode and my mostly-unused G5 in my office to accomplish the same thing. Once there, I made happy symlinks in my home directory to the Documents, Movies, Pictures (etc.) folders on the data partition, and the Mac-side was good to go.

This is where I started running afoul of missing support for moving BootCamp partitions around. Disk Utility wouldn’t touch the thing². I downloaded WinClone, but ran into this problem. At this point, I gave up on Windows for the moment, knowing I could always pull it off the external drive later.

Now it was onto installing Leopard in the space lovingly devoted to it. I rebooted into the installer DVD and it complained it couldn’t install on a drive formatted in this fashion. “Argh!” A quick inspection in Disk Utility showed that it was, in fact, partitioned using Apple Partion Table rather than GUID Partition Table. Then, of course, I slapped my head, since I remember having noticed that when I looked at the completely clean new drive, but apparently when I repartitioned it, I neglected to switch which partition scheme I used.

After much grumbling, I used Disk Utility to image the two data-containing partitions back onto the external drive, re-repartitioned using the right partition scheme this time, and spent quality time trying to get the images back onto the drives. In the case of the OS partition, for some reason, both Carbon Copy Cloner and Disk Utility balked many times in a row at the restore, and the first restore that took had for some reason decided to ignore the permissions on the disk image, resulting in a non-functional OS. (It would drop into some boot-time Unix console, try several times to load some services, and ultimately fail.) This morning, I am finally back to the point where I can install Leopard.

I know that this is not a typical procedure for non-technical people, but I really do wish there were an tool, possibly part of the Migration tool, or maybe the Disk Utility (or, obviously, a third-party solution), that let you batch move/resize partitions so that I could do this in one stop. It would be especially cool if it allowed me to split an existing disk into two separate disks by which sets of the file system I wanted transferred to which sides.
--
¹I think the rules regeneration count is now up to eight. At least this time, it was my fault, and not some obscure un-diagnosable rules corruption.
²On the other hand, the Startup Disk would still recognize the drive as a bootable Windows partition, though if you selected it and tried to boot it now that it was a USB-based drive, it would bring up the flashing I’m-missing-a-system icon at boot.

How well does your voting system work?

2007-06-28T09:10:00.000-07:00

Yee pictures show off graphically how various election mechanisms–e.g., plurality and instant runoff voting, as well as a collection of other esoteric methods–actually respond to the will of the populace. It’s interesting to see what happens in the case of ties and when the vote is split for several mechanisms (see the result for plurality above). It’s a good reminder about how problematic plurality is, but it’s also a good wake-up call for IRV supporters who think that ties won’t be a problem.

By the gleam of yonder moon

2007-06-12T18:24:00.000-07:00

Welcome to a new age of .NET. With the Customer Technology Preview (CTP) of Silverlight™ 1.1, the first commercial cross-platform Microsoft® .NET™ components became available. Furthermore, my tongue is no longer officially tied. The cat is out of the bag, and thus I can now clue you all in on what I’ve been doing in the last year.

Since there’s already been quite a bit of posting on the subject of Silverlight, I figured I’d fill in some of the details about its composition and some of the nomenclature, since, even within Microsoft, it’s not completely obvious what’s in the package at first glance.

Silverlight
Intro- duced Version	Level	Technology
Intro- duced Version	Level	Name	Codename	Description
1.0	0 (Native)	WPF/E	Jolt¹	Windows Presentation Foundation / Everywhere is the browser plug-in variant of its bigger brother in Windows. It is XAML-based presentation engine.
1.0	0 (Native)	Windows Media codecs		These allow for high speed video streaming inside a Silverlight solution.
1.1	1 (Managed support)	CoreCLR	Telesto²	The core execution engine and platform adaptation components of .NET. These are the only parts of the managed support that are native; the rest are all managed libraries. Officially, the CoreCLR project is also responsible for the Base Class Libraries (BCL), which has been reduced for both size and portability reasons.
		UIFX		The standard framework libraries, similarly reduced from the Desktop for both size and portability reasons.
		.NET Language Runtimes		Managed libraries to support C# and VB.NET
		DLR		Dynamic Language Runtime support libraries

The “level-1” components of Silverlight are entirely to provide a managed programming model for WPF/E, as an alternative to its built-in JScript model. The part of Silverlight I’ve been working on is the CoreCLR component, focusing on Mac OS X integration, but have been banding together with my Mac counterparts on the other related teams (mostly WPF/E, with a little bit of UIFX) to make sure the collective Silverlight story on the Mac is a good one. If you have feedback for us, head on over to the Silverlight.net forums, specifically the Programming with .NET forum, and let us know. It may take more than one of us to give a full answer (for example, I know much more about how we handle native exceptions on the Mac than about what XAML you’d need to use for a particular operation), but we’ll help if we can.
--
¹In the era before marketing took over code-name generation, we could have tributes to fine beverage products. However, since code names regularly leak out of Microsoft, and out of worry that we will get stuck with a trademark lawsuit for something that isn’t the name we’re ultimately going to use, marketing now comes up with names, presumably with some kind of trademark search ahead of time to verify that we’re not going to run afoul of someone else’s.
²No, “Silverlight” isn’t the “the gleam of yonder (Telesto) moon,” but I figured it sounded good.

LOLCode.NET

2007-06-11T14:14:00.000-07:00

Courtesy of my coworker, Andrew, who wrote the following on my whiteboard:

Plz Use namespace System
Awsum! KThxBye!

I don’t know if I have the heart to tell him that his syntax doesn’t appear to match the only known LOLCode.net implementation. Further alas that it’s GPL’d, which means that per Microsoft’s Chinese-wall-like policy, if I desire to keep my job, I can’t even look at the implementation. Ah, well. I guess, IM NOT IN YR CODZ.

reCAPTCHA

2007-05-24T20:27:00.000-07:00

After code reviewing some large number of files, I took a slight detour over to BoingBoing to an article on an alternative CAPTCHA mechanism. Instead of using a normal CAPTCHA system, typing in known words that have been graphically altered so that a computer couldn’t interpret it, you type in unknown words gathered via OCR that no computer has interpreted, but that the reCAPTCHA system has a pretty high liklihood index on knowing what at least one of them is. You type in two words. You get the “known” one right, and you get in, and your submission for the other word is kept to help determine what the other word is. It’s a pretty interesting idea. Plus, they’re using it to help digitize documents in the public domain that have been scanned, but that OCR has been hard pressed to convert them–a good cause.

In my playing around with the example on the site, I noticed some oddities:

You can fudge at least one of the words. There was an instance of “1980” and another word. I guessed that the other word was the “known” word, typed that in verbatim, and passed in “1988” instead. The reCAPTCHA system said I was in like Flynn.
You are likely to get partial or multiple words instead. Since it’s OCR that’s already known to not interpret it correctly, it may not even get the correct word break and when you are instructed to enter “two words,” you may have to enter in three or four words, or partial words.
Sometimes there are odd symbols in the older texts. There was a word that had an ‘æ’ in it. I dutifully asked the International menu to show me my Keyboard Viewer (since I never remember the Option-key combination for those diareses), found the character, and submitted the word exactly as written. It called me correct, but I wager that normal people won’t bother to use those high-falutin’, old-fangled characters, and just type “ae”. It might be close enough, but is it right?
Use of alternative symbols might get you an error. There was a word that clearly had a right-side closing single quote character used as a possesive or a contraction. However, I dutifully entered in the curley-quote version and was rebuffed! I guess the straight quotes is what they wanted.
Older texts have spelling mistakes or perhaps older or alternative spellings. I wonder how many people are going to bother making sure they type that extra ‘t’ that doesn’t belong; will it be enough for the verification code to preserve the original text’s spelling?
Some of those OCR documents are hard to read as it is, and blurring it makes it harder. There were several times where I had to refresh the reCAPTCHA many times in a row because it was just impossible to read. I wonder what their mechanism is when many, many people have avoided making a claim, or made irreconcilable claims as to what that word is. Does some poor shmuck have to go back and look at it manually? Or do they start limiting the blurring? Hmm…

All in all, though, it still seemed like it provided a very reasonable security while providing a nifty public service.

Standard User (UAC) + Network Home Folder = #)$(*@%

2007-02-06T15:38:00.000-08:00

I am in month seven of using Vista, having installed Beta 1 on my sole Windows development box as a part of being a Good Dogfooder™.¹ As a self-styled security afficionado, I elected to have my regular domain account be a Standard User account, using a local machine account as the administrator account. Now, when I want to do anything that requires administrator access, I’m prompted with a request for credentials.

When I first saw these, I felt comforted. I was used to seeing the same on my Mac OS X boxes when an application was requesting admin or root privileges. However, the sheer number of times that I needed to actually acquire administrative access to my machine surprised me. I would often think, “Does this thing really need administrative privileges to work?” In a lot of cases, the answer was, “Yes,” but in some, it seems that some more work could be done to either allow an application to install/run with user privileges (e.g., browser plugins) or to isolate preference options according to whether they need the dreaded “elevation”². Ultimately, though, that work can be done, and application developers and IT folks have some Microsoft-provided tools that can help them make their applications/plugins/whatever behave well in this environment.

Later, I would increase my Good Dogfooder™ karma (or reduce it, depending on whether you subscribe to the only-negative-karma idea) by enrolling in a pilot program to try out redirecting user folders to a network share. It pretty much works as advertised. Everything that would be in C:\Users\nathanh.000 gets redirected to a network volume that my domain account has read/write access to. It takes a bit of time to log in, but no matter where I log in, I have the same information. Similarly, there a few applications and products that don’t handle this gracefully... applications that like to install shortcuts on the Desktop, for instance, are annoying unless they’re installed somewhere on my user directory (which is rarely, if ever) or installed in the same location on every machine I log in to. Again, I can report back my woes and, at least with Microsoft-written applications, have a shot at having them work better in that environment.

Alas, as is usually the case with living on the bleeding edge, there’s the blood. Dogfooding at Microsoft is de rigeur, and there will always be some annoyances, though the product teams do a lot to keep them to a minimum. My problem is the confluence of elevation in the presence of the network home folder.

Let’s review: My domain account is my main account, and is a standard user, not an administrator. My administrative account is a local machine account, and has no domain privileges at all. My home directory is a mounted network drive where my domain account has privileges, but not my local machine administrative account. Do you see what’s coming?

Situation #1: Installing from a network share.

I can browse to some UNC path from my domain account, and click on an installer. The installer, UAC-aware as it is, puts up the elevation dialog, since it has to install into some machine-wide areas. I enter in my local administrator account and password. Voilà, the installer now runs as if it is the local administrator account, and instantly no longer has access to the network share, since my local administrator account doesn’t have privileges. Fortunately, this is usually only an annoyance, as most of the time, I am presented with a dialog complaining that the installer doesn’t have access to the share, and could I please enter in credentials of someone who does. I find it odd that I have to enter in my own credentials when I’m already logged in as myself.

Situation #2: Installing into the home directory

In the case where an installer needs to install into some machine-wide area as well as the home directory, I’m more stuck. I have to elevate to run the installer, but as soon as I do that, the installer loses access to the home directory. For some reason, in that case, it doesn’t present the network-access dialog, and things just fail to work.

In one such case, a program installed most of its items, but then failed to create a startup shortcut for me. “No matter,” I thought, “I’ll just copy it over myself.” I noticed that the shortcut I needed was already in my Start menu, so I browsed to it and copied it. I then browsed to the All Users startup items folder and tried to paste it as a shortcut. I then get the following dialog:

Windows cannot create a shortcut here. Do you want a shortcut to be placed on the Desktop instead? [Yes] [No]

“Hunh,” I think, and choose, “Yes.” Personally, I thought it should have just brought up an elevation dialog and let me paste the shortcut, but no matter. There is more than one way to do it. So, I then try to drag the shortcut nicely pasted onto the Desktop to the All Users Startup Items folder. Happily, I get the elevation notice. I think, “Great! Now I’ll have access to put this item here.” But I had not thought it through, for while I gained access to put the shortcut there, I simultaneously lost access to its source. Thus, after another elevation dialog (I don’t think that one should be necessary), I get the following dialog:

You don't have permission to copy files to this location over the network. You can copy files to the Documents folder and then move them to this location.

I take issue with this dialog on two accounts. (1) I have permission to copy files to this location; I just got it. I just lost permission to copy files from the source location. “to” is a little unclear. (2) Copying files to the Documents folder is not going to help me, since my Documents folder is also on the network share location that my Desktop is.

The sad part is I could have elevated, and copied the shortcut directly, without ever having to place a copy on my network home directory. But I wasn’t thinking through the ramifications.

Unfortunately, neither will our users. Furthermore, they’re not going to understand why these things don’t work “right” or “just work.”

I am not part of the UAC team and have definitely not considered all the ramifications of the implementation of extreme credential isolation, but I am certainly enjoying the authorization mechanism on Mac OS X which allows me as my current user (with all the access that implies) to do specific other tasks requiring a higher authorization level by supplying administrative credentials, and still have access to the secured resources my user should have access to.

I expect the UAC edges will get smoothed out, as will network home folder redirection... I mean, hey, why else do we do this dogfooding anyway?
--
¹Actually, it was at that point that all Microsoft employees were exhorted to all use Vista as our desktops–even though no official effort had been made to ensure that our group’s build environment and tools would still work–so that we would make sure the experience would be good for our customers. Our woes were noted, and some were addressed in time for Vista and associated tools to be released to manufacturing, so our pain was not in vain.
²Originally, I thought “elevation” was just a synonym for authorization. Alas, it is not. When you “elevate,” you (or rather your process) becomes owned by another user with more privileges than you. That user may also have fewer privileges than you in other realms. This can be a problem.

Collections

2007-01-10T02:31:00.000-08:00

Take thrice the daily intake of caffeine, a frustrating problem at work that needs some back-burner cogitation, and a recent revisiting of eBay, and that’s all that’s needed for a seriously long stint of late night web browsing for the purposes of collecting.

I would expect there’s a coincidence of collectors among people who write code, largely because I believe that both are ventures that jibe well with people who are “detail-oriented,” which is my polite way of saying obsessive-compulsive. In my case, I’ve gone through several iterations of collecting, starting with an aborted attempt at stamp collecting back when I was maybe 10. To some extent, it seemed to me that collecting was just a specific form of being a careful pack rat–you take care of your belongings to help them to last, even if you don’t need them at the moment, just because someday you might–a last vestige of handed-down Depression-Era values.

I switched over to collecting coins, but not expensive ones… just some interesting U.S. coins I had come across. One of my favorite finds was a glass jar of pennies that my father had saved when he was a kid. I was so excited to find some “seriously” older coins (e.g., from the ‘50s rather than the ‘70s or ‘80s).

I have since taken to dumping my pocket change into jars: one empty Glenfiddich metal canister for the quarters, aka laundry money, and one empty plastic jug that formerly contained olive oil for all the rest. Maybe someday my kids might find it as exciting, if these containers survive that long. The first attempt at this involved storage in an empty poster tube, and during the Nisqually quake, the tube herniated and broke; my wife (then girlfriend) decided to “clean up the mess” by taking all the coins to Coinstar! Coinstar of all things! Not only did I not even get to see six years worth of savings churn through the machine, but I get to pay 8.9% for the privilege! AIEE!

Ultimately, I didn’t do much in the way of collecting coins as a kid. I just kept a few dollar coins and some examples from various years. Another short-lived collection was that of Star Wars trading cards (even as a kid I eschewed sports-related things); I don’t even think that lasted through a full summer before I traded them away for something else.

In college, though, I started collecting for real. I fell victim to this newfangled idea–a card game where you collect the cards. This was, of course, Magic, the Gathering™, around the Alpha/Beta transition, and before I had even heard of the CCG acronym. My college roommate, Naval, would purchase boxes of card, sell the packs, and then trade with the people as they opened their packs. Well before Kyle MacDonald hit the trading scene, Naval turned one island into a Shivan Dragon. I did my own purchasing and trading. Even now, I have a Fleer binder of nifty cards and a white box of extra cards in my office, for lack of a better place for them. My friend Brian, who has alternative names for most everything, refers to Magic as cardboard crack. I’m pretty sure I was addicted or close to it while in college; any extra money I had from my computing jobs on campus would go into it. Later, I’d try out Jyhad and Middle-earth, and to a lesser extent Dr. Who, Star Wars, Star Trek, and BloodWars, before I ultimately swore off investing in any new CCG.

After college and after collectible card games, I got found myself back into coins by what I would have considered to be an unlikely source for me buying anything, Shop At Home TV. I usually just tell my TV to omit those shopping channels when setting it up for the first time, so I’m not sure exactly how it was that I came to be staying up, late at night, watching the Coin Vault. Somehow I got drawn to buying a whole slew of silver coins (mostly brilliant uncirculated), and only later discovered that there was a hefty markup. Nonetheless, it piqued my interest again, if only mildly, for numismatics. I certainly enjoy getting each year’s silver eagles for depositing into my Dansco album.

In addition, my prediliction for Zeppelin¹ paraphenalia, which is a collection² in its own right, bled into coins with regard to the 1930 three- and five-reichsmark coins, which feature the dirigible and laud its 21-day circumnavigation of the world in 1929. I have to say, it’s pretty difficult to find those coins on this side of the water. With some rusty college German, I can partially navigate some internet sites and eBay sales. Ron, of germancoins.com, has been a good resource, both in terms of coins and how to bridge the gap between US gradings and German gradings. One of my early morning tasks today is to perform my first international wire transfer, to pay for a recent winning auction bid for such a coin.

It still seems a little crazy to be trying to guess whether or not an online vendor is trying to gouge you (and by how much) without a price reference guide, or even without necessarily many vendors selling the same items. It makes for some hefty search sessions (and my browser tabs increase to the point where you can only see the first three letters of the title of the page), and even then, it still sort of feels like jumping off the deep end, especially in the realm of coins, where you’re trying to double-check the quality grading by inspecting a grainy submitted picture, that isn’t particularly zoomed in. Nonetheless, I’m trying it out, and we’ll see how well it all turns out.

--
¹ The airships, not the band.
² I had always been a fan of airships, as long as I can remember. But it was only during the collecting of some material for a game of Nobilis–entitled Means and Ends, it had a chancel which was a modified version of Seattle Center circa 1962 during the World’s Fair–that I branched out from Life magazine copies and into Zeppelin books. Of course, the geekery doesn’t stop there; I’m also a member of the Lighter-than-air society, and I regularly wear a Save Hangar One t-shirt in the hopes they don’t dismantle Moffett Field’s historic hangar.

iPhone envy

2007-01-09T16:12:00.000-08:00

Well, I was wrong. My friend Jon asked me what was going to be offered up this morning, and I said, “Whatever it is, it isn’t going to be an iPhone.” This because Cisco owns the trademark to it… In the back of my head, I was really hoping for a phone/iPod combo, not just because it would be cool, but because my i-Mate SP3i Smartphone is starting to drive me crazy, and I am looking for a replacment.

This isn’t to say that the SP3i wasn’t nifty at one time. When I was willing to spring for the $20 extra a month it cost for insanely slow wireless internet service, it synchronized nicely with my Exchange account at work, which was pretty much the only way I ever used its connection. Trying to do anything other than load an extremely simple page (usually one written to be displayed on a Palm) (1) took forever and (2) required scrolling all over tarnation with the dinky joystick of intermittent operation. Said joystick came out of the phone multiple times, and could never quite be put back in correctly, and right now I’m operating with the plastic stub instead. Still, the difference between me knowing I had a meeting to get to and/or to look up where it was or what someone’s number is in my 400+ contact address book was huge.

On a parallel note, the implementation of as-needed-synchronization in Windows Mobile™ 2003 Second Edition’s Pocket Outlook depends not on the ultra-slow network that I paid $20 a month for at all. Instead, the Exchange server sends invisible SMS messages (ones that don’t show up in your text message section) that get interpreted by Pocket Outlook to let it know there’s something new to synchronize. I didn’t have a text plan when I first got my smartphone, and after two months of $150 charges in text messages that I had no idea where they were coming from, I finally switched to mode of synching to just every 30 minutes. My comrades in Windows Mobile ultimately changed the behavior of this in a later edition of Windows Mobile™, which is great, but unfortunately, they weren’t willing to upgrade my phone (they were OK upgrading the SP3, but the SP3i was just too… something… (new? freaky?) And as far as I can tell, the manufacturer won’t upgrade it, presumably because it was already an older model.

As time went by, I gave up on the Internet connection, trying to settle on desktop-synchronization. Unfortunately, it was about this time that I played Good Microsoft Employee™, and dogfooded beta candidates of Vista, for which there was no ActiveSync. Now that Vista has released to manufacturing, there’s now an ActiveSync, but it doesn’t sync contacts or events anymore. “The synch status is on the device.”, only it’s not. Add all of this to the device no longer responding to right button clicks, and taking on the order of 5 to 20 seconds to respond to left button clicks when it hasn’t been used in a while (is it paging things in?), I’m starting to take a hard look at new cell phones.

One of the most annoying things about bar phones, IMNSHO, is the requirement of locking them. Yes, I know it’s not a strict requirement, but I put the things in my pocket and then they auto-dial someone in my contact list. I’m still waiting for an accidental call to 911 to happen. Strange things happen when it is locked though. If I get a reminder, sometimes I cannot dismiss it because it wants you to unlock it first, but the reminder is on top, so you don’t get the unlock UI. There might be some kind of lock timer I could use, but that doesn’t preclude me pocket dialing people, and I don’t always remember to lock it. I was thinking I would have to go to some kind of flip or clamshell phone to avoid that nuisance. I spent some time over the holidays looking for a relatively cheap phone (since I’d have to buy it as an “upgrade” through T-Mobile or get a compatible unlocked phone, as I already have a contract), but hadn’t come up with anything.

And then Steve Jobs shows off the new iPhone.

Something tells me the Exchange support might not be all that great. As it stands, Mail.app has never once been able to synch with the Microsoft Corporate Exchange servers. (In the past, that’s meant that I’ve been even more tied to Entourage and/or Outlook, and had a vested interest in fixing/reporting bugs in those products.) I somehow doubt that the iPhone is going to do better than Mail.app. But still the idea is alluring. The iPod I got as a ship gift for shipping Microsoft Office 2004 ended up going to my wife who lives for her podcasts, and her old iPod had ended up with battery issues. (NB: She recently got it re-batteried and now I have an ancient iPod that I really should load up with some tunes.) Having a newer model iPod that can show video and call folks and can fit in my pocket sounds great. And maybe I can even leverage Entourage’s Sync Services integration to get my info onto the phone…

I guess I’ll keep an eye on it, and if/when it comes out, figure out whether it’ll be worth switching to Cingular or whether it could be purchased unlocked for use with T-Mobile. Until then, I’ll live with my ailing smartphone.

P.S., What would be really cool, would be if it had a slot for not just a SIM card to enable the device, but extra SIM cards to serve as generic smart cards. Then you could use it as your physical token for authentication on machines. Can you imagine walking up to your machine and have it auto-negotiate credential sharing, and have a keychain show up on your box?

Intel inside / Herring v2

2007-01-04T21:20:00.000-08:00

Time seems to get away from me when diving into new work. It’s been a few months since my last speculative post, and since then, as I’m sure you’ve noticed, the Core 2 Duos are now in the MacBook Pros. I bought mine the day it came out. But like the rest of my old machines, it wasn’t so easy to part with my old Titanium. First, it was a matter of not having brought everything over (like some applications who keep data in strange places and as such didn’t get copied over when I copied my home directory and data drive), and secondly, for the first time in a long time, I had some PowerPC-only work on my plate!

Digging out the old 601 manual and peering through its pages, I realized that I missed dabbling in assembly. I say dabbling because I know just enough to be dangerous, and not enough to wring the performance you’d want from, say, an optimizing compiler. Fortunately, all I had to do was play with stack frames and arguments placement. Mmm… Nothing like screwing that up and getting a completely broken stack trace at the point of a problem. Well, anyhow, as it turns out, whereas it’s possible to use my new shiny MacBook Pro to do this work, it’s quite difficult to debug in Rosetta, and Rosetta seems to not be too happy about programs generating their own code (it quickly runs out of memory—perhaps it doesn’t know where the data ends and the generated code begins?). Thus, my old PowerBook was going to have its one last hurrah over Christmas, so I could work during downtime while visiting family.

I greatly overrated the downtime, which ultimately didn’t matter, as for some reason gdb on my PowerBook wouldn’t load the symbols of the code I was debugging, so it was even more difficult than it was going to be back at work. I gave up on working over Christmas and focussed it on my and Miller’s family.

As an aside, it seems that around my birthday, Miller and I “spawned a new process”. I don’t think it’s Intel inside there, but according to the doctor, it’s set to release in late July ‘07. Both of our families are quite pleased.

Now that the last vestiges of a reason to keep the old workhorse is gone, I finally used the photos I snapped of it several weeks ago, and put it up on eBay. <shameless_plug>If you’re looking for an old MacBU warhorse, replete with a Moby sticker, bid away.</shameless_plug>

Machine speculation, redux

2006-09-27T18:17:00.000-07:00

A couple of recent articles about Intel's new quad-core Core 2 offering coming early (in late 2006 rather than early 2007) from SFGate and the Washington Post reminded me that I didn't really act upon my previous machine speculation.

I had posited there was an outside chance that they'd update the laptop line for WWDC '06. It was much more likely that they'd release an Intel desktop, and they did. (I had given it a release date of December +/- 6 months, so it definitely came in on the early side.) Nonetheless, I was (and am) holding out for the low energy versions to get put into the machines for better battery life (and less cooking of the lap), and hoping that they'd be able to cram in a second two-core processor in. Well, with the announcement that availability of quad-core chips this year, with low energy versions "early next year", I might get (effectively) both. Unfortunately, since there's usually some lag time between chip availability and adoption, I may end up waiting another nine months until they could get put in the MacBook line. Ultimately, this comes down to when Apple updates the line and what they're going to do with it. I've got my fingers crossed.

Not just licking my wounds

2006-09-19T09:05:00.000-07:00

I should have known better. I'm not particularly thin-skinned, but every time I end up going to an Apple conference, instead of being able to purely enjoy the new technology (and at WWDC, the camaraderie of other Mac developers), I find myself plucking daggers out of my (well, Microsoft's) back.

Yes, I know that the Reality Distortion Field is going to promise great things on the platform. But, having never been to a PDC or TechEd, do the Windows conferences heap the same load of scorn on alternative OSes (and by inference, developers on and for that OS)? I'm sure there are cross-platform developers who are just itching for the new technology who think, "Yeah, yeah, now tell us what's cool about your stuff!" There are probably such Mac stalwarts that don't care a whit about what Microsoft is doing or would rather not hear the name mentioned in their presence, and referring to "Redmond"¹ repeatedly is just as bad.²

In any case, having been to WWDC 2003, and having had access to other MacBU folks' DVDs for '04 and live streaming for '05, I didn't get as much out of it as one of my new coworkers, who was roughly introduced to the society surrounding the technology. Instead, I enjoyed talking to several Apple developers working on the technology areas of my interest (mostly security-related), and put bugs in their ear about future directions. Secondly, I did not just throw away all those Microsoft daggers–omitting the ones that were purely spiteful, there were still several that complained of real problems in MacBU products that I was able to give feedback to the team about, not all of which were known issues.

The reason I've been quiet recently is not that I'm licking my wounds from WWDC, but that I'm diving headfirst into a bunch of new-to-me technology. Although my coworkers have some good insight about what sections of the technology have analogs to what I had been doing previously, it is still a little like drinking from a firehose. I hope to spend the next few months coming up to speed, and then when the product specs settle down and we can go public about it all, have some more technical blog entries about what I'm actually doing here in CoreCLR.
--
¹ A quick search of software companies in Redmond, Washington turns up quite a number of results. Perhaps they're repeatedly referring to WildTangent? No? Maybe Hipsoft? Crick Software? Something tells me they're just afraid of mentioning Microsoft, in case it increases Microsoft brand recognition to their own detriment.
² I've often wondered what purpose it serves to mock Windows at these conferences. I don't think it's going to dissuade Windows developers from developing for Windows OSes. Is it dissuading current Mac developers from leaving the platform? Or is it just patting them on the back for having made "the right choice" of OSes? Hmm.

CoreCLR at WWDC

2006-07-25T21:01:00.000-07:00

Well, it's a bit of a strange time for me. I've accepted a position on the CoreCLR¹ team working on the Macintosh version of the MiniCLR that's going into WPF/E² and perhaps later other places. It's a little odd to be considering leaving a position I've ostensibly had since I got here (with only one major reorg), but fortunately(?) I have so much to do to wrap up what I was working on for MacBU that I haven't had time to ruminate overmuch. On the other hand, it's hard not to get excited about working on cool developer technologies.

After some amount of worry when it seemed the handoff between the two groups (which is scheduled to happen over this weekend) was going to jeopardize my going to WWDC, all is resolved, and I'm once again set to go down to San Francisco the end of next week. I'll just be wearing a slightly different hat is all.

I hope that within my first week at the new job I'll know enough about what we can tell other folks that I might have something to show at WWDC. Or at least blog about it some.

Many thanks to my colleagues at MacBU for making my stay fun. Who knows… maybe I'll come back sometime later with some newfangled scripting technology to use with Office. If only I could think of one…
--
¹ The CLR in CoreCLR stands for Common Language Runtime, a fundamental piece of .NET technologies.
² WPF/E is Windows Presentation Foundation/Everywhere, a subset of WPF designed to work outside of Windows.

Yet another framework

2006-07-11T12:51:00.000-07:00

When I was younger, my dad showed off his Texas Instruments TI98+ scientific calculator, which for him was a godsend; he was doing medical research at the time, and being able to program up to fifty operations on a piece of data at a time made filling out his tables significantly easier. I was too young to really do much with it (or more to the point, have too much that I needed to do that could use it), but I "helped" (in that way that a child can "help" and have it take longer than it would've otherwise).

Fast forward a couple years, and our family acquired an Apple ][+. This wasn't our first computer¹, but it was the first one he did any significant computing on. I used to watch him enter in page after page of AppleSauce Basic to take in data sets, perform calculations, and spit out the results. We used the heck out of this machine. Admittedly, as kids, we preferred to play Karateka, Moon Patrol, or earlier Aztek and Elevator Action², we also had AppleWrite and I wrote my homework using that for years.³

Still later, I came back from college to find that my dad had purchased an IBM PC clone and had ceased doing any programming, but just used some already-created applications which did most of what he wanted. I ended up sneeking on and writing a simple BASIC program that would play Happy Birthday to him if he started his computer on his birthday. Apparently, he didn't do that for two years and was mightily surprised when it started making noises at him. In any case, one of the times I was working on programming and he was around, I asked him why he didn't just pick up this new BASIC and continue his work. His response was that he had already learned enough languages, and that picking up another was just not worth the time. I repsonded that it was not that different, that it was easy. He agreed that it was likely to be as easy as I said, but still not worth changing for, given the viability of the solution he already had.

At the time, I thought that I would never feel that way.

When I was maintaining the MacBU build system, it was written in Perl. I hadn't known Perl beforehand, and because I thought the system needed some tweaks, I learned just enough to make the tweaks I wanted. Then, of course, being the only person who was actually doing any work on it, they made me the official person to work on it. I ended up getting a pretty in-depth education in Perl as a result, from having to deal with the Perl plug-in to CodeWarrior (PerlIO anyone?) to writing tied filehandles to capture output into an XML time-stamped log. All this without the benefit of something like Affrus.

Eventually, I gave up working on the build system, and subsequent to that, it was decided that Python shall be the Way of the Future™, and the system that we're working on to support Xcode was to be adapted into Python from the old Perl-based CodeWarrior-driving system. Of course, now I'm back to where I was before – wanting to make tweaks to the system to make it work better for me. And learning Python isn't so terribly hard, since it's very similar to Perl. But it just seems sad to have to figure out a bunch of ever-so-slightly-different ways of doing the exact same thing.

I probably will finally put Python under my belt one of these days, but it's just not as compelling as it would have been to my child-self.

Not all new systems fall in this baliwick however. I'm currently working on some simple Cocoa stuff. Cocoa, too, has been long ignored by me, largely because very little of the MacBU-based code uses it. It is a whole new way of doing business, and its model is sufficiently different that it's taking a little "settle-in" time to grok it. It will be yet another framework to learn and to have to integrate into my other programming paradigms. However, it makes some things sufficiently simple, that it is compelling to learn. I just sometimes wish I were learning it faster.
--
¹ Earlier, my dad had purchased a Sinclair ZX81 with the 16k memory pack. The Basic programming was rather simple and fragile – on one hand, the 16K memory pack's connection wasn't too good, and if you giggled the keyboard, you were likely to lose everything, and on the other hand, it took several tries of playing the tape before the computer would finally "take" the program. As it was, I think he chalked it up to a learning experience and didn't do any scientific work on it. My brothers and I played some super-lo-fi 2D space scroller (like Zaxxon, only not orthogonal).
² Unfortunately, we didn't really have access to the good games, since it was a "Work" machine. I remember spending quality time at a friends house playing Wizardry. To this day, I still attribute my navigation skills to wandering that maze sans MILWA.
³ The Apple ][+ was also the computer I performed significant programming tasks on. I used AppleSoft BASIC to do some boring things (like modify other BASIC text-driven games, like Oregon Trail). I took a stab at basic graphics programming to show long addition. I tried several times (mostly failed attempts) to learn 6502 assembly, and really only ever emitted a few assembly things in BASIC code. My brothers mostly remember me trying to harangue them into helping me transcribe hex dumps of computer programs published in computer periodicals – they hated that, though less so when checksums were finally introduced.

Choice: productive(?) but unhappy

2006-07-03T20:48:00.000-07:00

Doing my standard breadth-first-search of people's blogs (omitting links of little interest), I ran across the Simplessity blog (via Nadyne via Brian Johnson). The particular article linked from the title is about a presentation by Barry Schwartz about how as the number of choices goes to infinity, the productivity (of maximizers at least) goes up, but happiness (in general) goes down. Facinating. This probably explains why people end up being paralysed when faced with the number of options our products support (assuming they actually are aware of them). ("How best to format this document? Oh, crap, that was the wrong way." Even if it was the right way.)

I really like the idea of Libertarian Paternalism.

How user discontent translates into profit motive

2006-06-29T00:35:00.000-07:00

My (employer-inherited) goal is to sell boxes. Microsoft software product boxes, specifically. Fortunately for me and my CS degree, my particular function in the achievement in this goal has nothing to do with the boxes themselves or the manufacture of the discs, but really only with the software that goes in the box.

Consumers, purchasers of boxes, both like and dislike aspects of the box and its contents. The question that this post is trying to address is how (or whether) whatever dissatisfaction a consumer might have translates into profit motive to fix the problem.

Well, first, there's the recognition of the problem that has to happen. Many problems go unfixed for lack of recognition. In some cases, that can be despite outspoken users on the newsgroups. It can be because we recognized part of the problem but not the larger problem (or the still yet larger problem, etc.). In some cases, people don't even know there is a problem until a user experience person watches them try to use the software and choose a highly inefficient way (relative to some other way the software provides) of solving a task. Some amount of market research is created to see if we could establish what problems are key to get people to upgrade or buy new.

But even once a problem is identified, there's still some measurement as to its importance. The market research may also have details as to how big a populace has a particular problem. Even when there is no market research around a particular issue, our Program Managers, Developers and Testers have to take a stab at how likely it would be for someone to encounter certain problems and if that results in a subset of users, again, how large that subset would be (and how annoyed they're going to be when they see the problem). The size of the affected population multiplied by some factor related to how severe the issue is / how critical that functionality is to the work they do, determines the initial relative priority of working on one problem vs. another. When development and test come in with time estimates for how long it will take to fix and test problems, then there's a more fungible, but more final relative priority of working on problems.

This still doesn't really account for the nebulous issue of, when is a piece of software buggy enough that you give up and won't upgrade. I'm sure there's also research around that, but for us it seems that the quality bar that gets set is largely a touchy-feely setting, that gets set based on experience and consensus between the departments. We hope that that quality bar is sufficiently high to make sufficiently many people sufficiently happy with the product as to keep buying upgrades. Unfortunately, that bar setting is set by different people on a per-application basis, so there may not be uniformity there.

How can you affect that equation so that your bug gets fixed?

Send cogent, succinct, and detailed bug reports – generally, this means to the newsgroups. This improves the likelihood of problem recognition, and reduces the fix time for development, especially if they don't have to track down a reliable reproduction case. Remember, what you think is a bug Microsoft has been ignoring might be a bug that they've fixed several versions of and think might be gone for good (and haven't seen your case yet).

Call PSS – As I said before, this costs us (and you) money, and we generally track what problems are coming in. The higher the number of calls, the more likely PSS will ask us to fix it on their behalf. (How important this is is not clear.)

Make sure other people affected by this issue do the same – again, it's a numbers game, to some extent.

If it's something that's truly blocking your organization from upgrading, have your license purchaser let their TAM know – The more seats that are affected, the more important it is. In fact, MacBU has had a lot of pressure from Windows Office and Exchange to solve some problems because not having a sufficient Mac solution was hurting Enterprise sales in heterogenous OS environments.

~~Bribe your developer contact.~~

What doesn't affect the equation that you think might:

Saying how important this bug is – We take these statements with a grain of salt. It might be really important to you and yours, but how representative are you? If the affected users are 0.03%, and experiencing it isn't likely to keep them from buying the product, then it's less compelling than if 10% of the users are seeing it. Similarly, saying you're not going to buy the product anymore, is only so useful if we actually believe you and believe there are a lot of people like you. Bluffing or exaggerating may get results, but more likely, it may get you ignored as a noise generator. Now, if you can point to sharable market research that supports your claims, then, you should be talking to our product planners.

Saying how long the bug has been around – Sadly, this is nearly inversely proportional to how likely it is to get fixed. If we could afford to ship it once and suffered insufficient adverse effects, then we're more willing to ship it again. That said, there's always some legacy bugs that are just taking their time to percolate to the top of the priority queue.

Saying how much money Microsoft has to throw at the problem – That Microsoft has coffers is one thing, but we are law-bound to try and make the most money for our shareholders. That means at the business level, we have to justify spending money to make money. Fortunately, that doesn't go all the way down to the individual bug fix level exactly, though it is somewhat mirrored in our priority/severity accounting and triage processes.

Being polite – Whereas we would sincerely appreciate your politeness and avoiding mockery of us and our products in public forums, if you are actually making a cogent, succinct argument in favor of fixing an issue (that we can tell), then we'll use it despite whatever extra vitriol was included. Hey, we all get frustrated sometimes. On the other hand, no amount of politeness is going to make a super-expensive feature less expensive and thus more palatable.

Unfortunately, none of this is a guarantee, and unless you're a Premier Support customer wanting a QFE, it's entirely possible that nothing (visible) may come of your efforts, or at least that the fix comes a long time off (one or more product cycles). Maybe someday our process will be sufficiently transparent as to show our assigned profit expectations to fixing various problems, and allow people to post bug bounties to push the chances of their particular pet-peeve bug high enough to meet the cutoff bar for a release. But sadly, I don't believe this will ever come about. On one hand, market research is apparently incredibly difficult to publish publically, and without that information, a lot of our profit expectation assignments would just appear arbitrary and cause more consternation that it would create benefit. On the other hand, our expectations of profit making might be considered to be trade secrets, and thus to be hidden.

Miller returns; her iBook, wiped

2006-06-27T23:10:00.000-07:00

Miller got back today from the last of her solo escapades for a while (at least until Burning Man). She had just finished spending a week with her family back home, and the week before that had been grading Spanish AP exams down in San Antonio. Right before she had left, she had just gotten her iBook back from the Apple store geniuses for more out-of-warranty-yet-free repairs to the hinge. Unfortunately, once at home, her iBook shut down and then subsequently would not boot. She called me at work and asked me to take care of it while she was gone, and then made her way to the airport.

A week ago, I decided to take a peek. The iBook would boot for a ways and then blink the "I can't find a blessed drive" icon. I pulled out the trusty Tiger disc and tried to boot from that, and it gave me an icon I had never seen before: a circle with a slash through it. After some Googling, it seemed that somehow the boot sector of the DVD couldn't be found, which seemed unlikely. I booted it up in target disk mode and connected it to my TiBook and there was no hard drive even listed. It did, however, show the Tiger DVD. I hadn't seen that before — previous versions of this error were easily rectified by selecting the drive in Disk Utility and selecting Repair, but with no disk listed...

I let Miller know I was going to have to take it in again. The geniuses tried the same stuff I did, and then said that it would need to go through a Repeat Repair. I was happy to find that it, too, would cost nothing. (It's nice that these repairs are free, but we've had to repair this iBook four separate times, and my TiBook has never needed anything!) They gave the perfunctory "make sure your data is backed up" speech, and asked whether I wanted to get in-house backup for something over $100. Here was my logic: If Miller had already taken this in before, and she got the same speech, and thus she's done everything she wanted with regards to data backup. I actually made the further assumption that she had, finally, taken my advice that she should back up the stuff she could not afford to lose. As it turns out, I was batting zero for two, but the final one was the kicker: My last assumption was, even if the hard drive was the culprit (rather than a controller or loose wiring or etc.), then they'd ship the damaged hard drive back with the machine so that I'd have a shot at recovery on the off chance that she hadn't backed up everything she wanted.

You don't get any broken parts back from Apple when they're replaced during a repair. I guess this makes sense, I just hadn't thought it through.

Fast forward to today, and I pick up her machine from the Genius bar, after having received the call that it had been received. They politely tell me what they did to it, and mention that they replaced the hard drive, as it had failed. I ask where the old hard drive is, and they respond, "Defective hard drives get scrapped or sent back to the manufacturer for warranty replacement, depending on the drive. It used to be policy that they'd retain them for seven days before doing so, in case someone wanted the drive, but that's no longer the case." Erp. I asked whether it was possible to retrieve it and their response was, "Probably not, since they would have already scrapped it or shipped it about the same time the iBook was shipped back here, but I can call AppleCare and check with the service manager to see what the deal is." I called Miller's parents' house and left a voice message about her machine having a brand, spanking new OS on it and that her hard drive was somewhere AWOL.

Miller called later, frantic, and said that this was a tragedy, and that yes, if I could try to get the drive back, that would be great. Apparently she had not backed up her drive... anywhere. No CD-R, not on her UW account, not in Yahoo, nowhere. I went through the AppleCare menu system with the feeling that I was asking the governor for a stay of execution. The tech investigated the case for me, said that the drive had already been scrapped and that they wouldn't really know how to look for it to get it back. But, he also said, that the reason it had been scrapped was that there wasn't anything they could do to revive the drive, so there wouldn't have been anything I could have done had I the drive. (Well, nothing shy of pulling out the plates and putting it another mechanism, which is admittedly, beyond my ken.)

We're still not quite sure of the information-lossage. Most of the, ahem, legitimate music can just be re-ripped. However, several years worth of academic papers, some amount of academic research, archives of e-mail correspondence, and most of her photo collection from Egypt are all resigned to the big bit bucket in the sky.

If there's anything to take away from this cautionary tale, it's back up your *#%^@ data.

My love affair with Type Libraries

2006-06-26T22:23:00.000-07:00

It's just the registration that's annoying.

OLE Automation is one of those pieces of Mac Office which probably isn't understood by most people, even people here in the company. Strictly speaking, it's not really part of Office per se — the Windows version of Office doesn't include it, as it is a part of the OS¹. But what the heck does it do?

Mainly, it allows a programmer to do is to define an application's object model and make that model available to be coded against or scripted. The central mechanism for this is what is called the Type Library. A type library contains a list of classes and their properties and methods, along with some annotations². It is roughly analogous to an AppleScript dictionary, though there are some marked differences³. Most often, a type library is stored in a file, but it can be implemented in code as well, which allows for some extra dynamism⁴. A scripting client of OLE Automation can use it to read type information out of the type library to determine what can be called. If you go into Visual Basic for Applications, and choose View/Object Browser, the contents of that browser are just a visual representation of the type library (excluding items that are marked as hidden or restricted). Then VBA knows that if you're working with an object that is the Excel Application object, that only so many properties or methods are allowed, and it can autocomplete your code as you're typing. When you run your code, VBA will call into OLE Automation, and OLE Automation will point it at the code in Excel that needs to run.

The type library provides several ways to be a client of the code which the type library describes. At the base level, you can either call into a method directly through an interface pointer's vtable, or you can call into a method by referring to it by name. This latter functionality is defined by the IDispatch interface, specifically the Invoke method. A class can be set up to allow one or the other or both, and in the last case, it's called a dual interface. If you want to use an interface from C/C++ and it supports vtable-calling, then the mktyplib utility, which generates the type libraries, can also emit .h files for including into client projects. Otherwise, you can call IDispatch::Invoke and have it figure out how to call that function. If you don't know what methods you will need when you're compiling your code or script, it's still possible to perform late-time binding, and ask the type library what's available at runtime. This is what VBA does, and why it can handle scripting arbitrary OLE Automation objects, so long as they can be acquired from one of the Office applications' object models, or the object model of VBA itself.

For years, the eldest Office applications, Word, Excel, and PowerPoint, all had two different object models. One was the OLE Automation / VBA model, which was shared with our Windows counterparts. One was the AppleScript model. They may have had overlap, but they were created largely in parallel, and they did not have any kind of feature parity. As a result, whereas sometimes the OLE Automation model would get new methods, the AppleScript model might not get the same methods, and the disparity would increase. Eventually, we had the idea that we could try and unify these things.

I made our first attempt at it, and it didn't succeed. The OLE Automation to AppleScript mapping proved to be sufficiently inadequate for a simple translation layer. There were enough oddities in the way the applications' type libraries were created (and subsequently had scripts writing assuming those oddities would remain), that the AppleScript experience would have been awful.

For Office 2004, Jim Murphy took a slightly different approach; start with the mapping, and then write some custom code to handle the rough edges. As of this writing, there are still some rough edges left, but ultimately, both VisualBasic and AppleScript now code to a (largely) unified object model, and more importantly to a (largely) unified implementation. Less code and more functionality. What could be better?

Under the covers, OLE Automation looks at the type library and performs calculations to figure out how to form a call to the actual function. Implementing IDispatch::Invoke involves knowing how, for this architecture, ABI, and calling convention, to put arguments on the stack or in registers, call the method, and then retrieve the results of the operation. It's one of the few places in the Office products where hand-written assembly is actually necessary⁵.

But back to my initial caveat. While type libraries allow you to advertise arbitrary object models, one of the main issues has always been, "How do you create an instance of one of these objects?" On both Mac and Windows, the answer has always lived in the registry. When you register a type library, you place registry entries that list what version the type library is, where to find it on disk, and where to find the application or framework (er, DLL) code that implements the objects and methods. Then later, when asked to create a new object of a particular kind (e.g., when you Insert/Object "Microsoft Excel Worksheet" from within Microsoft Word), OLE can look it up in the registry and launch it (if it's an app) or load the shared library, and call the appropriate object creation code.

Now you get into two sets of annoying problems. (1) The files move. On Windows, if you move files from where they were installed, you'd better make sure to re-register the type libraries, or things will (possibly transparently) break. On the Mac, it's a little more resilient (we have aliases after all), but you can still make it break. (2) You have more than one version or more than one copy of the same version. If you register a type library, you're registering just it and just the application or shared library you pick. There can be only one. If you have two or more, you'll get rerouted to the one that was registered last. This is another form of DLL-hell, and whereas DLLs can be distributed with their applications (removing the sharing aspect of shared libraries) to avoid DLL-hell, type libraries can't be fixed the same way.

Ultimately, the problem is no different than the one that LaunchServices (or previously, the Desktop DB) solves. It keeps tracks of applications it's seen, and when asked for "com.microsoft.excel", it can launch it, and it has disambiguating rules it uses to pick the most appropriate "com.microsoft.excel" if there's more than one. As an aside, there's currently no way to leverage LaunchServices by having it cache additional data about files, so it could also track what info is currently in the registry.

My acquaintance with OLE Automation began when MacBU acquired the privilege of maintaining the Mac version of the OLE code base. I've seen its transition to CodeWarrior, through Carbonization, and now we're working on Xcode/Universalization. My best, and frankly irreplaceable, reference for all of this, beyond having access to the code itself, has been Inside OLE, Second Edition, by Kraig Brockschmidt, ISBN 1-55615-843-2, sadly out of print. It goes into much, much more technical detail about all of this and the rest of OLE, and explains it all very clearly.
--
¹ Windows users will know it by a different name, oleaut32.dll.
² These annotations include such things as alignment and indications of where to find help on this type or method. There's also a mechanism to add custom annotations.
³ Most OLE Automation types have analogues in the AppleScript world, but one of the hard ones is how to deal with methods that return an interface. There's no idea of returning a pointer in the AppleScript world — you have to return an object reference instead. Unfortunately, in some cases, a given interface won't necessarily have a way to turn itself into an object reference. If you arbitrarily created a "temporary" object store just so an object reference would get returned, the script writer would have to clean up after themselves, making sure to delete that object reference when done. While this is certainly possible, it's goes against the general AppleScript paradigm.
⁴ A type library could be generated on-the-fly at runtime. Usually, this wouldn't be necessary. But it would allow the type library system to be used to interact with a completely different scripting system whose contents wouldn't be known until runtime (or at least might change between the compile time and runtime). For example, it would be theoretically possible to write code that returned an ITypeLibrary interface which represented the contents of an AppleScript dictionary, and have that code be able to translate between OLE Automation types and AppleScript types so that you could use VBA to script a "normal" Macintosh scriptable application.
⁵ Another such arcane place involves the code that allows an interface to be hosted in a process other than where the implementation code exists. In these cases, we have to intercept the calls, send them via interprocess communication to OLE Automation running in the other process, and it will perform the call on our behalf. (The reverse process occurs when the result is returned.)

Machine speculation

2006-06-26T14:24:00.000-07:00

It was the beginning of this year when the new Intel MacBook Pro made it into the Apple Store for pre-ordering that the Pavlovian drooling commenced. My wife, Miller, in her prudent fashion, suggested I wait six months before upgrading my 500 MHz TiBook. Partially, it's because she wants to make sure I'm not just infatuated with the new technogadget-of-the-month. I, on the other hand, was sufficiently sure that I've already purchased Parallels, but her logic also made sense otherwise. Whereas a new product line may have certain problems endemic to it, six months is probably a good length of time to see if they crop up. Also, I am wondering whether WWDC '06 will hold some more product releases in store. If they announce better MacBooks, it will have been worth the wait. If they announce other hardware, like a more standard desktop, it won't be that great for me personally, though I suppose it might be possible that it would drive the prices down on the MacBooks. Unlikely, but possible.

In any case, I'm still crankin' away on my TiBook. I miss the (relative) speediness of the CodeWarrior builds, where even on this old boy I could crank out a set of Mac Office builds overnight. Now it takes longer than that to crank out one flavor of one architecture. I no longer really use it for mainline development work for that reason. All that said, and though I'll be happy to finally purchase an Intel-based Mac and see some dramatic speed improvements, I'll be sort of sad to put this old workhorse to rest. The keyboard keys have all gotten shiny with extended use. The Moby sticker to the left of my touch pad has long outlived its earlier counterpart on my old Duo 280, and I'll have to seek out an appropriate replacement.

Speaking of my Duo 280, is there anything I could do to replace a cracked screen at this point, or should I relegate it to the junk heap? I've still got an old Duo Dock in my office, though at this point, all it's doing is supporting my Intel iMac so the screen height is more ergonomically correct. One of my non-tech-geek friends made the point over the weekend that all these old machines are just adding to the already considerable clutter in our house. We got into a spirited debate over whether to keep random extra, usually defunct or obsolete, tech gear around. At some point I used the word "shrine" and the discussion fizzled. Anyhow, I think having a working Duo 280 is worth keeping, but probably not a irreparable one. I'm afraid to pull my SE/30 out of the closet and see whether it'll still go. I don't want to have to turn it into a fish tank just to have a reason to save it.

Long overdue photo

2006-06-17T23:57:00.000-07:00

I think I might burn out my blogging muscles for another nine months if I type up another long post, so I'll settle for putting up a photo that will go into my profile.

Piercing the veil

2006-06-17T16:38:00.000-07:00

Corporations are rarely transparent in their operations, and Microsoft is no exception. It has historically difficult to understand exactly Microsoft was doing to address specific customer desires or complaints. Previously, the ways you might have been able to talk to Microsoft were:

Writing to MSWish - despite being monitored, user rarely got any feedback as to whether their bug was to be fixed or their feature suggestion taken into account other than the boilerplate text. [NOTE: MSWish is no longer operational at this time.]

Talking to PSS - complaints or feature requests get filtered through this organization, and instead of producing qualitative suggestions to the teams, more often they'd be quantitative suggestions (e.g., this feature area got a lot of calls). Talking to PSS costs both the user and Microsoft money. Users are disinclined to call unless they can't solve their problem in some other way, so we miss feedback. Microsoft is financially incented to reduce PSS calls; better products is just one possible side-effect.¹ All told, a user won't know that their commentary is going to get used or not.

Talking to TAMs - Technical Account Managers handle the big accounts at Microsoft, and as such you're already a special class of user. You have more pull, but you're paying for the privilege, and the prospect of future purchases keeps our attention.

Writing to Newsgroups/Forums - There's a fair amount of people willing to aid those who use our products who write to newsgroups, but quite a few of them are not Microsoft employees. Some of them are MVPs, who are well informed and intelligently summarize major problems back to the product teams. Some Microsoftees monitor the lists, either as part of community outreach, or ad hoc, but engage individual users rarely.

With the exception of the TAMs, the general problem with all of these methods is that as a user, you'd not know whether it was worth your time to report the problem. Even if the problem was heard and understood, who knows what internal priority it would be given... would it fall of the list of things to do for this next patch release (or worse, fall off the list of things to do for a major release)? You won't know until you by product v. n+1, and try it out for yourself.

Part of the problem was that the Microsoft culture was one of employees being publicly silent. If you're an employee, and you post on a public forum, and you screw up (anything from revealing confidential information or trade secrets, to implying there might be a next release of something not officially announced (much less whether a particular issue would get addressed in that release), to negatively representing Microsoft), you may find yourself without a job the next day. There was little incentive to talk to the public, and when talking to the public anyway (say you get cornered on an airplane and reveal you work for Microsoft), you'd have to play defense lawyer, and say, "I can't comment on that."

My personal opinion is that this lack of transparency and interaction has hurt Microsoft's public image.

The advent of public bug reporting mechanism such as Apple's BugReporter or SourceForge's bug tracker didn't seem to perturb the way Microsoft did business; semi-standard industry practices aren't necessarily readily picked up. Instead, the advent of blogging has started to crack the official barrier between customer and employee, circumvent the aforementioned "official" routes. All of sudden, you could read a blog and get instant insight to what a product team was doing, even what technical hurdles were having to be addressed. Futhermore, with comments, you could give direct feedback to that blogger.

Consequently, employee bloggers are interacting with the rest of the world in a much more public fashion. Non-public-relations people are regularly writing commuiqués, and the PR and legal departments are nervously fidgiting, waiting for a major gaffe. On the whole, it seems promising; technology evangelists are getting people excited about products, and there's a new transparency into some of the workings at Microsoft. It's unclear how many neophyte bloggers have had to "seek employment outside of Microsoft", but my impression is that it is negligible.

The developer devision seems to be leading this new wave. The MSDN blogs were among the first I had heard of at the company. Furthermore, they're the first group trying to "close the loop" with services like LadyBug. I'm not sure if "close the loop" is some official customer-representative jargon, but I'm using it to mean to be able to receive customer comments, report back what, if anything, we're doing with them and why, and then, once action has been taken, to follow up with the customer to make sure that the action satisfies their desires.

Again, historically, we were far from being able to close the loop. If a user complained about an problem, even if we knew it was an "official problem", i.e., there was a bug report and it was deemed a valid problem, we weren't allowed tell the user that.² Even if we could have told them it was a valid problem, we couldn't tell them much about when we would address it (assuming we knew) except under very limited circumstances.³ At best, we could have kept their contact information around and at the point where we finally addressed their problem and the software that did so was on the shelves, to report back to them. (I think, that happened in very isolated cases.) That still didn't really address the customers whose problems we elected not to solve.

While the new blogger-era rules of interaction are not fully written, it still seems like the new feedback tools and (the promise of) looser restrictions on customer communication will make it easier for customers to tell us what we need to know to do our jobs better and for us to let customers know that we "get it". (Or at least how much we've "gotten it", so they can take appropriate action.)
--
¹ For example, we might add new wizards to aid people who don't know how to use a feature; this reduces support calls, but doesn't make the product better for those who already knew how to use those features. It may not even mean that the product is better when you account for all users of the product. If only 10% of customers are calling about a feature and the rest understand it, the only portion that's costing us money that we can measure are the 10%.
² Notwithstanding our various Licensing Terms, previously known as EULAs, which warrant nothing about the software, the implication that there was a "bug" in the program could be (and in some cases, rightly so) construed as a "flaw" rather than "design limitation". Nobody wants to be sued, and software companies with deep pockets live in some non-zero fear of being the target of a landmark class-action consumer rights lawsuit akin to those in the automobile industry that might require fixing, recalling, and/or punitive damages.
³ If it was going to get fixed in a release not yet announced, that was a no-go. If it was going to get fixed in a release announced, but not on the verge of being shipped, there was a risk that the fix might get accidentally undone by some other work during the course of the project, and saying that it was going to be fixed meant having to make extra double sure that none of them were broken (not so hard), but also fix them if they were (which can be quite expensive if it's at the very end and we're trying to get the product out the door).

Eleven years

2006-06-17T09:59:00.000-07:00

This coming Monday, I will have been working for Microsoft for eleven years, migrating from my initial position in Excel development into the newly-formed MacBU (or Macintosh Product Unit, as it was called in those days). I took some time this past week to look through what all I had really managed to accomplish over that time frame, partially wondering whether I was living up to my (self-gauged) potential. It's hard to recall all the little things I did for the various projects; the ship list seems to be the remaining milestones. Fortunately for my memory, those are permanently affixed to the Ship-It awards (I ran out of space on my first one), and I have the Shelf-of-Ship, a display of promotional boxes from the various products shipped (including the somewhat-hard-to-come-by Office 98J CD).

MacBU seems to have progressed a bunch over the years too. I missed the 68k to PPC transition that had happened with Office 4.2, but between picking up Windows components that Windows Office doesn't have to maintain for themselves (OLE, OLE Automation, Visual Basic for Applications), having to switch from our no-longer-supported Macintosh cross-compiler in MSDev to Metrowerks CodeWarrior, and undergoing a major OS revision (OS 9 to OS 10), we've come a long way. Now we get to look at CFM vs. Mach-O, moving to Xcode/gcc and adding Intel to the platforms (and largely the former two because of the latter). Roz has made a public commitment to work on it, and Erik Schweibert, my current lead, has already posted on some of those trials.

At the same time, whereas we don't have to play porting games with Windows Office, as their source diverges from ours, and as we need to maintain file format compatibility (to at least roundtrip the things our code doesn't support), we have a delicate balance to maintain in terms of what needs to get brought over from Windows Office and how it gets brought over: Do we port it and try and keep our code in sync with theirs? Do we clean it up as a v. n+1 version of the same feature? Do we rewrite it in a MacOffice paradigm? Do we do nothing and suffer the consequences? Each of these options has its negatives: Porting/synching code has the problem of many more developers working for Windows Office producing much more code than we have time to carefully review and integrate, and even if we do so, we have to live with the drawbacks of their particular implementation; on the good side, it means that if we have to do more porting of code added in a different release, it'll be easier to do since there will be fewer differences between our code and theirs. Cleaning it up suffers from the same problem of quantity, and whereas the finished product might be better and/or more elegant from a pure code-maintenance perspective, we complicate the future porting strategy — will we still be able to add the new feature they added to our "cleaner" version of the code, or will we have to throw out what we did and go back to straight porting later. (To be fair, it's not strictly a one-way operation; sometimes Windows Office ports code from us, and they face most of the same issues, if not the quantity issue. However, I doubt most of the pure code-cleaning gets back-ported unless it adds significant features; from most people's perspective, all it does is add risk to shipping on time.) Writing a MacOffice-version of the same feature has similar consequences, and when file format is involved, not supporting it is just not an option. Rick Schaut has been posting on the most current incarnation of file format compatibility since mid-2005.

For better or worse, MacBU hasn't been the only Macintosh software developer at Microsoft over these years. During its inception, a bunch of teams offloaded the Mac versions of their code, some with a big sigh of not-having-to-maintain/support-Mac relief. There were (and are) still exceptions... The Outlook team continued to produce a Macintosh Outlook client up to the 2001 edition. Encarta still produced their Mac applications (even though they usually had two developers all told for both platforms). The Windows Media Player team produced their, ahem, client for the Macintosh, though that has been recently supplanted with the Flip4Mac version. (This, by the way, caused a minor debacle, since their PR dept released the information on the same day Roz made the five year commitment.) The hardware group still produced their own Macintosh drivers, and the Services for Macintosh team on Windows Server worked on the Microsoft UAM, which, by the way, seems to have been replaced by an Apple-provided version of the same thing by 10.4.6 that even works on Intel. Included among the new exceptions are the WPF/E project, as well as the cross-platform shared source initiatives. In all of this, these groups are acting as peers, without a specific Macintosh oversight group. The tradeoff is that there's freedom for these teams to do what they need to do for their product, at the cost of a lack of Mac-product uniformity in quality, best practices, access to Apple information (MacBU has the closest link to Apple), and so forth.

As much as the new Intel boxes are creating new work for and my team, they still give me the excitement that something new is always happening in the Macintosh world. I look forward to writing more "interoperable" software, and hope to see another decade of closer Apple/Microsoft integration and partnership.

A public face

2005-10-01T19:28:00.000-07:00

This past week brought quite a few MVPs by our offices. Per usual, it was nice to be able to show a very little of what we're doing. On the other hand, it introduces another level of information dispersal and access protection to think about. On the one hand, acknowledging a problem with the software or talking about a planned feature could be considered to be an implicit promise to fix or implement something. On the other hand, not talking about what we're doing means that we miss out on valuable feedback.

So what would have been future design feedback is now feedback on existing design, which is, well, not always pleasant. It is sometimes difficult to participate on public newsgroups or mailing lists. One doesn't read much positive feedback (but then again would you really join a newsgroup to laud the developers who wrote the feature that made your day?), and there's as much negative feedback as one might want. Some of it is completely appropriate, and takes you back several months to the point where there was an agonizing choice... either the PMs at an adds/cuts meeting, or at some late point when a problem was finally realized where all the principals weigh the cost of addressing it and making sure that it was really fixed without other repercussions. I wince once when a hard decision happens, and then again when that first person says, "What were you thinking when you wrote that?" or "Don't you do any testing?"

It's just not useful, for me at least, to try and address all the posts. Some are unrelated to the software at all, and have to get redirected to a more appropriate area. Others are FAQs, asked on the order of three to four times a week, and points to people's lack of willingness to search the archives. Some, though, are the good problems: the ones we don't see in-house, the environments we don't have in a test lab or on a dogfooder's or beta tester's computer. These are the ones where one tenacious and helpful user makes it so we can fix the problem for untold others who won't report the issue. The other good ones are when there is an obscure error message that doesn't have an obvious solution but that we can help diagnose what's going on and solve some settings issue or help out with some workaround. Being able to respond to those makes me feel good about my work.

Then there are the total flame bombs that get dropped by irate customers, or better yet, irate non-customers. I personally do not know how to respond in a positive fashion to these, especially the ones that have horribly flawed or missing logic. I really don't understand the sense of entitlement evidenced by some posts. That a piece of software might not do everything you want should be par for the course, but does it mean that you're somehow entitled to have it "fixed" to do what you want it to do? Is it merely a problem of that the public listing of features not being specific enough to let you know what will and will not work? Comparing one piece of software to another might be useful to pick which piece of software is appropriate to use, but if it compares unfavorably, does it really mean that you're due some kind of replacement version that addresses those problems?

Ultimately, I will go into work and write the best software I can.

A hole to crawl into

2005-09-14T23:40:00.000-07:00

Somewhere between a recent series of emotionally charged misunderstandings with a friend of mine and the Seattle weather and who knows what else, I've regressed to not wanting to leave the house. Yesterday, I felt competent enough to stare at e-mail, usenet, and blog postings, but felt entirely lethargic and slept through most of the day, never making it in to work. Today, I spent a short day at work, and then worked at negotiating a truce between two owners in our building with adjacent units with regard to sound issues. Blech.

Both yesterday and today, there were social events that were interesting that I could have attended. I'm just not sure what made them unworthy or home so inviting. It certainly wasn't the lure of SciFi Original Pictures or one of the Law and Order variants. Nonetheless, it's somehow easy to stay up until 5am alternating between channels and web browsing.

Makes me wish I were back on the playa, where the nights were colorful, the stars inviting, and it was a joy to walk everywhere with my friends and my sweetie.

Guess I have some more decompression to do.

UPDATE: In terms of actually interesting late night television, I stumbled on ASSSSSCAT: Improv on Bravo, and laughed my fool head off.

The nth social networking software

2005-09-13T11:50:00.000-07:00

As much as I enjoyed Friendster when it came out, it took quite some time to set up the various pictures and profile information, and then to go through to find whether my friends had previously joined, and if so add them or if not invite them, and then perform periodic maintenance as other friends joined but didn't know I was there to add me (or, to the more paranoiac part of me, did know and chose not to add me anyway). Much like having a blog makes me feel, it is nice to have a little web corner-of-the-world, where if people want, they can stop in and say a virtual, "Hi!"

But then, Orkut came out, and of course, some people liked that one better. Friends gradations is pretty cool; I always had the 7^th grade question of "Are they really my friend? Or just my acquaintance? Or what?", and that solved it, while at the same time re-inforcing the 7^th grade popularity contest in my head. (This friend is a better friend than this other friend, etc.) Orkut has its own profile system, which also serves to link people with similar social interests, regional interests, etc. It also takes a fair amount of time to fill out.

Now that I have the blogging bug, I'm discovering that the various journaling resources on the web are just another form of the social network software, though the focus tends to be on personal publishing. Sure, I can just publish my blog and never look any further, but Blogger also has a profile mechanism. Furthermore, my wife and several friends post on LiveJournal, and in order to see the more private posts, you have to be part of their friends. And there again, you have another social networking issue — where are your friends posting? do you have an account on their blogging system? do you have your profiile on that blogging system or can you point to some more generic profile?

The whole profile thing predates all of these services though. Even basic sales websites want to know your address and credit card information, but then go further to establish buying patterns and areas of interest to give you targetted advertising. Microsoft's Passport was a simple attempt to have a single roaming profile that other websites could use, so you wouldn't have to enter in all your information over and over.

It would seem to me that, with the proliferation of social networking products, that someone would undertake to create a system where people could publish their own profiles (with private information hidden) and that any number of web sites could extract the information they want. That furthermore, it would be extensible, such that if there's some new bit of trivia that a particular service to which you subscribe desires to know about you, you could extend your own profile with that information. There would have to be some kind of standardization, lest they ask you to produce the data in three different ways based on three different modes of consumption, but that seems like it would be relatively straightforward. In today's world of XML and XSLT transforms, you might even just be able to have the data once and just mirror it into other formats. Friends/Acquaintances would be referred to by the locations of their published profiles, etc.

In the interim, though, it seems an interesting exercise to see if I come up with the same Favorite Movies in the same order on the various web sites I have to fill in that information. Right now, you can clearly see that I'm of many minds about things (or at least am absent-minded sometimes).

Too much|little to post

2005-09-11T22:22:00.000-07:00

I don't know that I've come up with good decision criteria as to what should go into a blog. The obsessive-compulsive part of me thinks that a crafted, well-honed, fine piece of editorialship is required. The rest of me balks at both the effort that would be required and the necessary reduction of the thoughts that that kind of piece would require. Ah, well, I suppose, after some consideration, that I'd prefer to show my foibles.

But first, I can show you the foibles, er, postings of my wife in her journal. She's abroad for an educational stint at the American University in Cairo. She's away for a while, which can be kind of hard, but between Skype and iChat A (we don't use the "V" yet, since her connection doesn't have enough throughput), we get to talk to each other pretty regularly.

Now back to the nitty gritty. This week, I ran into yet another "can't install/use except as admin" program. These irk the crap out of me, largely because I want to be able to make it so that guests of my house can't (accidentally) destroy my stuff on my computer, but that they should be able to install things when I'm not home. I have heard arguments that IT departments want to be able to restrict people from installing anything, but that seems like an orthogonal problem. It is just a bug (sorry, I meant design flaw) that a regular application cannot be installed merely because the setup program seems to believe it needs administrative credentials. Many things should Just Work™ in a non-admin setting. Apparently, it's problematic enough that (1) developers cannot program correctly for non-admin users and (2) users who should not be admin users are, and invite attack upon themselves, that there are whole other blogs on it.

On the personal side, I ended up hanging out with quite a few friends this weekend that I have not hung out with regularly in quite some time. I spent some amount of time continuing my recovery period from Burning Man, mostly in the form of laundry (of which some is now been pink-ified!), though partially putting various things back into their storage, where they will not be touched for another 51 weeks. I did get a chance to meet some new folks, friends of friends, and head out for a sailing day trip on Puget Sound with them. It reminded me of my two previous longer-term experiences with sailing, and how I certainly enjoyed all the ropework involved. The capstone of the weekend, blog not included, was a fierce gumbo made by my next door neighbor who invited me to dine this evening; by the way, he makes a mean Sazerac-oidal concoction that won even my licorice-hating self over. All in all, a good weekend.

In the vein of the useless: Currently listening to "myself typing this blog entry".

Once more into the breech

2005-08-15T01:13:00.000-07:00

After thinking about blogging for several months, today I finally broke down and did it. I ended up trying to think of something sufficiently witty to name it, when my wife reminded me of Technosloth, my registered (and largly unused) domain, and voilà. After battling with Camino (which would not let me edit my posts) and then Safari (which would only let me spell-check and add images), and finally having to resort to Firefox, I could prepare my initial post. Whoop-de-doo!

This weblog will probably end up being (using intent as a directive) a log about personal pet peeves with coding practices, Real Life™ problems of a developer, and other miscellany of my life.

May you have more patience with me, than I with the world.