Monday, March 31, 2008

Tweeters, UIA Status

Climbing, Addiction

I took last week pretty easy, since I was still kind of wiped out from being sick. This allowed me to be refreshed and ready for my weekly Thursday rock climbing. This week our usual group was supplemented by new friends and some friendly geeks (it was almost a BarCamp reunion). I had a pretty good climbing night, and then we went out for dinner at Shakespeare's Pub which is always fun.

Dinner with a big group is interesting and fun because there are usually two or three main conversations going on, and the center of those conversations may shift around the table. What was weird at this dinner was that any time there was a lull in the conversation, the geeks produced their smart phones and (presumably) caught up on email, feeds, and general internet happenings. At the other extreme, if somebody made a particularly witty comment, these same geeks raced each other to Twitter it.

It was kind of surreal...I generally consider myself too plugged-in, so I avoid highly-addictive services like Twitter. During the recent San Diego fires, I did find Twitter the best source for fire news, but in general I've made a conscious effort to *not* join that community. I really wonder what these services do to a person's attention span. When spending time with tweeters, I get the feeling that if I am not a constant source of interest or entertainment, they will be quickly drawn back to the web via the nearest terminal.

Previously I've thought about how convenient it might be to have a cool smart phone that I could develop software for, but now I fear that my addictive personality would quickly fall victim to these pitfalls.

I kind of get the feeling that hyper-plugged-in people are not so much the creators of Web 2.0 as they are the "product" for some weird Web 2.0 economy. Although, they could just be geniuses with much more time and energy than I have... ;-)

UIA Status

In other news, I made some good progress last week. I have a hacky little patch to winforms that initializes the providers via reflection, and exposes a FormAdded event to get notified when forms are created. I really want to stress that this is just a proof-of-concept to get the pieces connected for UIA, and is not ready (for various reasons) to be proposed for inclusion in Mono. Anyway, this initializes our new UIAutomationWinforms assembly so that it can create providers as Forms are created. I also made a little more progress on the WindowProvider and ButtonProvider, but they haven't been my focus so they are still incomplete. I wanted to work more on our "core" that will connect the UIAutomationProvider assembly with the winforms provider and the UIA<->ATK bridge, but ended up getting stuck reading a lot of documentation about the Microsoft implementation.

Andres has done some awesome work to get the bridge working, so I'll be working with him to get the end-to-end model working. It will be very nice to have a thin vertical slice of our entire infrastructure working, so that we can at least see winforms windows in Accerciser. I'll be working on the core and improving providers this week.

Summer of Code Deadline Extension

Also, the deadline for submitting proposals to GNOME for Summer of Code 2008 has been extended by one week. I spent a lot of time this weekend reviewing the proposals we have received so far, and plan on spending next weekend in much the same way. There are some really great proposals in there, but it will be good to see what another week brings us. I don't expect to do any mentoring (I didn't propose any Tomboy ideas this year), but it's fun to help out with the whole process. My main role this year will be getting on people's backs about deadlines and overall status. ;-)

Thursday, March 27, 2008

Yeah, I think I'll attend LugRadio Live USA

LugRadio Live USA 2008 looks like it's going to rock hard, and Southwest has cheap fares, so I think I'll go this year.

But before I book a hotel room or bother friends in the east bay...does anyone have an open couch, or a hotel room they want to split costs on?

I figured I'd go up Friday morning and leave Monday morning.

Monday, March 24, 2008

Fevers and hacking go together like rocks and rollerskates

So I was pretty sick last week, running a high fever for several days. Consequently, I didn't get a whole lot done. But here's my status since my last update...

