Time for a litl change

Last week was my last with Novell.

This week is my first with litl.



Novell was a great place to work and I recommend it to anyone. I will miss the Mono Accessibility team, but the beauty of being an open source project is that I can just pop into IRC or review some code on ReviewBoard when I'm feeling nostalgic.

At litl, I'll be working with Brad and his crack team to make the channel experience EVEN MORE AWESOME.

If you're wondering "what will the impact be on Tomboy/Snowy/etc?", the answer is that you can expect more polish on the Mac version of Tomboy now that I'll be dogfooding it every day. And it looks like I'll be switching Snowy to use lxml. Nothing else should change. I still intend to be as involved in GNOME as Stewie will let me. ;-)

Mono Accessibility 0.9 Released!

Yesterday, Brad announced the first release of the Mono Accessibility team's work, which started a little less than a year ago. It's pretty exciting for us to put out this developer preview release; I'm interested to see what people make of it.

The goal of the first phase of our project, which will culminate in a 1.0 release early next year, is to make Winforms applications accessible in Linux with traditional at-spi tools like Orca and Accerciser. In 0.9, we offer support for most Winforms controls (Button, Label, ComboBox, ToolStrip, WebBrowser, etc). In 1.0, we will be rounding out this support to include the remaining controls (DataGridView, TreeView, custom controls, etc), in addition to fixing bugs and improving stability.

It may not sound that exciting to enable accessibility for Winforms apps. After all, you probably aren't using very many on your GNOME desktop today. However, there certainly are some cool open source apps out there (Paint.NET, NClass, etc). And the main benefit will be for overall Linux adoption. There are many businesses, large and small, schools, governments, non-profits, etc...that are stuck on Windows because they have custom applications written using APIs like Winforms. One goal of the Mono project is to provide a migration path for these potential Linux users. Accessibility support is often a requirement, so by making these custom Winforms applications fully accessible in Linux, we are enabling Linux adoption scenarios that would have been too expensive before (rewriting your internal tools is not cheap or easy).

If you are not familiar with our project, let me briefly explain what it is we are doing:

We are implementing Microsoft's "User Interface Automation" (UIA) specification on Linux. During the first phase of our project, we are focusing on the "provider side" of this specification, which offers interfaces that are implemented by the accessibility/automation "provider" for a given control. This is similar to implementing ATK interfaces for a GTK+ widget, if you are familiar with that. We have been writing UIA providers for all of the Winforms controls.

The other half of our work this phase has been creating a bridge from UIA to ATK. This bridge translates between UIA interfaces and ATK roles/states/etc. This is the piece that makes a Winforms application look like a GTK+ app (or any other app written in a toolkit that exposes a11y info over at-spi) in a tool like Orca.



It's pretty cool the way this fits together. Next year, after 1.0 is released, we'll begin the second phase of our project. It includes two major efforts:

First, we will be making Moonlight accessible in the same way we have made Winforms applications accessible. We will create UIA providers for Moonlight controls, and they will automatically gain accessibility via the exiting UIA<->ATK bridge.

Second, we will implement the "client side" of the UIA specification. This is a set of interfaces designed to allow an accessibility tool (think Orca) to interact with accessible applications. It is similar to the at-spi interfaces, and we will in fact be implementing it as another bridge, this time translating "client" UIA calls into equivalent at-spi calls. The benefit here is that as Windows developers create accessibility and automation tools using the UIA interfaces, they will be portable to Linux (and vice versa).

Accessibility is a great feature for users and potential customers. Automation support is invaluable to testers, software QA, and even users who just want to streamline common tasks. With the release of Mono Accessibility 0.9, we are growing the landscape of accessible applications. We look forward to your feedback (and bug reports)!

Busy busy busy

If you've been desperately waiting for my weekly UIA status update, I'm sad to report that I'll no longer be posting those. You can track the team's progress via the development schedule page on the wiki. Never fear, if I have something interesting to share, I will make sure to post for you!

