A few articles have already been written. There’s lots left to do, of course, but we’re making progress. If you see something you’d like to write about, feel free to contribute!

As always, the content of that page is in flux while the feature set of Firefox 4 continues to be adjusted. In addition, it’s obviously too early to be sure exactly what articles will be produced for all the topics at hand, so there are a number of placeholders.

If you’ve contributed code to Gecko or Firefox recently, you may be hearing from me or one of the documentation contributors soon, to gather information about your area of expertise as documentation comes together.

I’ve also written a rather lengthy article on MDC about how it works. Hopefully this will be helpful!

I’m now getting started on writing the more extensive documentation for js-ctypes, including a full reference for its API.

If it’s not obvious, I think js-ctypes is one of the coolest things ever.

MDC

The big task for this week, other than getting caught up (which shouldn’t be too hard since I generally was able to triage most of my email and did handle MDC editing tasks while I was out), is to start the overhaul of the js-ctypes documentation now that I have a pretty good handle on the changes there.

We’ve scheduled — finally — our upgrade to MindTouch 2009 9.12.2, to take place during tomorrow’s maintenance window. We have hopes that this will further improve reliability and performance. It does on our staging server, at least under certain situations, but it’s hard to gauge how that will carry over to the live site, which obviously gets much more traffic and is more powerful hardware.

Weave

I’ve started playing with the code for the iPhone Weave client a bit. I think I’m going to try to build a simple web browser around the code, so I can do quick surfing to look at stuff using my Weave bookmarks and history without having to tap links to swap over to Safari to do it. At the moment, I have the existing client building but it’s crashing on me. Not sure, yet, why that’s happening. Looks like I may have pulled the repository in a state of transition, so I’ll try again tonight.

Weave has turned into something I really can’t live without, and it’s driving me nuts not having it on my iPhone.

This will become more of a problem once I have my iPad; I placed my order for a 3G iPad last night after finally having a chance to try one out yesterday afternoon. I foresee the iPad becoming my primary method of surfing and handling email when I’m at home, just because of how convenient it is to have with me. So getting a good Weave client together is pretty important to me.

The trick, for the moment, is that the sample requires a customized build of Firefox, since it relies on a patch to enable support for accessing external data. This patch, or, more likely, a revised version of it, should land sometime before too long. There’s some discussion ongoing about changing the way this feature is exposed, so I’m holding off on posting my sample until that’s finalized.

I’m quite intrigued by the possibilities offered by js-ctypes; another idea I’m kicking around is an extension that would let you download and burn ISO images in a single action, using the Disc Recording framework built into Mac OS X.

There are a lot of interesting things this makes possible to do very easily, that previously would have involved a lot of native code and XPCOM trickery. It’s very exciting stuff!

This opens up a lot of possibilities for extension developers, by making it vastly easier to interface with native libraries. This includes support for directly talking to system APIs.

The demo I’m working on is an extension for Mac users that adds an item to the context menu that appears when you right-click on images, “Add image to iPhoto.”

I’m using Core Foundation routines and the Launch Services API, which is part of the Application Services framework to implement this, by taking the URL from the img element’s src attribute, grabbing that, and using Launch Services to open it in iPhoto.

The trick at the moment is that I need to pass a reference to a standard, built-in structure that’s part of the Core Foundation framework to a Core Foundation routine, and at the moment, js-ctypes doesn’t support accessing these external structures. But dwitte has a patch for that, and we’re testing that patch now, so that barrier should be lifted shortly.

With that done, hopefully I’ll be able to wrap this demo up soon, then I can work on updating the existing js-ctypes documentation, which was written to an older version of the API. While the existing docs are mostly still accurate, they only cover a fraction of the current capabilities of js-ctypes.

The past week or so of working on this has been a blast. I really enjoy when my code monkey side and my documentation overlord side collide like this. It’s great fun, and, as in this case, often leads to discoveries that are helpful to the engineers behind the feature being documented.

In this case, we found a viable use case for needing to implement support for accessing external data provided by libraries. We also found a situation in which not being able to catch exceptions thrown by the external libraries can be a problem (ie it can bring down your browser), so there’s now a bug filed for that.

Also, the errors reported by js-ctypes still need some love, so there’s a bug for that now.