I talked with Jonathan Pobst and Geoff Norton to figure out how we should hook into the winforms implementation...Calvin, Andres, and I had been discussing the idea of implementing the UIA providers directly in the winforms assembly. Turns out we really can't be adding anything public to winforms or even adding additional dependencies, since we need to match the Microsoft implementation. Therefore, we'll be trying the following approach:
  • Winforms UIA Providers are implemented in a separate assembly (WinformsAutomationProvider).
  • When the Winforms assembly initializes, it will use reflection to initialize required UIA assemblies like the provider implementation (and possibly the UIA<->ATK bridge).
  • The WinformsAutomationProvider assembly will use reflection to hook into an internal Winforms event that will allow providers to be created as new forms and controls appear. This internal event may need to be added to Winforms.
I made a diagram of this to help me visualize the interaction. It assumes the existence of a UIA "Core" that would sit in between provider implementations and potential bridges. This would be a more flexible design, but there's no reason we can't just have our provider implementations go straight to the UIA<->ATK bridge if that makes the most sense.

In the future there will be at least one more provider implementation (Moonlight), and potentially there could be other bridges if we needed to target other accessibility platforms. Anyway, the big question mark in there is who is the one to initialize the bridge. That's probably a piece of conditionally-compiled code sitting in the core, though I haven't really thought much about it.

So I've been working on provider implementations for Form and Button, with some success. I also experimented with a couple of ways to set up the internal Winforms event. By the end of this week, I will have created the infrastructure for the WinformsAutomationProvider assembly, which will include my Form and Button providers. I will have a patch to Winforms that initializes that assembly, so that I can dynamically create providers as forms are created. I may also work on the Core or whatever else needs to be done.

I'm looking forward to a more productive week.

Monday, March 10, 2008

A week in Cambridge, a11y status, new Tomboy release, and other hacking

So I spent last week in Cambridge, getting to know Mike and Andres, who just joined the Mono Accessibility team. Aside from consuming massive amounts of seafood, I became a lot more familiar with the project and the entire accessibility landscape. I do wish I'd seen more of Boston, though.

I'm going to start blogging a sort of status report every Monday, to keep everybody informed about what I've done and what I'll be doing as part of implementing UIA on Linux. This is the first such entry. Last week was kind of a wash for development, but I did help get Mike and Andres set up, verify some of our unit tests against the MS UIA implementation in my new Vista VM, and delve into winforms code. We need some way to know when new Forms are created so that we can register them in the UIA-ATK bridge, but once they are created, I believe we can implement the UIA "provider" interfaces with just regular access to the public members of forms and their controls. Though I've been warned that it may be necessary to hook in a bit lower in the winforms code...

This week I intend to start implementing some basic UIA providers (window, button, etc). I'll drop some code into winforms to alert me when new forms are created, and since the UIA-ATK bridge is not quite ready, I'll write a few tests directly against the provider interfaces. Should be fun!

In other news, Boyd just released Tomboy 0.10.0! This is a nice release with a lot of polish. I think people are really going to like Notebooks...I'm looking forward to feedback that should let us know if we were right or wrong in going with Notebooks instead of free-form tagging (which is totally supported in the implementation, if anybody wants to write an addin or dbus client). I'm sure that we'll get a lot of good suggestions from our users, as usual. Soon we'll have a meeting to plan our next release, so keep your ears open!

I've also been spending some time on Tasky, which I'm liking a lot better than the other task programs I've tried. In general I like RTM's Gmail extension for Firefox, but its mouse dependence really slows me down. My favorite RTM/Gmail feature is how I can type in a task like "lunch today" or "release tomboy 0.10.0 march 10th", and it will become "lunch" or "release tomboy 0.10.0" with the proper due date set. I've implemented this for Tasky, though I don't yet support as many natural language phrases as RTM/Gmail does (we don't appear to have a cool library like Chronic for .NET). Hopefully some variation on my patch will make it into trunk, as I think this is the easiest way to type in tasks with a due date. What do you think?

Other things I'd love to hack on when I have time: offline Tasky for RTM, DAAP client support in Banshee trunk, and better refactoring support in MonoDevelop (like typing out a new method call, right-clicking the method, and choosing "Implement method"). I'll save my Tomboy thoughts for a future entry...