I've started helping out with Tasque maintenance, so I triaged a bunch of bugs and applied some patches. I think we'll be ready for a new release soon. I like working on Tasque; it's a fun project.

I installed openSUSE 11 Beta 3 in a VM last week. It's looking pretty good! The new intlclock applet is very cute with its weather integration. In openSUSE 10.3, I struggled a lot with package management...YaST's GTK+ interface was easy to use but crashed a lot, zypper had a very nice CLI but was ridiculously slow, and I ended up using the ncurses YaST UI, and leaving it up all day so that I could avoid the slow repository updates. In openSUSE 11, things are worlds better:

• Zypper is wicked fast, and is now my favorite way to manage packages. All it lacks is tab-completion of package names, but running `zypper se somepackage` is so fast that I don't mind too much. ;-)
• YaST's GTK+ interface has been updated to GTK2 (so it fits in with the rest of my desktop), no longer pops up a kabillion windows when you install packages (so I can, you know, use my computer while I install stuff), and seems really stable. I found some usability problems, but Sunday I wrote a patch and this morning Michael Meeks committed a modified version of it. YaST's GTK+ code was really easy to follow, by the way, considering I'd never looked at it before. Kudos to the YaST team!
  

I hope Firefox is better on openSUSE 11. Maybe it's just my crufty 10.3 install, but I've always had freezing/crashing issues with FF2 and FF3. It seems to be running fine in my openSUSE 11 VM, so I'll keep my fingers crossed. Looking forward to doing a clean install of openSUSE 11 on my main machine soon.

Oh and by the way, I'd like to toss out a quick immature Fuck You to Blogger for never auto-saving my posts, constantly crashing Firefox this morning, and having some weird display problem where the "Compose New Post" page has teeny tiny fonts. I guess I shouldn't care too much about the display of the page, since I apparently can't use it to write posts anymore. Normally FF3 restores the contents of text boxes after a crash, but for whatever reason this is not supported by Blogger. Hooray for using Tomboy as a text editor. :-/

Next, spiders...

Tomboy 0.11.0 released, et UIA

This morning I released the first development release in the 0.11.x series. Tomboy 0.11.0 features Boyd's Tasque add-in, the beginning of John Anderson's rewrite of the printing add-in (goodbye libgnomeprint!), and even a patch or two from our founding father. The new printing add-in lacks a few features, most notably text styling/formatting. We'll make sure to get it fixed before 0.12.0 is released, but if you want to see it fixed faster, patches are welcome. :-P

Last week didn't feel very productive at work. I made one commit and a table mapping winforms controls to UIA ControlTypes. I don't really understand where the time went. :-( How many hours did I lose wrestling with my Vista VM, or exploring the Mono implementation of the WebBrowser control? Fortunately, as the table shows, I have PLENTY of work to do! So I'd better get to it...

UIA Status, All Moved In Edition

Moving was...exhausting. When I can find my camera, I'll post pictures of my new bedless office. In the mean time, here's what I've been up to in UIA Land:

Last couple of weeks

• Started work on UIA providers for CheckBox, Label, and NumericUpDown. Extracted common functionality into abstract base class suitable for most Winforms controls.
• Began writing tests of WindowProvider for Forms.
• Worked with Andres to get child controls, specifically Buttons, mapped from UIA to ATK. Fun refactoring of UIA<->ATK bridge. :-)
• A few dozen more unit tests of MS implementation, and associated fixes.
  

This week

• Compile list of all SWF controls we need to support, and work with Calvin on a schedule for implementing them.
• Fully implement the providers I started last week.
• Help with mapping signals/etc between UIA and ATK.
  

Why do we bother with Linux? Also, UIA status, and Twitter revisited...

The Question

My good friend Aaron is a PhD student in Geology at Penn State. We've known each other since we were toddlers, and connect on many levels. He uses Matlab and god knows what other crazy software to write molecular simulations for his experiments, but he's not the same kind of geek as I am. After reading about Banshee on my last blog, he comments:

I really like reading your blog. I click on all the links and feel like I'm learning something. I do have one question though. When you are working to create these programs for Linux does it ever feel like you are reinventing the wheel? It seems like a lot of time and effort is spent creating linux versions of programs that already exist. Sure there are a few new features that are neat but the bulk of the work seems like recreation. I'm totally missing the point here right?

I've been thinking about this for a few days now. I'm not going to waste time arguing specifics about Banshee, bringing up examples of truly new and unique software on Linux, or explaining how even when we are reinventing the wheel, it is a worthwhile and fulfilling endeavor. Instead, in the spirit of Passover, I will address the general question, "four children" style:

So, why do I spend so much time working on Linux, when a no-cost proprietary solution may already be available?

The free software zealot says: "I will not use software unless it is free (as in freedom). Whether or not a proprietary solution exists is irrelevant; I have problems I need to solve, and if there is no free software that solves it I will create a new project. It is simply unacceptable to sacrifice my freedom for the sake of convenience. As Benjamin Franklin said, 'Those who would give up Essential Liberty to purchase a little Temporary Safety, deserve neither Liberty nor Safety.'"

The pragmatic user or programmer says: "It is in my best interest to use free software. If I find a bug or wish there was a certain feature, I can talk directly with developers about it, pay somebody to fix it, or fix it myself. I don't have to wait until it's in the best interest of some corporation. I don't have to be afraid of being stuck with unsupported abandonware."

The young developer says: "Reinventing the wheel is half the fun of writing software! Even if there *is* an existing free software project that mostly does what I want, I'll probably start one from scratch because then I can do it *my* way. If it's useful to others, then that's great, too. Duplication is par for the course in the software world; after all, weren't there plenty of media players before iTunes, and aren't there still? If there are multiple operating systems, applications, or web sites that appear to serve the same need, then you just need to look closer to understand what niche each is for."

The user who does not understand enough to know the difference says: "My friend/child/administrator set up my computer with Linux. If popular software isn't available on Linux, I'm usually lucky enough to find a suitable free alternative. I get free updates and no weird restrictions on how I can use my computer."


My own answer is a mix of those. Sure, sometimes when I'm writing code that could literally be copy/pasted from some Microsoft engineer's workstation, it's a bit frustrating. It's frustrating that other companies rarely see fit to release their code. But in reality, most code that I write isn't like that at all. It's written to solve a specific, unique problem, and when I solve that problem I feel fulfilled. Using and writing free software gives me warm fuzzies. And as a developer and demanding user, it is very important to me to have access to source code, so that I can fix bugs and add features I care about. Nobody at Apple ever cared about the problems I had using iTunes to burn CDs (every version and OS), and I couldn't do anything about it. That's the opposite of feeling warm and fuzzy.

I'd be interested to see how other developers answer this question, though.


Yay, UIA

Andres has started adding support for firing ATK events, so now we can see Windows Forms appear and disappear, as expected, in Accerciser. It's been fun working with him on this...I get the feeling we'd be a good pair for XP, if he wasn't on the other side of the globe. :-P I've written a lot of unit tests against Microsoft's classes and fixed ours to match that behavior.

This week I'll be continuing with that, and probably working with Andres to expand our event support. I'm excited to be able to send and receive standard window and button events. But I guess I'm easily excited?


Yes, Twitter