Also, there are cases where it would be very helpful for clarity’s sake — and for implementing things such as the concept of a CFMutableArrayRef being passable to any function that accepts a CFArrayRef — to support const declarations.

This is one of those times where being a technical writer feels especially full of win. My work toward understanding a technology has resulted directly in improving the technology itself. That reeks of awesome, and makes my job all the more worth doing.

Why, then, have I started blocking ads?

Simple. Companies that insist on using tricks to try to force you to look at ads you don’t want to see. Pop-up and pop-under ads, for example.

Worse, to me, is those ads that pop up if you simply mouse over text in the middle of a news story. This is the epitome of skanky behavior on the part of advertisers. It’s offensive and disruptive. This is why I block ads now. If advertisers would simply realize, “Hey, if we only put some ads here and there in the main page and refrain from making them stunningly distracting, from interfering with the actual usability of the site,” then I would be perfectly happy to turn off the ad blockers and let the ads back into my life.

Until then, I’ll block the ads.

CSS transitions make it easy to smoothly animate changes to CSS styles, instead of changes taking effect instantly. With a number of ways to control and customize the transition effect, and support for everything from font size and style to colors and even position, you can create some impressive effects with very little work. I suggest taking a look at the demos I put together to get a good idea what you can do.

Obviously since CSS transitions are still in the Working Draft stage, it’s entirely possible the syntax could change, but this is a great way to easily add a little pizazz to your web content.

I’ve written a series of eight articles with corresponding demos. In order to try them out, you’ll need to be running a trunk build of Firefox, and set the webgl.enabled_for_all_sites preference to true.

Getting started with WebGL

How to set up a WebGL context.

Adding 2D content to a WebGL context

How to render simple flat shapes using WebGL.

Using shaders to apply color in WebGL

Demonstrates how to add color to shapes using shaders.

Animating objects with WebGL

Shows how to rotate and translate objects to create simple animations.

Creating 3D objects using WebGL

Shows how to create and animate a 3D object (in this case, a cube).

Using textures in WebGL

Demonstrates how to map textures onto the faces of an object.

Lighting in WebGL

How to simulate lighting effects in your WebGL context.

Animating textures in WebGL

Shows how to animate textures; in this case, by mapping an Ogg video onto the faces of a rotating cube.

I should note that the last demo currently badly leaks memory due to a bug in the WebGL code in the current trunk builds of Firefox. A fix is in the works and should hit the tree soon.

I really look forward to seeing some of the excellent stuff that’s likely to come with the introduction of GL support for the web.

Before we knew it, Happy was on the move, exploring the living room. I got down on my knees and tried to catch him, but of course he was too quick for me. So I got some food and put it out, and he ignored it, and started checking out under the couch, over by my chair, and so on.

So then I tried putting some food in my hand and waited, and while he came and sniffed around my hand a bit, he didn’t climb onto it, so I wasn’t really able to snag him.

Finally, I had a brainstorm. We just got Happy a new, larger cage the other day, and the old one (also glass) hasn’t been put away yet, so I had Sarah go get that while I kept an eye on Happy.

She brought it to me, still empty, and I set it down on its side on the floor, then placed inside it Happy’s food dish with a little food in it. Then we waited.

It only took a minute or so for Happy to notice it, sniff around a bit, then crawl inside. A quick tipping up, and Happy was recaptured and transferred back into his new cage.

Watching Happy explore the world while dodging my attempts to grab him was actually sort of fun. But in reflection, it also makes me think about how tricky it can be to document moving targets like the open Web. Stuff changes, and it changes fast — sometimes so fast you can’t keep up. Seems like every time you reach out to start writing about something, it either changes or gets made obsolete by something newer, better, or faster.

But, just like trying to catch a runaway rodent, documenting the open web is a lot of fun, in a strange, giddy sort of way.

There are several new interfaces, as well:

• nsIDOMOrientationEvent
• nsIAccelerationListener
• nsIAcceleration
• nsIAccelerometer

I’ve asked for feedback and technical review from dougt among others, so it’s possible this material could change as I receive corrections, but based on my reviews of code, samples, and existing material, this should be fairly accurate.

This is going to be a very cool technology. Obviously it’s especially useful for mobile users, but laptop users may get some use out of it as well. It has a lot of potential both for user experience improvements (such as rotating the user interface based on the orientation of a mobile device) and for web gaming.