I've been experimenting with twitter, because it turns out people I care about are using it in non-masturbatory ways. I'm looking for a better client that I can read on *my* time (instead of being IM'd whenever a friend updates). Gtwitter isn't getting updates for some reason and Twitux requires newer GNOME libraries. If I start checking for new tweets more than twice a day I'll have to do something about this...

LugRadio Live Rocked, and UIA progresses

So I'm on the plane back to San Diego after spending all weekend in San Francisco at LugRadio Live, and HOLY CRAP that was an awesome time. It could be that it was my first open source conference, or that I stayed with some awesome Utah hackers, or that I got to meet a ton of colleagues in person for the first time...but man I'm glad I went. Soon I'll post about the details, but for now I'll talk a bit about how the UIA implementation is going.


UIA Continues at a Reasonable Pace (watch out for dangling participles!)

For now we're sticking with the design approach I discussed last week for connecting the Winforms UIA providers to the UIA<->ATK bridge. But I didn't work much on that, because there are some issues with atk-sharp that Andres is busily hacking away at. Instead, I've been writing unit tests against Microsoft's implementation to pull out a ton of constant values that we need. This was really boring so I wrote a little program to automate it, though it's not very general. I think it would be cool to expand it to parse through MSDN documentation for some given classes and generate the boring unit tests for the appropriate fields/constants/etc. As it is it probably took me as much time to write the test generator as it would have to write the tests manually, and it's not terribly reusable. :-P I'll write more about it if it grows.

This week I'll continue writing unit tests, though I have some catching up to do because I spent Friday largely offline, and ditto today, so I've got to see where the team is. There's still plenty of work to be done in the providers and the core; they're just harder to test right now.


Tune In Next Time...

I started writing about LRL but it just got too damn long and I have work to do. But for now, I will fire the first volley in what is sure to be an extensive character debate. Here's young Aaron Bockover to share with you his impressions of LRL, through the magic of the karaoke Rickroll:

Moving, UIA Progress

Moving

Looks like we'll be moving from San Diego to Las Vegas some time around May 1st. We're having some trouble finding a decent home to rent, but I'm hoping that will all resolve itself in the next few days.

UIA Progress

Last week, Andres committed a ton of fixes to get stuff working in the UIA<->ATK bridge. I spent a few days working on my end (winforms and providers), until we finally got this:


So that was exciting. Our friends on the Mono team helped us figure out that some of our problems were caused by the fact that Winforms actually has a current dependency on GTK+ to get theme colors! The initialization of GTK+ before we load our UIA<->ATK bridge was causing runtime failures. We have filed a bug on it, and will probably be removing the GTK+ dependency in Winforms (see bug for details). Currently we work around it in our patch to Winforms.

Of course, the implementation to achieve this wasn't really too great. My providers were depending directly on Andres' bridge. So now it's time to start working more on the "core". I'm experimenting with it now. Here's an updated version of my old diagram, color-coded to differentiate between MS assemblies and our new assemblies:


Notice that I have removed the core, and in its place is the MS-defined UIAutomationProvider assembly. I played around with different designs, but there is a fundamental problem in that MS intends all interop between providers and *their* core to happen via a static class called AutomationInteropProvider, that lives in the UIAutomationProvider assembly along with a ton of useful interfaces. Well, we can't add new public interfaces to that assembly, but when messages come to the AutomationInteropProvider they need to somehow get to the bridge. And I'm trying to avoid excessive reflection.

So right now I'm assuming that I can define a good bridge interface in a new assembly, UIAutomationBridge, that only depends on MS's UIAutomationTypes assembly. A class in the UIA<->ATK bridge assembly implements that interface, and the AutomationInteropProvider uses reflection only once in order to find that class. This prevents me from using interfaces in the UIAutomationProvider assembly in the bridge interface, but I think this will be okay...we'll just have to pass a few things around as plain old objects, and document what the client can expect from them.

I'm thinking that this AutomationInteropProvider class is already designed to represent the "core", so I'm just going to run with that idea this week and see where it takes me. It's all happening in the olive and uia2atk projects.

My winforms providers are a little nicer now, but they're not much use until the bridge grows a little bit. So this week I'll focus a lot on these design issues, and also I need to write unit tests against MS's implementation to derive a bunch of constant values.

It should be a fun week; I like this sort of stuff.

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. ;-)

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.

A Few Firsts

Monday had some pretty interesting firsts for me...

• First day with a 30-second commute, instead of a 30-minute one.
  
• First day where getting to my desk didn't require a badge and several security checks.
• First day writing software for citizens instead of soldiers.
• First day writing free software full-time.
• First day working for Novell.

Yes, the rumors and tabloids are true: I've joined Calvin's accessibility team. I'm really psyched with this turn in my career. It's a nice change to support a cause that is more aligned with my own values. Not to mention that I'll be working with a bunch of engineers that I really respect, and from whom I hope to learn a lot.

Plus...I've always wanted to take my dogs to work! ;-) Working from home is...interesting.

Oh, and another first: this is the first day where I've been allowed to take a picture of my work area! Behold!


Just imagine a bowl of cereal by my headphones, a dog under the desk, and OpenSUSE on my awesome company-provided 24" LCD, and you'll see what I see right now.

Cheers!

Row, row, row

Paintings

One of the things I used to like about my job was how the walls were decorated with amateur art, much of it created by employees. When I needed a break, I would take a long walk from piece to piece, occasionally finding something that really reached me. One day a while back I was walking to my cube and noticed that the paintings in my area (the entire second floor) were all being taken down. I asked if we were getting new ones, but it turned out we were getting something else. Billboard-sized promotional posters with soldiers and weapons and satellites, all larger than life, with catch phrases to convey the company's strengths.

The posters were not just huge, but they protruded about three or four inches from the wall. And it turned out they had so many of these that they put the extra ones _inside_ our closed area (which previously had no art). Our aisles are not even big enough for two people to pass without one turning, and this did not help.

So this was obviously done because we have customers in our area sometimes and we want to convey a professional image. The effect on me has been the constant reminder that my job is to increase the efficiency with which we take lives. No matter the reasons, this is not something I'm comfortable with.

The posters are still causing claustrophobia in our closed area (a closed area is a large secured room -- ours is most of the second floor -- that is approved by the DoD for various classified work). They have taken down a few in the halls outside my area, and art is beginning to reappear.

But anyway, I've been checking out the new art downstairs since I can't relax in the halls upstairs. One of our employees is very talented in landscape, which I enjoy. My current favorite is a watercolor of a rowboat partially docked on a wooded river or lake bed. I don't know the names of colors, but I love looking at this painting. Some days, like yesterday, my eyes are drawn to the water, which perfectly reflects the overhanging trees, the distant mountains, the setting sun. Other days, like today, I can only stare at the row boat. It's dark, and its composition seems to shift more than the water's.

If I liked to contemplate art at home, I'd buy it.

Returning The Favor

For a long time I've been a consumer of free software, thought-provoking blogs, and of course Wikipedia. What has kept me from contributing back on a regular basis? Anyway, I'm trying to rectify that. It's been going well and I'm feeling really good:

• Tomboy work is very rewarding. Whether I'm hacking on the new portable-tomboy branch, trying to fix last minute bugs before the upcoming release, or contributing to Bugzilla/IRC/etc, I feel like I'm doing something that matters to me and to other people. I don't know why I took such a long hiatus from working on it.
• I'm trying to be more proactive on the various mailing lists I'm subscribed to. It's nice to be able to answer questions about products like MonoDevelop.
• Sometimes I even comment on blogs I read from planet gnome, etc.
• If I see a problem in a Wikipedia article I'm reading, I fucking fix it. Seriously, it only takes a couple of minutes. Wikipedia doesn't work if people don't interact with it, and I'm so tired of just taking.

So I'm trying to be a better citizen in this free culture that I claim to support. I really hope I can keep it up. It's fun and it makes me feel good. A nice departure from my job ;-)

I Was Just Trying To Help

It was me. I put up the sign in the first stall of the men's restroom that says "Nobody's Perfect. If you're standing up, please lift the seat." And you know what? It worked! I stopped seeing pee all over the toilet seat! Imagine that! Then recently we had a bunch of customers in for some sort of thingy, and I went to use the restroom and noticed my sign was gone.

Then I looked down and noticed there was pee on the seat.

Oh well, at least I had a few months of not having to clean up old man pee.