Planet Mozilla Interns

Adrian Kalla: Browser ballot fail: asks to set IE as the default browser

Thu, 11 Mar 2010 19:50:28 +0000

Wasn't the whole ballot thing about preserving the users choice? Then wtf is this:

Procedure to reproduce:

choose to install your prefered browser, but not IE (actually, my prefered browser, SeaMonkey, is not in the list, even when it is the 6th most popular desktop browser in Europe... That's a big fail too.)
close the ballot screen by clicking on "Choose later (Später auswählen)", because you couldn't find a "Close" button
install the downloaded browser and set it as default
restart your system
see the ballot screen asking you to set IE as the default browser

Is it just me, or does this look like a violation of what Microsoft has signed in Brussels?

Benoit Girard: Optimizing CGContextDrawImage

benoitgirard — Tue, 09 Mar 2010 05:49:41 +0000

I wanted to share my finding on optimizing CoreGraphic’ CGContextDrawImage, a performance critical part of my upcoming patch for the Core Animation drawing model.

After implementing the read back from openGL, I was expecting the bottleneck of my code to be the glReadPixels() call since we are copying from VRAM to RAM every frame, however I noticed using Shark profiling tool that I was actually spending more time in CGContextDrawImage.

After investigating further I noticed using Shark that CGContextDrawImage was invoking argb32_sample_RGBA32 where cairo’s calls where not hitting this sampling routine. After a few hours of tweaking I managed to get around the first cause of this sampling by using the monitor’s color profile instead of ‘kCGColorSpaceGenericRGB’.

The second problem less obvious. I had previously looked at the transformation matrix to make sure that no scaling was happening. The transformation matrix was translating by (tx, ty) and was scaling the Y axis by -1. I had incorrectly assumed that scaling Y by -1 would be handled as a special case ‘flip’ case instead of using scaling, however resetting the scaling to 1 resulted in a drastic performance increase. Since my rendering was now reversed I applied the transformation on my OpenGL context where scaling is very efficient.

After the tweaking the bottleneck was now glReadPixels as I had originally hypothesized. I did not grab accurate measurements of the performance difference but I would say the rendering is now at least twice as fast as it was when I was hitting the sampling routine. Once we do away with the glReadPixels step this patch will be even faster!

Wei Zhou: It’s really not all about money

weizhou — Fri, 05 Mar 2010 20:41:55 +0000

When I studied Graphic Design in Yale University, my professor told me a universal truth: “When you choose a career path the primary thing is figure out if you would enjoy the details.” I realized at a young age that I don’t enjoy choosing typefaces among a thousand of options, so I quit graphic design. Among these years, I’ve watched so many types of jobs: I would never be an investment banker because I don’t enjoy correction typos or copying pasting numbers in the pitch book. I would never be an programmer because debugging kills my skin cell. And I would never be a teacher because I don’t enjoy talking to dumb kids. Now I work as a senior consultant in user experience industry, I realize sometimes don’t like using visios to create wireframes or photoshop creating visual design comps. This baffles me for a while: how could I ever fulfill and satisfy myself? I think this article(by josh Kaufman) answers this question well: you need to know yourself well enough.

Here’s a deceptively simple question: why do people work? On the face of it, the answer seems relatively straightforward:

The 3 Core Levels of Material Need

Level 1: Resources
Working for immediate needs like food & shelter; living paycheck to paycheck.

Level 2: Security
Working to ensure safety; saving and investing for future needs.

Level 3: Freedom
Working to ensure self-sufficiency and independent choice of action.

These three levels of work are similar to the first few levels of Maslow’s Hierarchy of Needs or ERG Theory: work is a way we can meet our basic existential needs effectively and reliably.

That’s a perfectly reasonable explanation, but here’s where things get interesting: what happens when people have enough resources to do whatever they want? What does “Level 4” look like?

Level 4: Primary Motivation

Consider individuals like Warren Buffett, Steve Jobs, Dick Cheney, and Angeline Jolie. Each of these individuals has enough money to ensure that they never need to work again – they could quit tomorrow and live off of their savings in perpetuity. For some reason, however, they don’t – they keep working. Why?

After considering this question, I think that people who have reached the “Freedom” stage of work make a choice (either explicitly or implicitly) about what they’re ultimately working for. The choice ultimately revolves around what that person values most: power, status, pleasure, creation, or quality.

#1: The Autocrat

The Autocrat’s primary motivation is power and control. Common behaviors include continually seeking influence or control over the lives and actions of other people. Examples: businesspeople turned politicians like Henry Paulson (US Secretary of the Treasury), Dick Cheney (US Vice-President), and Michael Bloomburg (mayor of New York City).

#2: The Narcissist

The Narcissist’s primary motivation is attention, status, and fame. Common behaviors include continually seeking the attention and esteem of other people, and acting in ways that will ensure they receive more and more attention. Examples: actors / celebrities like Lindsay Lohann, Brittany Spears, and Madonna.

#3: The Hedonist

The Hedonist’s primary motivation is pleasure and enjoyment of material goods. Common behaviors include the continual acquisition of luxurious homes, fine food, and exotic travel. Examples: Larry Elison (CEO of Oracle), Mohammed bin Rashid Al Maktoum (Sheikh of Dubai), and Paul Allen (co-founder of Microsoft).

#4: The Architect

The Architect’s primary motivation is creating something new or reshaping the world. Common behaviors include the establishment of a vision of what the world “should” look like, then continually pursuing projects that they believe will bring the world closer to that ideal. Examples: Steve Jobs (CEO of Apple), Richard Dawkins (biologist and lecturer), Muhammad Yunus (father of micro-lending), and politicians like Ron Paul, Denis Kucinich, and Al Gore.

#5: The Craftsman

The Craftsman’s primary motivation is quality and enjoyment of the work. Common behaviors include the continual exercise and improvement of a set of specific skills or abilities and use of those skills as a means of self-expression. Examples: Warren Buffett (investor and CEO of Berkshire Hathaway), J.K. Rowling (author), and Stephen Spielberg (filmmaker).

Why is Primary Motivation Important?

Here’s my first hypothesis: once you identify your primary motivation, you’ll find it much easier to achieve your goals. These primary motivations appear to be relatively universal, and are based on very deep-seated psychological needs. Tapping into these sources of motivation directly allows people to accomplish their actual objectives more quickly, whatever they might be. Said another way, it’s easier to get what you really want if you identify what you really want.

My second hypothesis is that not all of these primary motivations lead to a lasting sense of personal satisfaction and fulfillment. If you’re an Autocrat, there will always be people you do not control. If you’re a Narcissist, there will always be people who look down on or ignore you. If you’re a Hedonist, the hedonic treadmill ensures that every pleasure eventually fades. If you’re an Architect, the world seems to have a tendency to stubbornly refuse to conform to your ideals.

When I look at the universe of “successful” people in the world, it appears that the Craftsman has the best shot at lasting personal satisfaction and fulfillment. You ultimately can’t control the world or other people, but you can control your dedication to perfecting your craft and expressing yourself through your work.

If we have a choice in determining our primary motivation, it seems that the Craftsman’s ethos has the most to offer: it may eventually lead to power, status, pleasure, and world-changing achievement, but it frees us from the perception that our self-worth depends on any of these things. That’s a remarkable combination.

Thoughts? Leave them in the comments.

Margaret Leibovic: Sharing Content on the Web

Margaret Leibovic — Wed, 03 Mar 2010 22:11:05 +0000

Since January, I’ve been working as an undergraduate researcher with the Haystack Group in CSAIL. I’ve been working on FeedMe, a plug-in for Google Reader that provides mechanisms to support sharing content with other web users via email. FeedMe facilitates directed sharing by supporting the social processes behind web content sharing. FeedMe uses content previously shared with recipients to determine their preferences, and it uses these preferences to recommend potential recipients for a given feed entry. It also allows users to see how many items have recently been shared with a given recipient, in order to avoid overwhelming individuals with shared content, and it provides a single-click process for recipients to thank sharers, encouraging future shares.

Although the current FeedMe system facilitates sharing within the Google Reader interface, one of its main limitations is that FeedMe recommendations aren’t available outside of this interface. Many information foragers use Google Reader, but most of them also find interesting content from at least one other information aggregator, such as Twitter, Hacker News, or Reddit. Additionally, users sometimes stumble upon novel content outside of any information aggregator, and this is content that their friends are often least likely to see.

To address the main limitation of the current FeedMe system, I’ve been working on designing an interface that will enable FeedMe recommendations for all websites. Designing this interface poses some challenges, especially figuring out a way to make these recommendations noticeable without detracting from the user’s browsing experience. After a series of paper prototypes and mock-ups, I decided to implement an expandable (and hideable) bar along the edge of the user’s browser content. However, I still haven’t decided whether this bar should be at the top or bottom of the content. I’ve included some mock-ups below, and I’m open to feedback.

This week I’m going to begin implementing the basic structure and functionality of this bar using Jetpack, and I’ll try to make updates here whenever I make progress worth sharing!

Top Bar (Collapsed and Expanded Views)

Bottom Bar (Collapsed and Expanded Views)

Josh Matthews: Getting involved with Mozilla

Josh Matthews — Tue, 02 Mar 2010 10:09:10 +0000

I realize that while I’ve been contributing to Mozilla since last July, I’m still quite new to a lot of the process and knowledge that more experienced developers take for granted. Therefore, I’m going to document the steps I’ve taken to increase my understanding and involvement in hopes that it generates some discussion on the best way to help new people get their bearings.

One of the most inviting aspects of the project right off the bat was that I had a point of contact. Benjamin Smedberg announced in a blog post that the Electrolysis project could always use more help, inviting interested people to get in touch with him. This was an immense help, as he pointed me towards a really good introductory bug that forced me to explore and learn about IPDL, IDL, XPCOM, Javascript, the build system, and more. This was perfect for me; I’m always looking to expand the horizons of what I know, and my work hooking up e10s with the typeaheadfind component allowed me to do just that.

I find that one of the largest hurdles for getting involved in any project for me is lack of knowledge. You’ve got a source checkout, and you’ve got a problem to solve, but no idea where to start. If you’re courageous, you can start dipping into random files and window shopping until you find something that looks promising. However, this approach is inefficient. As I said, I really like to expand the breadth of my understanding as quickly as possible, so here are my patented steps to getting a better handle on the source tree:

Subscribe to an RSS feed of commits
Hang out in IRC channels
Watch interesting Bugzilla users

The trick here is to have lots of information available for consumption, and to sample a wide variety of it. I read commit logs every morning, pick out entries that catch my attention and skim the commit. If I’m still interested, I’ll visit the original bug and read through its history. Through these actions, I am now in possession of:

names of people involved in something I’m intrigued by
locations in the tree of code that I’m interested in
other information from the bug – components worth paying attention to, dependencies, blockers, etc

IRC channels are a great way to act sponge-like. Many diverse conversations on all sorts of interesting code-related topics occur in #developers, while more focused channels like #content and #static allow me to pick up new concepts and insights into the work that I’m currently doing. Furthermore, they’re points of contact for people who are usually happy to help out when I’ve got a question.

Finally, Bugzilla is a goldmine of fascinating activity and information. When I started working on electrolysis, I realized that all of work I was interested in was clusted in the Core:IPC, so I set up an email watch on the QA contact for that component. Eventually, however, I wanted to diversify, so I began to follow specific users. Watching the activity of the polyglots of the project, those who dip in and out of every component is a great way to quickly become exposed to the wealth of work being done. There’s a downside to this: the more users you watch, the more intimidating your bugmail becomes. Today, I ended up receiving 270 emails over the course of one hour because roc decided to unassign himself from a crapload of bugs at the same time as a bunch of dependencies were added to some Jaegermonkey tracking bugs. However, I’ve become adept at quickly deciding whether a conversation thread is interesting to me or not, and these deluges are infrequent.

When it comes to learning about specific pieces of code that confuse me, I have another system. If it’s some fundamental concept that I need to grok (nsCOMPtr, ns*String, etc.), I turn to the faithful Google search: “mozilla X”, X being the unknown item, and 99% of the time the first result will be the relevant MDC page. If I’m more interested in quickly locating pieces of code, I pull out DXR and make use of its wonderful search limiters such as member: or derived:. If what I’m looking for is a piece of C or JS code, or simply isn’t indexed in DXR (m-c only), I haul out mxr and search there. If I do a few searches and can’t find what I’m looking for, it’s usually off to the friendly folk in #developers.

There’s one specific moment I remember from when I was starting out – my very first review. I’d submitted my first attempt at the typeaheadfind work, and to my horror, and email arrived with the subject “review denied.” I felt crushed. Reading through the review, I saw that many good points were made, but it was hard at first to shake the feeling that my code was simply not good enough. I’ve gotten better at accepting review- since then, but I feel that a simple change to the email subject (“review complete“) would go a long way to improving that user experience.

So that’s it, really. Through the application of these methods, I’ve gained enough knowledge to submit a bunch of patches, log some bugs, and start answering other people’s questions. It’s really just been a process of perseverance, asking the right questions, and making use of the correct tools.

Got a story? Please share! I’d love to hear how other people’s experiences differ.

Josh Matthews: Faster mercurial patch queue merging with emacs

Josh Matthews — Tue, 02 Mar 2010 01:41:03 +0000

As a follow-up to my previous post about merging mq reject in emacs, I thought I’d share some improvements to the process that I’ve made since then.

(defun switch-hg-reject ()
(interactive)
(let ((other-file
(if (string= (substring (buffer-file-name) -4 nil) ".rej")
(substring (buffer-file-name) 0 -4)
(concat (buffer-file-name) ".rej"))))
(if (file-exists-p other-file)
(save-selected-window
(switch-to-buffer-other-window (find-file-noselect other-file)))
(message "No alternate reject file found"))))
(defun kill-hg-reject ()
(interactive)
(let ((reject-file (concat (buffer-file-name) ".rej")))
(kill-buffer
(find-buffer-visiting reject-file))))
(global-set-key (kbd "C-c r") ’switch-hg-reject)
(global-set-key (kbd "C-x r") ‘kill-hg-reject)

It turns out that swapping back and forth between the reject and the original in a single window felt was quite inefficient. With these changes, the reject opens up in another window (think emacs terminology here) on C-c r, and I can kill it later with C-x r. This also works better with other modules like uniquify – the code from the previous post would fail when trying to access rejects associated with buffers name “Makefile.in|ipc”. No longer must you suffer the indignity of process! Merging can, and should, be fun! BEHOLD MY WORKS AND DESPAIR.

Benoit Girard: Bugzilla Patch Collision

benoitgirard — Fri, 26 Feb 2010 05:10:52 +0000

Edit: I was told that a similar feature was already planned for DXR. I think DXR as the potential to be a very good development tool!

I have been discussing this idea a bit over the work week and though I should perhaps get a better opinion. I haven’t worked on very many patches yet so I might be going from a small sample size but it seams like it should be possible to know if anyone is modifying the same code you are. I would be interested to know how common this problem is to everyone else so please let me know!

What I suggest is to have a separate web app from Bugzilla that would keep a copy of all current patches. You could submit your patch to that server and the web app would present you with a report of all patch that touch the same source files and even highlight patches that directly conflict with your patch. A visual diff of all the patches on a given source file would be a great bonus (color coded like EtherPad). It could also show you information about the review state of that patch (if its been super-reviewed and is likely to land soon). An added benefit is you could query the server if an existing Bugzilla patch can no longer be applied on Trunk (bitrot).

I’m curious to know if people that have been using Bugzilla longer think it would actually be worth while to create this tool or if it would just become an annoying optional step when submitting patch?

Benoit Girard: Improving Incremental Builds Using ObjDir Method

benoitgirard — Tue, 23 Feb 2010 01:03:22 +0000

One annoyance I’ve ran into while working with incremental builds is that the Makefile are generated in the obj-dir. Rebuilding requires you to go from your source directory to your corresponding obj-dir and invoking ‘make’.

Just place the following command in a script in your path:
cd $(pwd | sed 's/mozilla-central/mozilla-central\/obj-ff-dbg/g') && make; cd - make -C $(pwd | sed 's/mozilla-central/mozilla-central\/obj-ff-dbg/g')
This script will call the corresponding obj-dir Makefile from the source folder. As readers mentioned the second version removes the ‘cd’ nastiness, thanks!

This is great if your working with both 32 and 64-bits obj-dirs since you can create a make32.sh and make64.sh script to trigger the corresponding incremental build from the same source folder and manage two builds!

Benoit Girard: Sharing Your Session

benoitgirard — Thu, 18 Feb 2010 20:39:43 +0000

Motivation

I’ve been working a lot with remote people over IRC here at Mozilla. Pastebin can be your friend to share stackdumps but sometimes you need to show an interactive session. This is great if you want someone more experience to help you debug the problem in GDB for example. GNU Screen is a great terminal multiplexer but the drawback is that it requires some configuration.

How to:

Here is a simpler way to quickly share your session over a chat session. You can redirect ’script’ to a listening port using the following command:

touch transcript; tail -f transcript & script -q -t 0 | tee transcript | nc -l 5678; rm transcript;

That’s a long and complicated command but that is the best way I have found to redirect script to both the screen and ‘nc’. Let me know if you know a better way!
To have someone watch your interactive session ask them to execute the following commands:

nc <HOSTNAME/IP> 5678

Extensions

If this is useful others I could extend this to allow the person watching to interact with the session as well, however for now I can just claim that it’s a security issue!

I’d also like to extend this to work with NATs by deploying an online web app where you can request that you would like to share a session with someone and it will give you addresses to connect to and act as a connector so that two users located in different intranets can use this as well.

Benoit Girard: Interning At Mozilla

benoitgirard — Thu, 18 Feb 2010 18:57:01 +0000

I’ve been at Mozilla for nearly two months now. In this blog I plan to share about the projects I worked on, the problems and the solutions I found along the way and other tips that may be useful.

Josh Matthews: Applied knowledge

Josh Matthews — Wed, 17 Feb 2010 13:41:05 +0000

I think I’m starting to feel more at home in the Mozilla codebase. It’s an exciting feeling when you can actually start answering other people’s questions instead of always being on the asking end.

Wilson Lee: JavaScript Quiz and Explanations of its Answers

kourge — Fri, 12 Feb 2010 15:27:47 +0000

Update: Comments are now enabled.

In the field of linguistics, rules can be either descriptive or prescriptive. Simply put, descriptive rules tell you what can be done and prescriptive rules tell you what you shouldn't do. Many articles about JavaScript give you prescriptions: they tell you what you shouldn't do in JavaScript because it's bad practice. After learning to stay away from certain styles and patterns, though, sometimes a simple typo or brain fart can avalanche into a disaster in your code and still leave you puzzled even after attempting, descriptively, to explain what exactly happened.

kangax's JavaScript quiz, geared towards web developers, helps exactly that: finding descriptions that clarify perplexing situations. It does not test your knowledge of any DOM behavior and is focused on the ECMAScript language itself. Since this quiz targets web developers, SpiderMonkey gurus can likely even point to where a given quirk (the term is being used very loosely here) is manifested in the implementation. As always, please point out any possible error in the answer explanations about to follow. Those who are interested but still haven't taken it: halt! Go and take it. I'll wait. After that, read on.

Brian Krausz: Building a C++ XPCOM Component in Windows

Brian — Sun, 07 Feb 2010 20:47:58 +0000

I’ve been teaching myself to write Firefox extensions for the last few weeks, and became interested in XPCOM components. Unfortunately, I couldn’t find a good (and recent) summary of them, and had to spend 3 or 4 days cobbling together various tutorials, so I figured it’s time to write one.

What is XPCOM?

XPCOM is a language-agnostic communication platform used in Mozilla products (and some other random pieces of software) to allow code (specifically extensions) to be written in a wide variety of languages.

Why would I want to use XPCOM?

There are two ways to “use” XPCOM. First, you can call functions through XPCOM. For example, the Firefox bookmarks service uses an XPCOM interface. So in order to interact with this service from Javascript you would do something like:

var bmarks = Components.classes["@mozilla.org/browser/bookmarks-service;1"].getService();
bmarks.QueryInterface(Components.interfaces.nsIBookmarksService);
bmarks.addBookmarkImmediately("http://www.mozilla.org","Mozilla",0,null);

There are plenty of tutorials on doing this as it is the more common use for XPCOM, so I won’t go into any detail on it here.

The second way is to write an XPCOM service. That is what this tutorial covers. Sometimes you need extra functionality, speed, or just want to tie into some library that requires a different language. Most commonly this is C++, but there is also JavaXPCOM and PyXPCOM (and probably a few others). I’ll be talking about C++, since it’s what I needed for my project.

Warnings

Before you trudge through this: you most likely are in the wrong place. Firefox extensions are usually all Javascript. If you can use JS to do what you want, stop now. There is no need to go through the complexity of an XPCOM component when you can just use JS. Go read a tutorial about writing extensions and get to work.
There is something called ctypes coming to FF 3.7 that may make doing this a lot easier. I haven’t touched this at all, but it may be worth considering if you can wait for the functionality and only need to tie into a particular DLL for some functionality. Long story short, XPCOM may become the more difficult way to call C++ functions from FF extensions.

My Setup

Windows 7
Visual C++ Express 2008 (free from Microsoft’s website)
Firefox 3.6 (Gecko 1.9.2)
A UUID or GUID generator. This is a unique (read: random) ID that identifies your app to the world. Windows and Linux have tools to generate this (guidgen & uuidgen, respectively), or you can find various online generators (Mozilla links to several). I recommend this one since it gives you the C++ encoded form too, which you will need. You need two different UUIDs: one for your interface and one for your component.
Ability to read and understand C++

Sample Code

If you don’t want to go through the tutorial and just want everything to work, then download this sample code. Just follow step #1 of the tutorial, then make sure your Gecko SDK directory is set right in the build step, and you can breeze on by most of this article.

The Tutorial

This is mostly paraphrased from Alex Sirota’s great tutorial, but it hasn’t been updated since 2005 and is a bit outdated. This new one should work out of the box for FF 3.6.

This tutorial will create a component called MyComponent with one function: Add, which will take 2 numbers and, surprisingly, return the sum.

Download the Gecko SDK for your version of Firefox. I used 1.9.2 for FF 3.6.
Create an idl file - IMyComponent.idl, with the following (replacing ***IUID*** with your interface UUID):
```
#include "nsISupports.idl"

[scriptable, uuid(***IUID***)]
interface IMyComponent : nsISupports
{
  long Add(in long a, in long b);
};
```
This file is a language-agnostic interface definition which you can read more about here.
Generate the interface header and typelib files out of the interface definition file. Assuming you extracted the Gecko SDK to C:\xulrunner-sdk\, run the following commands (from the directory you saved IMyComponent.idl to):
```
C:\xulrunner-sdk\sdk\bin\xpidl.exe -m header -I C:\xulrunner-sdk\idl .\IMyComponent.idl
C:\xulrunner-sdk\sdk\bin\xpidl.exe -m typelib -I C:\xulrunner-sdk\idl .\IMyComponent.idl
```
These will create IMyComponent.h and IMyComponent.xpt, respectively.
IMyComponent.h has two snippits of code that you can use for the next two files. Everything between /* Header file */ and /* Implementation file */ can be used for MyComponent.h:
1. Start by inserting double inclusion protection code and the right include:
```
#ifndef _MY_COMPONENT_H_
#define _MY_COMPONENT_H_

#include "IMyComponent.h"
```
2. Add the following lines, which define your component name, contract ID, and CUID (where ***CUID*** is the C++-style component UUID, of the form { 0×12345678, 0×9abc, 0xdef0, { 0×12, 0×34, 0×56, 0×78, 0×9a, 0xbc, 0xde, 0xf0 } }):
```
#define MY_COMPONENT_CONTRACTID "@example.com/XPCOMSample/MyComponent;1"
#define MY_COMPONENT_CLASSNAME "A Simple XPCOM Sample"
#define MY_COMPONENT_CID ***CUID***
```
3. Copy in the snippet from IMyComponent.h, replacing all the instances of _MYCLASS_ with the name of your component (MyComponent).
4. Finish off the double inclusion protection code with #endif //_MY_COMPONENT_H_
Everything between /* Implementation file */ and /* End of implementation class template. */ can be used for MyComponent.cpp:
1. Start by inserting the right include:
```
#include "MyComponent.h"
```
2. Copy in the snippet from IMyComponent.h, replacing all the instances of _MYCLASS_ with the name of your component (MyComponent).
3. Add some implementation to the Add method. I replaced return NS_ERROR_NOT_IMPLEMENTED; with
```
	*_retval = a + b;
return NS_OK;
```

Create your module definitions files:

#include "nsIGenericFactory.h"
#include "MyComponent.h"

NS_GENERIC_FACTORY_CONSTRUCTOR(MyComponent)

static nsModuleComponentInfo components[] =
{
    {
       MY_COMPONENT_CLASSNAME,
       MY_COMPONENT_CID,
       MY_COMPONENT_CONTRACTID,
       MyComponentConstructor,
    }
};

NS_IMPL_NSGETMODULE("MyComponentsModule", components)

You now have all of the files needed to build an XPCOM component:

IMyComponent.h
IMyComponent.idl
IMyComponent.xpt
MyComponent.cpp
MyComponent.h
MyComponentModule.cpp

Now comes the hard part: getting the damn thing to build.

Building the code

Ok, it’s actually not hard since I’ve done most of the legwork for you. Assuming you’re using Visual C++ 2008 here are the settings you need (again assuming C:\xulrunner-sdk is where your Gecko SDK is). In Project->Properties:

Configuration Properties
  General
    Configuration Type: .dll
  C/C++
    General
      Additional Include Directories: C:\xulrunner-sdk\include
    Preprocessor
      Preprocessor Definitions: XP_WIN;XP_WIN32;XPCOM_GLUE_USE_NSPR
  Linker
    General
      Additional Library Directories: C:\xulrunner-sdk\lib
    Input
      Additional Dependencies: nspr4.lib xpcom.lib xpcomglue_s.lib

If you put the idl file into your project, be sure to mark it “Excluded from Build” in its properties…we don’t want VS touching it.

Cross your fingers, pray to whatever deity you believe in, and hit the build button. If it didn’t work let me know why in the comments and I’ll try to build a troubleshooting section.

Installing/Testing the Code

Copy two files to C:\Program Files\Mozilla Firefox\components:
- The DLL the build generated
- IMyComponent.xpt
Normally, if this was installed as part of an extension, it would automatically search this directory and find these files. But now we have to force a refresh. Delete xpti.dat. and compreg.dat from your profile directory (FF will regenerate them on next restart)

Close Firefox and open it with this test file (MyComponentTest.html in the sample code):

<html>
<script type="text/javascript">
function MyComponentTestGo() {
	try {
		// normally Firefox extensions implicitly have XPCOM privileges, but since this is a file we have to request it.
		netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
		const cid = "@example.com/XPCOMSample/MyComponent;1";
		obj = Components.classes[cid].createInstance();
		// bind the instance we just created to our interface
		obj = obj.QueryInterface(Components.interfaces.IMyComponent);
	} catch (err) {
		alert(err);
		return;
	}
	var res = obj.Add(3, 4);
	alert('Performing 3+4. Returned ' + res + '.');
}
</script>
<body>
<button onclick="MyComponentTestGo();">Go</button>
</body>
</html>

One last time: cross your fingers, pray to whatever deity you believe in, and hit the Go button. If it didn’t work let me know why in the comments and I’ll try to build a troubleshooting section.

Hopefully this clears up what looked like a lot of confusion to me. I will keep this updated to the best of my abilities and hopefully it will continue to be useful for a long time.

James Boston: The wiki is the message

James — Wed, 03 Feb 2010 23:10:48 +0000

Today, I attended a Social Media Week event at the Rivoli. Nelson Ko of Citidel Rock gave a presentation, Why You Need To Wiki As Part Of Your Social Media Initiative And How.

Unlike the IN09 conference I attended last year, this event didn't have the same mix of software developers and content creators. Most attendees were the avatars of various non-profits who wanted to see if the wiki could serve their needs.

Free message with every medium!
Ko started with a smattering of theory which is something I love (when I'm not writing an exam). He started with the famous Marshall McLuhan quote: The medium is the message.

McLuhan in my own less succinct words: The technology you use to communicate your message carries its own message, perhaps at a barely audible whisper, but it is one which shapes (or distorts) the message you meant to convey.

Neil Postman's Amusing Ourselves to Death makes the point that the overriding message of television is that everything can be judged as entertainment. No matter what you are watching, you can't help asking, "Is this fun or is this boring?"

Or, more eloquently:

"[It] is not that television is entertaining but that it has made entertainment itself the natural format for the representation of all experience. […] The problem is not that television presents us with entertaining subject matter but that all subject matter is presented as entertaining."
— Neil Postman, Amusing Ourselves to Death

But what is the message of wiki media? Mr. Postman, set me up:

"[M]ost of our daily news is inert, consisting of information that gives us something to talk about but cannot lead to any meaningful action."
— Neil Postman, Amusing Ourselves to Death

Well, the information in a wiki is actionable. If you can't do anything with it (and in the case of sites like WikiHow you can) then you can at least do something to it.

Ko talked about divergence and convergence — the difference between broadcasting something (traditional publishing) or collaborating on something (social media). I'm not going to repeat the whole presentation, but I thought he made an interesting point here about most collaboration tools being at the personal end of a personal-public continuum such as email or the telephone. Wikis are something new in that they are public.

Carrot sticks!
Ko's presentation was free flowing with lots of Q&A interspersed. The audience seemed most keen to learn how to guide and motivate users to contribute. (I'm sure that marshaling the efforts of volunteers is a paramount problem for any non-profit.) Ko had a slide about the various carrots and sticks that typically motivate people, which I jotted down:

reputation and recognition
social and networking benefits
scratching an itch
hobby, enjoyment or personal interest
obligation from ethics or conscience
compulsion or threat of explusion
swag
money

I personally think reputation and recognition are the big motivators is social media. People "play" wikipedia or digg much like they play WoW. You are always trying to level up. But that's just my take. The rest of the list is fairly self-explanatory, except for compulsion which left me scratching my head. Unlike obligation (Wikileaks), I can't think of wiki where compulsion is the prime motivator.

Ko warned would-be wiki curators not to make contributing into a chore.

"Don't characterize it as work," cautioned Ko. "It ruins the atmosphere."

There was also another item from the slide, "learning by doing", which I omitted. This pertained to the question of guiding as opposed to motivating. I omitted it because the consensus seemed to be that there is no easily repeatable way of teaching users how to contribute. There are repeatable methods for inviting people into the community, but training them to be productive is always an ad hoc effort.

At least that's what I heard. I hope someone else blogs the event. I want to know what other people thought.

Aaron Train: Dabbling in Cocoa/iPhone SDK

Aaron — Thu, 28 Jan 2010 01:17:50 +0000

As I gear towards graduation at Seneca College, I am actively engaged in an a professional Apple Development course. Why am I enrolled? Merely an interest for learning different languages; discovering their quirks, oddities and normalities. As well, I am using this astute scenario to experience the procedures and protocol in developing software on a mobile device. Nonetheless, the course should be fun and a unique learning opportunity.

As part of my first lab, we were to get a feel for the different interface builder UI objects within a single view in order to create a manipulating student profile. See below.

Josh Matthews: Dealing with mercurial patch queue rejects in emacs

Josh Matthews — Thu, 28 Jan 2010 00:13:10 +0000

Since Mozilla has embraced mercurial, and especially patch queues, with open arms, I get to deal with rebasing patches frequently. There are two ways this can happen – either you set up an external merge tool like meld to handle each conflict, or the rejected changes are dumped in a filename.ext.rej in the same directory as the file being patched. Since I do all of my work in emacs, I’ve finally got around to writing an elisp function to allow me to switch to a reject file from the original quickly and painlessly:

(defun switch-hg-reject ()
(interactive)
(let ((other-file
(if (string= (substring (buffer-file-name) -4 nil) ".rej")
(substring (buffer-file-name) 0 -4)
(concat (buffer-file-name) ".rej"))))
(if (file-exists-p other-file)
(switch-to-buffer (find-file-noselect other-file))
(message (format "No alternate reject file found" other-file)))))
(global-set-key (kbd "C-c r") ’switch-hg-reject)

A simple C-c r is all it takes to switch from nsFrameLoader.cpp to nsFrameLoader.cpp.rej in the current buffer, and another C-c r will take me back to the original. Now that’s convenience!

Josh Matthews: Make ye a hydra

Josh Matthews — Wed, 27 Jan 2010 10:32:20 +0000

I’m interested in playing around with Dehydra to see whether I can create a pre-review checker, hopefully to lessen the amount of nits that inevitably crop up in any patch submitted on Bugzilla. However, as always, the immediate hurdle is acquiring and building the software involved. Making dehydra from scratch involves building gcc 4.3.x, SpiderMonkey 1.7+, and dehydra itself. The instructions in the dehydra README gave me good, error-less instructions for gcc, and installing SpiderMonkey was nothing more than ./configure ; make ; sudo make install. Building dehydra was a bit hairier; here’s my final sequence of steps:

export CXX=/home/t_mattjo/src/gcc-dehydra/installed/bin/g++ ./configure --js-libs=/usr/local/lib --js-name=js_static --js-headers=/usr/local/include/js/ make

Of course, I also had to go into the Makefile and add -lstdc++ because I kept receiving this error while trying to use the generated gcc_dehydra.so (thanks bradh!): /home/t_mattjo/src/gcc-dehydra/installed/bin/../libexec/gcc/i686-pc-linux-gnu/4.3.4/cc1plus: symbol lookup error: ./gcc_dehydra.so: undefined symbol: _Znwj

So after all that, make check almost passes everything. I’m running into the same six errors that Roger Dicke got a few days ago, so I might try digging into that. However! I can hopefully start playing with static analysis soon, and that’s a very exciting prospect.

Update: the treehydra problem is a known regression in Spidermonkey trunk.

Adrian Kalla: Please don't kill the existing extension eco-system

Sun, 10 Jan 2010 17:18:54 +0000

After reading Mike Connor's blog post about in fact forcing extension authors to use JetPack and theme authors Personas, I'm horrified: That's killing of what have made Mozilla and Firefox so successful - extending the application in *ANY* possible way. That includes extensions implementing features *no one was thinking of before*.

I have learned the downsides of writing XUL and JS based extensions. JetPack may help authors of smaller extensions, but bigger ones require, and will always require, more. So please: let every extension author decide if he wants to use JetPack or the current way of writing extensions. Don't replace the "old way" entirely by JetPack!

Brandon Pung: Bpung.com redesign launched!

Brandon Pung — Wed, 30 Dec 2009 06:26:56 +0000

Today marks the launch of the redesigned bpung.com. The site contains information about myself and the projects that I’ve contributed to, along with this blog. I’d like to thank Matt Huang for advising me on which tools to use in the construction of the site, as well as helping me tweak the desig...

Aaron Train: HTML5 Canvas/getImageData and the nefarious

Aaron — Fri, 18 Dec 2009 22:15:38 +0000

This afternoon, I indulged myself by returning to my HTML5 experimentation and tinkering, toying with the canvas element by testing the waters of different functions under the HTML5 specification API.

All was good until I got to getImageData(), where I encountered an exception in console. The crux is this: I’m getting an NS_ERROR_DOM_SECURITY_ERR error when trying to run context.getImageData()

A bit about getImageData():

To obtain an ImageData object containing a copy of the pixel data for a context, you can use the getImageData() method:

var myImageData = context.getImageData(left, top, width, height);

Ultimately, I wanted to use this function to place a image on canvas and perform some direct pixel manipulation; perhaps inverse an image by first getting the image data from a context.

window.addEventListener('load', function () {
  var canvas = document.getElementById("canvas");
  var ctx = canvas.getContext("2d");
  var img = new Image();

  img.addEventListener('load', function () {
    var x = 0,
      y = 0;

    ctx.drawImage(this, x, y);

    var imgd = ctx.getImageData(x, y, this.width, this.height);
    var imxpxl = imgd.data;

    for (var i = 0, n = imxpxl.length; i < n; i += 4) {
      imxpxl[i] = 255 - imxpxl[i]; // red
      imxpxl[i + 1] = 255 - imxpxl[i + 1] // green;
      imxpxl[i + 2] = 255 - imxpxl[i + 2] // blue;
      // i+3 is alpha
    }
    ctx.putImageData(imgd, x, y);
  },
  false);
  img.src = "http://www.google.ca/intl/en_ca/images/logo.gif";
},
false);

Running this code, I didn't get the results I expected. In fact, I did not think out of the ordinary was incorrect, until I checked the error console and found:

Error: uncaught exception: [Exception... "Security error"  code: "1000" nsresult: "0x805303e8 (NS_ERROR_DOM_SECURITY_ERR)"  location: "file:///pixeldata.html Line: 16"]

Interesting - why the need to raise privileges? Am I forgetting something here? If I toss a,

netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");

I end up with something yucky like this

try {
  try {
    imgd = ctx.getImageData(x, y, this.width, this.height);
  } catch(e) {
    netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
    imgd = ctx.getImageData(x, y, this.width, this.height);
  }
} catch(e) {
  throw new Error("unable to access image data: " + e);
}

but, running the code will yield:

A script from "file://" is requesting enhanced abilities that are UNSAFE and could be used to compromise your machine or data:

In this case, the code will run - but it will leave you with an impression that what you're doing is wrong.

I'm not nefarious, I swear! No intent to do harm here. I am trying to understand the reasoning and or need for raised privileges just to extract data from a context. With a write to canvas, a nefarious user could write something nasty to context, but why with getImageData?

- Aaron

Anant Narayanan: Figuring out the Goo.gl API

Anant — Mon, 14 Dec 2009 23:11:52 +0000

UPDATE: ‘Fatalis’ has pointed out in the comments that the POST should be made to http://goo.gl/api/url with User-agent set to ‘toolbar’. The code now works, Yay!

Google just announced their own URL shortening service. Their service can only be used from the toolbar or FeedBurner, and I don’t particularly like adding extra toolbars to my browser. Maybe I can figure out a way to use their service from the command line?

I downloaded the toolbar XPI, unzipped it and peeked inside. Horribly indented JS awaited me. Nothing jsbeautifier couldn’t fix though. Few minutes later, I arrived at this readable JS function:

var getUrlShorteningRequestParams = function (b) {
    function c() {
        for (var l = 0, m = 0; m < arguments.length; m++)
          l = l + arguments[m] & 4294967295;
        return l
    }
    function d(l) {
        var m = String(l > 0 ? l : l + 4294967296);
        for (var o = 0, n = false, p = m.length - 1; p >= 0; --p) {
            var q = Number(m.charAt(p));
            if (n) {
                q *= 2;
                o += Math.floor(q / 10) + q % 10
            } else o += q;
            n = !n
        }
        m = m = o % 10;
        o = 0;
        if (m != 0) {
            o = 10 - m;
            if (l.length % 2 == 1) {
                if (o % 2 == 1) o += 9;
                o /= 2
            }
        }
        m = String(o);
        m += l;
        return l = m
    }
    function e(l) {
        for (var m = 5381, o = 0; o < l.length; o++) m = c(m << 5, m, l.charCodeAt(o));
        return m
    }
    function f(l) {
        for (var m = 0, o = 0; o < l.length; o++) m = c(l.charCodeAt(o), m << 6, m << 16, -m);
        return m
    }

    var i = e(b);
    i = i >> 2 & 1073741823;
    i = i >> 4 & 67108800 | i & 63;
    i = i >> 4 & 4193280 | i & 1023;
    i = i >> 4 & 245760 | i & 16383;

    var h = f(b);
    var k = (i >> 2 & 15) << 4 | h & 15;
    k |= (i >> 6 & 15) << 12 | (h >> 8 & 15) << 8;
    k |= (i >> 10 & 15) << 20 | (h >> 16 & 15) << 16;
    k |= (i >> 14 & 15) << 28 | (h >> 24 & 15) << 24;
    j = "7" + d(k);

    i = "user=toolbar@google.com&url=";
    i += encodeURIComponent(b);
    i += "&auth_token=";
    i += j;
    return i
};

So, I call getUrlShorteningRequestParams("http://www.kix.in/"); to get "user=toolbar@google.com&url=http%3A%2F%2Fwww.kix.in%2F&auth_token=78925814685". I see in their code that they do a POST request to the service to obtain a JSON return value that would contain the short URL. I punch it in using cURL:

$ curl -v -d "user=toolbar@google.com&url=http%3A%2F%2Fwww.kix.in%2F&auth_token=78925814685" http://goo.gl/
* About to connect() to goo.gl port 80 (#0)
*   Trying 74.125.19.102... connected
* Connected to goo.gl (74.125.19.102) port 80 (#0)
> POST / HTTP/1.1
> User-Agent: curl/7.19.7 (i386-apple-darwin10.2.0) libcurl/7.19.7 OpenSSL/0.9.8l zlib/1.2.3
> Host: goo.gl
> Accept: */*
> Content-Length: 77
> Content-Type: application/x-www-form-urlencoded
>
< HTTP/1.1 405 HTTP method POST is not supported by this URL

Oops! Well, not really, the URL shortener from the toolbar doesn’t work either, I just get the full URL whenever I try to “share” something. Has anybody actually generated a real goo.gl short URL yet?

Their auth_token parameter seems completely superfluous to me as it is generated from the URL itself. Don’t we all know security by obscurity doesn’t work

Wei Zhou: From dating experience to real identity crisis of the web

weizhou — Fri, 11 Dec 2009 23:07:48 +0000

If anybody cares, I haven’t access my blog, facebook, twitter, IM and any other social media for exactly one month. During this period I asked myself one single question: what does humanity really mean today on the web? What is the biggest challenge here for the next generation’s user experience design?…

One month ago my best friend’s fiancee broke up with her because an article on the 10th page on Google’s search engine under her name: A highly manipulated article accusing her irresponsible behavior in terms of relationships with her ex. And it turned into a deal breaker. My friend’s dream of marrying in a rich family is officially over. Now look at what fashionable girls do for dating : You meet someone in the bar, you Google his name, you ask your personal lawyer to count how much money he make..and then you choose if you go out a date with him. Google becomes our biggest obstacle of finding true love.

Yeah we don’t do this 5 years ago. Now we blame the internet gets to transparent to ban us making any mistakes. Today we are not who we really are, we are what google says who we are. Everything is openly connected and we’ve been trying so hard to make things open: making browsers more open, more social and more you, making everything connected, making open IDs. Suddenly we found out: The more we try to design for “you”, the less “you” can express yourself freely. Maybe it is time for the UX designers to make the user experience less open, more humane. And you know what’s ironic: it costs three years to make everything, but it might cost more than three decades to make the openness disappear.

When we talk about user experience, we always say we are engaging in making people’s life better. Nowadays we’re even trying to embed the most intricate and sophisticated human emotions into the consideration of design: like religious needs and sexual needs. However we designed a huge system that ignore the most basic one: The need to lie. Or they need the freedom to lie. If we are really aiming to design a YOU centric web, this question becomes unavoidable and probably be the hottest one in the next 10 years: How do we design a web that people can have real freedom within?

The web has changed, thus you have changed. But I know I love the world better before Columbia found the new land – when things were harder but full of unknown hope and inspiration.

Wei Zhou

Pejman Pour-Moezzi: Hello world!

admin — Mon, 23 Nov 2009 07:56:45 +0000

Welcome to WordPress. This is your first post. Edit or delete it, then start blogging!

Anant Narayanan: Go: Why I ♥ Google

Anant — Wed, 11 Nov 2009 03:23:56 +0000

Christmas came early this year.

Today, Google announced their new open source systems programming language: Go. I’m super excited about this, we all have been wondering what Rob Pike has been upto since he joined the big G, and now we know. Not just that, but Ken Thomson, Robert Griesemer, Ian Taylor and Russ Cox were all involved in the project, with Ken doing what he does best, writing compilers in lightning speed If that isn’t a list of heavyweight respectable computer scientists, I don’t know what is!

I think Go is poised to be the dominant systems programming language of the future. Go has nailed almost every aspect of a systems language, though some would say I’m biased. Go has been strongly influenced by Oberon, CSP languages like Limbo, and the standard libraries have tantalizing similarities to Plan 9. We’ve had Limbo and Plan 9 for a while now (more than a decade), but this is where my real love for Google begins to bubble, they took something awesome but unpopular and gave it a push to the masses. There are very few companies in the world who would attract the talent to do this, and even fewer who would open source the results. The attention Go has been getting is just mind blowing. Pike had been doing amazing work at Bell-Labs for quite a while, but none of it even got an inkling of the publicity Go is currently getting.

Google was what Pike needed to prove Utah2000 wrong.

I know one thing for sure, I’ll definitely be using my Plan 9 virtual machine a lot less; now that I can write clean concurrent programs that don’t make my head hurt, both in Linux and OS X. And GCC, I’m not shedding any tears while I bid you goodbye.

On another note, Google also announced today that they’ll be sponsoring free WiFi at a whole bunch of US airports this holiday season. For all its faults, Google definitely seems to be doing the right thing. For how long, it remains to be seen, but so far I’d say their track record has been better than excellent.

UPDATE: John Gruber points out that “judging from the copyright statements, [Go is] not an official Google project”. Could this be a result of the famous 20% time scheme?

Aaron Train: ‘Stymied From Experimentation’ – Firefox ‘View Page Source’

Aaron — Sat, 07 Nov 2009 17:15:38 +0000

Firefox’s – ‘View Source’ component sucks. It must improve.

Upon reading the WebMonkey article, “After Five Years on the Web Firefox Preps for the Next Round“, I was reminded of a suppressed annoyance, or ‘beef’ I have with Firefox through reading Jonathan Nightengale’s statement.

“When a developer loses the ability to view a web page’s source code (something you can’t easily do in Flash) they can’t see how web applications and complex interactions function. And, he says, that stymies further experimentation”

Jonathan is absolutely correct. Developers need the ability to learn from each other and the only best way to do this is through viewing a web page’s source code. View Page Source is a door to undiscovered knowledge on the web.

Ah yes, ‘View Page Source’.

See, in order to boast and fully support this idea, I believe that developers need to have access to the best tools available. Developers need to harness these tools and utilize them to their fullest potential. These tools should exhibit engaging yet intuitive functionality and rewarding characteristics.

See, my ‘beef’ is with Firefox’s ‘View Page Source’. It sucks. It’s really bad. It’s archaic. In-fact, here are 200 bugs spanning multiple years pertaining to the simple view-source component in Firefox.

Here’s my personal listing of ideas to improve View Source with 5 improvements:

Introduce proper syntax highlighting (crucially needed with the new HTML5 parser)
Links should have copy link location in the context menu
Line numbers should appear in a side column
Add view-selection-source ability
Interface should be tabbed!

With many of those 200 (simple query search of ‘View Source’) filed as enhancements, it’s clear that the view-source component needs a complete overhaul.

I believe that Firefox needs to revamp it’s view-source component in order to supply developers with the best tools necessary to prevent a case of being stymied from experimentation and any other further barriers of innovation on the web.

Developers need the best tools out there, and I feel that they are left out of what could be an awesomely improved component and uniquely defined characteristic of the entire Firefox experience.

Currently, I dont think there is a significant drive towards prioritizing this component in the browser. In fact, I dont think it has been touched in many years. It certainly feels archaic, sluggish and lacking. Has the code been touched in years?

So I ask the community, you reading this, do you wish to collaborate to revitalize this dying dead horse?

What do you think?

Anant Narayanan: Identity on the web is broken

Anant — Tue, 03 Nov 2009 03:08:27 +0000

The mere presence of systems like OpenID, Facebook Connect and a host of other identity services on the web today is attestation to the fact.

Authentication should be a feature of the protocol, not something that relies on hacks like cookies. 99% of websites today rely on cookies for authentication for their websites, besides offering custom registration and login pages. This means the browser, as the user’s agent, has no clue of what is going on. A user is forced to manually track myriads of accounts, remember passwords for each of them, and remember what personal information each of them holds. Sure, part of the problem is solved by using password managers (like the one in-built into Firefox, or external programs like 1Password), but even these programs rely on heuristic algorithms to determine if something looks like a login credential or not. There’s no explicit way for web pages to tell your browser: “This is a login form, please fill in details of the user’s identity here” or “These pages are privileged, please give me the user’s identity”. Why is that?

Actually, there is such a mechanism: HTTP based Authentication has been a feature present since HTTP/1.0, but only 1% of sites actually use it. The reason for that is purely cosmetic, most browsers display a very bland modal dialog when it encounters a page that requires HTTP Auth, and sites are unable to customize that interaction. So, the technically right way to do things sucks from a user experience perspective, and websites started adopting alternate means. Someone discovered they could use cookies to store session information on the client, and the whole situation exploded ever since. As a programmer, I feel very sad when I think about the fact that instead of fixing the problem in HTTP/1.1, web-based authentication took the route it did and led to the mess we are in today.

However, I must also state that HTTP authentication doesn’t solve the entire problem – there is still the issue of users having to create an account for every site they want to be part of. This is because there existed no protocols to federate and provide decentralized authentication. That is, until OpenID and OAuth came about. Now we’re at this exciting juncture, and the browser is in a unique position to use these tools together to provide the user with an experience that is secure and easy to use. Every architect will agree that it is indeed a fun challenge to use the state of identity on the web today and make it into something awesome.

This is precisely what the Mozilla Labs team has been thinking about for a while now. Sometime ago, we added support for automagic one-click OpenID logins to Weave. We plan to spin that “feature” out into it’s own extension and build on it, something we call “Weave Identity“, part of the broader “Open Identity” initiative by the Labs. “Weave Sync“, the original extension, will just focus on the synchronization parts so we can tackle these two different problems separately.

So, how exactly are we planning on doing this? Take a look at an initial version of a document describing an in-browser “Account Manager“. We’ve also put up a WEP (which expands to Weave Enhancement Proposal, by the way) describing the raw form of a specification for automatic actions on websites, such as user registration or password changes.

Keep in mind that all of this is in its very early stages (pre-alpha); but that also means it’s a great opportunity for the community to get involved! What are your thoughts on Open Identity? Use the discussion tab on any of those Wiki pages, start a thread on the Mozilla Labs group, or simply leave a comment on this blog entry, and chip in – we’d love to hear from you!

Anant Narayanan: GSoC Mentor Summit ‘09 Roundup

Anant — Sun, 01 Nov 2009 18:17:18 +0000

The grand Summer of Code Mentor Summit of 2009 concluded last week and I had the fantastic opportunity of being able to attend on behalf of Gentoo, Plan 9 and Mozilla. What follows is some indication of how awesome the summit was:

(Photo courtesy of warthog from Etherboot)

I met so many folks I’d only interacted with online so far (the classic nickname-to-face matching), but even better was the opportunity to meet folks powering open source projects from so many diverse backgrounds. I met many of my personal rockstars, and learned about a bunch of open source projects I’d never heard of

Also, one of the things that is only possible at an event like the summit was the ability to get a whole bunch of non-linux operating system groups in one room. We had a great discussion, and it resulted in the creation of the “rosetta-os” special interest group. Look for more activity on the common device drivers for non-linux operating systems front soon!

Other sessions worthy of special mention were Open Source Security, Recruiting and Retaining Awesome People, Advanced Trolling (yes, you read that right), and of course the always welcoming Casablanca where I spent most of my time. We discussed everything from our SoC experiences to the Afro Celt Sound System in that room, always full of creative energy and warmth.

After 4 years of participating in the Summer of Code, I am super happy to have finally met the faces behind the program. Every single person I met over the course of last weekend was friendly, intelligent and just generally awesome; that sort of thing doesn’t happen by chance. I feel warm and fuzzy inside to think that I’m actually a part of the revolution that is free and open source software, three cheers to everyone that made it possible!

Aaron Train: FSOSS 2009 – So many choices

Aaron — Thu, 29 Oct 2009 01:56:15 +0000

As part of Toronto Open Source Week, tomorrow marks the start of the 8th annual Free Software and Open Source Symposium at Seneca College

With a vast range of academically intriguing presentations and focused based hands-on workshops to choose from, I have narrowed down a listing of presentations that I will attend to.

Thursday
09:00 AM	Automating UI Testing with Mozmill
Friday
10:00 AM	Ranking the Bugs: Predicting Which Bugs Will Get Fixed
11:00 AM	Open Source Licensing Demystified
1:00 PM	Coping at the Scale of Mozilla: How Mozilla uses Open Tools to Manage Complexity
2:00 PM	Open Source for fun and profit: making a career out of FOSS
3:00 PM	3D in the browser… more than just Doom

Bring on tomorrow – I hope to see you all there :)</pr>

Anant Narayanan: How does Weave use Cryptography?

Anant — Sun, 11 Oct 2009 15:26:53 +0000

I’m back from the EU MozCamp in Prague and we all had a great time! Check out the slides from my talks: Labs Overview and Weave in Depth.

A few people at the MozCamp were interested in Weave’s use of cryptography to protect the user’s data and privacy. Although the specs for the Weave server are available, it may take someone new a while to wrap their head around the whole scheme. I’m going to attempt explaining what crypto operations we do and why we do it in this blog post.

First, let’s get some basic definitions out of the way. Symmetric cryptography means you have one key that can perform both encryption and decryption, and they are complementary operations. For Weave, we use AES with a 256 bit key, and we use it in a mode that requires an ‘initialization vector’ for every decryption. Asymmetric cryptography means there’s a pair of keys (usually called ‘public’ and ‘private’ keys). A piece of text “encrypted” by one key can only be “decrypted” by the other key. Here, we use RSA with a 2048 bit private key.

So, when a user first signs up for Weave using the wizard on their computer, we generate a (random) pair of public and private keys. Next, we use the user’s passphrase to create a symmetric key. This is done using a pretty standard algorithm known as PBKDF2 (short for “Password Key Derivation Function”). The PBKDF2 algorithm requires a ’salt’ value which is also stored on the server. Now that we have a symmetric key, we use it to encrypt the user’s private key and upload it along with the public key to the server. Note that the passphrase is never sent to the server, so if the user’s password ever gets compromised all the attacker can get is their encrypted private key, which really isn’t of much use (especially given that the key is 2048 bits long).

Whenever a particular “engine” is to be synchronized (an engine could be Tabs, Bookmarks, History etc.) we generate a random symmetric key for that engine. This key is then encrypted using the user’s public key (now, one can only retrieve the original symmetric key with the corresponding private key) and uploaded as being associated with a particular engine. All entries (the ‘ciphertext’ property in a “Weave Basic Object”) in that engine are encrypted with the symmetric key that was generated for it.

To make things clear, let’s enumerate the steps we would take to decrypt a single tab object for user ‘foo’:

Find the user’s cluster by making a GET request to https://services.mozilla.com/user/1/foo/node/weave. It returns https://sj-weave06.services.mozilla.com/.
Fetch the user’s encrypted private key and public key from https://sj-weave06.services.mozilla.com/0.5/foo/storage/keys/privkey and https://sj-weave06.services.mozilla.com/0.5/foo/storage/keys/pubkey respectively. The user’s password is required to access these JSON objects.
Ask the user for their passphrase and generate a 256 bit symmetric key from it using PBKDF2 and the ’salt’ found in the privkey object.
Use the generated symmetric key and the initialization vector found in the ‘iv’ property of the privkey object to decrypt the user’s private key.
Fetch the user’s encrypted tab objects from https://sj-weave06.services.mozilla.com/0.5/foo/storage/tabs/?full=1.
Fetch the corresponding symmetric key (the URL is also listed in the “encryption” property of every WBO), in this case https://sj-weave06.services.mozilla.com/0.5/foo/storage/crypto/tabs.
Decrypt the symmetric key with the user’s private key.
Use the decrypted symmetric key to decrypt any WBO from the tabs collection with the initialization vector found in the ‘bulkIV’ property of the tabs symmetric key WBO.
Profit.

A word about the formats in which the keys are actually stored in. All values are Base64. For symmetric keys, the key is stored as-is. For asymmetric keys, I wish we used a standard format like PKCS#12, but we don’t. It’s still ASN.1 though, in some format NSS exports private keys in. You need to do a bit of ASN.1 parsing to figure out the values you’re interested in.

Fortunately, I’ve already figured out most of the details for you – check out my Javascript or PHP implementations of the crypto elements required to decrypt Weave Basic Objects.

Finally, a quick note about why we do all this. Sharing is now reasonably easy, if you want to share your bookmarks with someone, you just need to encrypt the corresponding symmetric key with their public key and they’re good to go. Also, each WBO has it’s own ‘encryption’ property so this can be as granular as needed. Secondly, the passphrase is never stored anywhere (except possibly on the user’s computer) so the server never sees anything other than encrypted blobs of Base64′ed text. Along with making HTTPS mandatory, we think this is a pretty secure way of protecting the user’s data.

If you have other encryption schemes that might fit into Weave’s use cases please let us know! (We’ve already been looking at interesting developments in this area such as Tahoe). I’d also love to hear from you if you have any questions on our current cryptography scheme. We’re constantly trying to improve the security and efficiency of our system so these details are only valid until we change our scheme

Now, go write that third-party Weave client, you have no excuse not to!

Adrian Kalla: Koala at the MozCamp Europe in Prague this weekend!

Sat, 03 Oct 2009 11:30:34 +0000

Tomorrow at 10 am we will present the Koala - Komodo Advanced Localization Addon - project. If you are in Prague at the MozCamp, you'll will have a great opportunity to learn more about it.

Florian S. and I are already there, so if you have some feedback or questions - don't hesitate to talk with us.

Aaron Train: Toronto Open Source Week 2009

Aaron — Thu, 01 Oct 2009 20:43:09 +0000

October 24-30, 2009

Toronto Open Source Week is a celebration of Open Source technology and community throughout the Toronto area. The following events have been confirmed; additional events are being planned.

Saturday, October 24	Ontario Linux Fest
Monday, October 26	Open Source Showcase for Non-Profits
Tuesday, October 27	FOSSLC – Web programming bootcamp
Thursday, October 29	Free Software and Open Source Symposium – Workshops Teaching Open Source Summit
Friday, October 30	Free Software and Open Source Symposium – Presentations

Anant Narayanan: Heading to Prague…

Anant — Thu, 01 Oct 2009 05:50:09 +0000

I’m off to the beautiful city of Prague, or “Praha” as it is known locally, for the European MozCamp of 2009. Memories from the MozCamp last year are still fresh, and I’m definitely looking forward to this one!

On Friday, we’re going to be hosting a Labs Hackathon on Jetpack. This is your chance to get to know more about the framework that’s so easy to use that your mom could write an extension with it. Maybe not your Grandma though, you do need to know a bit of Javascript The hack session will last as long into the night as needed for you folks to come up with amazing ideas for Jetpacks and implement them. Drew Willcoxon from the Firefox team and I will be on hand all day to help you, so feel free to come and poke us. Oh, I almost forgot to mention that there’s Free Pizza involved.

On Saturday, I’ll be giving a talk on Weave. With 0.7 just released, we’ll be taking a look at our current state, what’s in store for the future, and maybe a few cool demos. We’re also especially interested in engaging with addon developers to see what Weave can do to make it easier for them to add sync functionality to their addons.

Be there!

Aaron Train: Code Friday’s #1

Aaron — Sat, 26 Sep 2009 00:43:36 +0000

It’s Friday evening and I’m too lazy to check the television for the Toronto Blue Jays score. Yeah yeah, nothing a little script can’t handle.

lynx -nonumbers -nolist -dump http://m.4info.com/search?searchQuery=Toronto | egrep -i -B2 -A4 "Status"

   Toronto Blue Jays (75-84)   (R) 4    (H) 5    (E) 0
   Baltimore Orioles (61-98)   (R) 7    (H) 9    (E) 0
   Status:  Top5th  B: 2 S: 2 O: 0
   Start Time:  10/02 7:05 PM ET
   Pitching:  Jason Berken (0K)
   Batting:  Kyle Phillips (0/1)
   Man on 1st

Replace the query with whatever team or term you desire; easy :)

Wei Zhou: why you should marry a designer

weizhou — Fri, 25 Sep 2009 19:20:55 +0000

Many facts suggest that you should marry to a designer.

First, designer are smart and constantly optimizing user experiences in their lives. Today designers are no longer artist, almost all of them are tech-savvy and bright. They like solving problems- so they are fully capably of fixing pipes for you; they are curious about everything in the world – your life will be fulfilled surprises. For designers, a string of URL gives them a whole new free toy to play with which immediately makes your life beautiful – they are not nagging like others because they are always playing or making stuff: you’ll have customized everything in your house and hand-made wine, chocolate, card and cake in your wedding anniversary.

Second. Designers are rich. They are born entrepreneurs, that means they are seeking every way of making money with innovative ideas. Don’t be surprised if you know a designer has 6 companies at the same time. Today design has never attracted as much attentions as it used to be – it encapsulates so many levels of skillets; as designers, they are much more powerful than they were: because they are designing business for other people.

Third, designers have freedom. Freelance designer is surely the best job in the world – not only because the nature of design requires the usage of both right and left brain so you won’t risk your other half having high suicide rate as a creative writers or artists, or retiring intelligence of football players. Designers surely look younger because the beauty and harmony they involve with everyday, and yes, as freelancers, they sleep a lot everyday, and if you like, they have the time to pick up kids.

Fourth, designers are happy people. Designers have the best friends. Their clients are passionate and hopeful people with fantastic dreams who believe beautiful design can make a difference in their life – never a change of dealing with desperate and angry clients as lawyers do everyday.

Fifty, designers are family guys and girls. They may like clubbing but never as much as they love their job or their life. They are never wasted as investment bankers do. Designers spend money appropriately because design is the art of balancing limited resource and quality. You’ll find your life quality increased significantly after you live with her/him, with less money, of course.

Yeah, marry a designer, you’ll never be wrong.

Nino D'Aversa: Married, Mozilla and More

Nino D'Aversa — Tue, 08 Sep 2009 20:13:04 +0000

Wow, so it seems I have misplaced my blog this summer. However getting married, moving and taking an epic honeymoon can do that to blogs. It’s been a whirl wind kind of summer, full of change. It’s hard to know where to start, so I’ll start with what matters most.

Being a married man, now for over a month, I can safely say I am both lucky and very much in love. It seems all those years Tasha and I enjoyed as a couple has us well prepared for the life of husband and wife. We have fallen into a wonderfully collaborative effort of eating, cleaning and entertaining. We have both spent a great deal of time preparing our home and we are finally enjoying the fruits of our labour, and it’s fantastic!

When I last blogged my internship at Mozilla had just begun, as I write this I find it came and went too quickly. Opportunity doesn’t always come at the right moment, but you need to seize it nonetheless. I’m so happy that I took the chance to work with Mozilla this summer — even if life had me pulled in too many directions. Spending time in California meeting Stuart, Doug, Mark and others was rewarding. During these last few months I have kept my eyes and ears open and the thing I take most from the experience is how dedicated and passionate they all are. It has inspired me to find that same passion in what I choose to do from now on. I’m spending my time now to take a look at the job market to find what best suits me, my skills and my passions. My home life is already proving to be rather fulfilling and I have decided I will settle for nothing less in my professional life.

I’m choosing to leave this blog post on the shorter side, it’s impossible to catchup with everything that has happened. However, some parting notes, I plan on remaining a contributor to the Mozilla project – the experience can only be surpassed by it’s importance, these are world class developers and I still have so much to learn and contribute.

I also would like to take a moment to thank Silvana from Impulse Photography, she has a track record of producing some of the most unique and creative photography around, and our wedding was no exception. With that I leave you with moments from our big day – Thanks Silvana!

Anant Narayanan: Another summer at Mozilla passes by

Anant — Tue, 01 Sep 2009 03:54:52 +0000

My last day at Mozilla this summer was last Thursday. I didn’t take a lot of pictures this summer, because, you know, I took a lot last time around. Also, this strategy turned out pretty well because now there are more pictures of me floating around on the tubes! After a longish trans-atlantic flight, I’m back in Amsterdam now resuming work on my Master’s (because hacking on Minix is awesome).

No other internship has been ever so satisfying: over the summer, I worked on a wide range of mini-projects which allowed me to exercise skills ranging from systems to application level programming. I even did a bit of work in the mobile space (turns out programming in limited memory and processing speed is a *lot* different).

One such project that I’m especially excited about is support for video recording in the browser. Yes, there is even a canvas-based live preview of your webcam feed, in addition to Ogg/Theora encoding support! Combined with the audio recording support I wrote sometime ago, some really cool applications are now possible. Skype-like dialer in the browser? Why not?! (*hint* anyone is free to send in a patch for multiplexing the audio and video, they’re currently two separate Vorbis and Theora streams *hint*).

We also had 3 major releases for Weave during the summer: 0.4, 0.5 and 0.6. The last one was especially big, given the completely new, HTML based UI (big kudos to thunder for pulling it off!) and a bunch of other performance fixes. Also, the web UI I wrote last year underwent so many great changes by the wonderful folks at Glaxstar. Now we’re putting up a community design challenge to revamp the UI so we can ship the thing! (*hint* if you’re good at UI design you should participate in the challenge *hint*).

There’s so many more cool things I worked on that I’d like to talk about, but perhaps they deserve a separate blog post. Soon… (I keep promising myself that I should blog more often, it never works).

To add the already good times, my two students in the Summer of Code this year passed with flying colors. Yay!

Aaron Train: Wrapping Up an Internship at Mozilla

Aaron — Tue, 25 Aug 2009 05:24:07 +0000

Friday is approaching fast, it will be my last official day as an intern with Mozilla Corporation, but certainly not my last day with the project and overall initiative.

The past four month’s have offered me an an incredible chance to learn, far more than any one job, classroom or book may offer. I have learned a lot; everything from the Mozilla platform to invalidation reference testing to XML User Interface Language (XUL) to reducing test-cases for crashes in the browser to even the vast assortment of brown-bag and meet-up discussions, I have learned a lot. With the knowledge gained, this internship opportunity has been far more rewarding than one could possibly imagine. There is nothing more rewarding than having the opportunity to discover and ascertain and to certainly ask many upon many questions.

Four month’s long, I worked alongside the QA (Execution & Test Dev), (that of which include Clint and Heather) team driving forth many efforts within the world of testing. Over the months, I got to tackle quite a few tricky issues that turned out to require new and unique solutions that I really enjoyed inventing and implementing. The different challenges and testing opportunities were each rewarding as they demonstrated the underlying importance of software testing.

See my parting presentation here for a complete overview (no <iframe/> in WordPress) of the major project I worked on in July/August and the test development areas I worked on in May and June .

That being said, I’m not gone yet. Despite a return to my final year of software development in school, I’ll continue to chip in to the efforts of the QA team and other projects to come, only I’ll be on IRC at a slightly different time of day.

Thanks Mozilla and in particular the friendly folks of QA for the first-rate experience!

Take care Mozilla,

Aaron

Margaret Leibovic: New about:me Page for Firefox!

Margaret Leibovic — Mon, 17 Aug 2009 16:06:51 +0000

This summer I created an experimental prototype of an about:me page for Firefox, and I am proud to announce that it is now available for download as an add-on on addons.mozilla.org!

The goal of the about:me page is to give you a more interesting view of statistics about your browser usage, providing a fun way to see personalized patterns in your interactions with Firefox. The current version includes graphs that illustrate trends in your browsing and downloads histories.

The “Activity Stats” section graphs the websites you visit most, including the individual pages you visit most within each top-level site. This section also graphs your hourly browsing activity, which can reveal patterns in websites you visit most at various times of the day.

The “Downloads Stats” section illustrates the distribution of different types of files you download, as well as daily trends in your download activity.

I plan to continue to develop the about:me page to include more sections from our brainstorming list, such as statistics about bookmarks and tabs. Please let me know if there’s anything you would love to see next!

Michael Sullivan: Inline threading for TraceMonkey slides

sully — Sun, 16 Aug 2009 05:06:32 +0000

Here are the slides from my end of summer brown-bag presentation: http://www.msully.net/~sully/files/inline_slides.pdf.

Matthew Noorenberghe: Doorhanger Notifications: Progress Update 2009-08-14

matthew — Fri, 14 Aug 2009 19:46:34 +0000

Current Progress

worked on API design and features discussed in Aug. 6 meeting
improved initial working prototype

Automatically hiding icon notifications after a delay
Notifications are shown as menu buttons when notification button clicked
More code and UI cleanup

Loose threads

where in the UI should the doorhangers be shown? (need input from beltzner)

Next target

fully working version of doorhangers
ETA August 21, 2009

Brian Krausz: Yet Another Reason Not to Use GoDaddy

Brian — Sun, 09 Aug 2009 17:50:08 +0000

Update: It seems GoDaddy fixed this issue. Glad they fixed it, though I still can’t say I recommend them. Thanks Sean for pointing that out to me.

I recently gave a talk on WordPress plugins at the Boston WordPress Meetup (slides are online on their meetup.com page). During this talk the question came up of which webhost to use. Everyone has their own recommendation of webhost, but the one host that was universally panned is GoDaddy.

I’ve long since moved on from shared webhosts on to VPSes (I’ve been using VPSLink since they started. Use this link to get 10% off for life and snag me a nice referral bonus ), but GoDaddy was my first web host, and since then I have heard nothing but terrible things about their marketing practices, upsells, and other sketchiness. But they will show you videos of women taking their clothes off on their website, which is great if you’re into that sort of stuff, but not what I need from a webhost.

But until recently I never discovered anything actually wrong with their hosting service…it worked, and while it was cheap, they at least delivered what you paid for (though granted, you’re not paying or getting a lot). Yesterday, while looking through some code for a GoDaddy site, I discovered something painfully bad with their service that makes them a terrible idea for any ecommerce site.

It seems GoDaddy doesn’t allow outgoing connections from their shared hosting packages. So, for example, you can’t connect to authorize.net or paypal.com from your server. How do they recommend you accept payments? Send it through some unsecured proxy they have.

That’s right, GoDaddy is actually telling people to send credit card information to another server in unsecured plaintext. They then forward it along and send you the response. There are 2 things wrong with this.

Man in the middle attacks up the wazoo. Not only can someone possible get in between the proxy and your server, but who knows whether or not the proxy requires valid certificates. If not then the entire workflow is vulnerable.
There’s a now a single point of failure for all of that hosting. If that server is compromised, all those sites get compromised too. This is a huge risk.

If I were issuing merchant accounts and knew about this, I wouldn’t accept accounts from anyone hosted with GoDaddy. There are very few reasons for GoDaddy to be doing this. The only one I can think of is preventing the spread of website worms that use holes in website scripts. This is a pretty lame reason to lock websites into their own box, and there are much better ways to stop this.

Aaron Train: Totally hip, totally rad Mozilla QA Companion 1.0

Aaron — Sat, 08 Aug 2009 05:14:44 +0000

Mozilla QA Companion 1.0 Released

Fresh new QA Companion. This version has a revamped design of the former QAC, with functionality for running manual tests, reporting bugs, and viewing the latest QMO news. 1.0 is a vast improvement over 0.2.3!

Download the latest version here

So what is the Mozilla QA Companion (QAC)?

The Mozilla QA Companion (QAC) is a new tool that was created after discussions between the QA team and community about how to make it easier for anyone to get involved with the Mozilla project and help us test Firefox.

The QAC is meant to be an easy way to get community members involved in the QA process. It pulls testcases from Litmus and provides a response form, all within the QAC interface. The QAC also includes notifications for important QA events such as Bug Days, and keeps users up-to-date with live feeds from the QMO site and forums.

Features

General QMO tab — updates on news, forums, etc.
‘Run Tests’ tab — This is the heart of the extension. It allows users to get testcases to run and to submit results from within the extension. QAC will detect most system settings and helps new users set up a Litmus account if they don’t have one already.
‘File Bug’ tab – File bugs by submitting a report!
Settings/Help (Preferences) — This is for the confused or misconfigured.

Installation

You can install the QA Companion like any other Firefox add-on by visiting https://addons.mozilla.org/en-US/firefox/addon/5428

Getting involved with testing and development

Install Mozilla QA Companion 1.0
Run test cases through QAC by interacting with Litmus
Submit bug reports to Bugzilla through issues you find in testcases.
Join us in #qa on irc.mozilla.org

The interface is fairly intuitive and easy to follow, but please let us know if you have any questions. Find us on IRC or post to the QMO forums. We hope you find the Mozilla QA Companion a useful tool that helps you get more involved with the Mozilla QA community!

Thanks!

- Aaron Train, on behalf of the Mozilla QA Companion revamp team

Matthew Noorenberghe: Doorhanger Notifications: Progress Update 2009-08-07

matthew — Fri, 07 Aug 2009 21:51:04 +0000

My second major project this summer on the Firefox team is to implement Doorhanger Notifications. The main goals are to redesign the notification interface to address various issues and to provide a unified notification area for them to be displayed. For now you can read the wiki page for more information. Below is my progress thus far:

Current Progress

lots of code cleanup
decided how to support undo notifications and worked on API design
met with faaborg and dolske to talk about UI design
initial working prototype done

Loose threads

where in the UI should the doorhangers be shown? (need input from beltzner)

Next target

fully working version of doorhangers
ETA August 21, 2009

Margaret Leibovic: Making Firefox Feel Faster

Margaret Leibovic — Thu, 06 Aug 2009 00:25:09 +0000

I recently finished work on a sprint to improve perceived performance in Firefox. Unlike code improvements that actually make the browser faster, perceived performance improvements make the browser feel faster. There is currently a long list of brainstormed ideas for these improvements, but Alex Faaborg identified improving mouse wheel behavior in Windows as a quick way to make the browser appear noticeably more responsive.

In native Windows applications, scroll events triggered by long flicks of the mouse wheel are not distinguished from events triggered by single wheel clicks, which can result in frustratingly slow scrolling when traveling a long distance down a page. Mac OS X, on the other hand, applies an acceleration effect to mouse wheel events, increasing the distance the page moves in response to multiple successive mouse wheel events.

In order to create this acceleration effect in Windows, I wrote some code that changes the way we process mouse wheel events. This code uses some logic and arithmetic to increase the distance the page should move if there are multiple successive mouse wheel events, using the values of three different preferences to determine exact behavior.

mousewheel.withnokey.numlines: The number of lines the page moves with one click of the mouse wheel. This value is used to determine scrolling distance before acceleration computations are applied. Increasing this value will make scrolling feel faster for all types of scroll wheel actions, including individual scroll wheel clicks.
mousewheel.acceleration.start: The mouse wheel click number at which acceleration begins to take effect. This value determines whether or not acceleration computations are applied to a given scroll event.
mousewheel.acceleration.factor: The multiplicative factor used to determine the rate of acceleration. The acceleration computations create a constant acceleration effect, but this value can control the level of acceleration.

These preferences can be configured from the about:config page, and although the default values are not set in stone, they seem to create a reasonable acceleration effect. Feel free to play with these preferences on a nightly build and let me know what you think!

Michael Sullivan: Doing whole tree analysis with Dehydra

sully — Tue, 04 Aug 2009 01:19:40 +0000

Introduction

In this post I discuss how I used Dehydra to do analysis of the entire Tracemonkey tree.

Note

I talk briefly about some Tracemonkey things to motivate what I used Dehydra for, but a knowledge of Tracemonkey is not required to appreciate the main point of this post.

The problem

One of the optimizations in my Tracemonkey inline threading work (Bug 506182), which I will be posting about later, is “PC update elimination”. Doing this requires figuring out which functions out of a certain set can access the JavaScript virtual program counter (which is stored as a variable named “pc” in a class named “JSFrameRegs”). There are about 230 functions in this set, so doing it manually is impractical.

The solution

I used Dehydra to help solve this problem mechanically. Dehydra is a static analysis tool built on top of gcc. It allows the semantic information of a program to be queried with JavaScript scripts.

First steps

By providing a process_function() function in a Dehydra script, I can inspect the variables used and the functions called by every function. Determining whether the pc is used is as simple as seeing if any variable has the name “JSFrameRegs::pc”.

function process_function(f, statements) {
  for each (let v in iterate_vars(statements)) {
    if (v.name == "JSFrameRegs::pc") {
      print(f.name);
      break;
    }
  }
}

The catch

Unfortunately, this isn’t quite what we want. This will tell us which functions directly use the PC, but not which functions can indirectly use it through function calls. Figuring out that requires looking at all the functions called by a given function. This is not straightforward with Dehydra, as functions frequently call functions declared in other files. Dehydra is a gcc plugin and is driven by the normal build system. Thus, it works on a file-by-file basis. Normal builds output an object file for each source file and rely on the linker to stitch it all together. Likewise, to do a whole tree analysis we need to output per-file information and then link it together later.

Collating the data

I reworked my process_function() to determine both whether the PC is directly accessed and the set of functions called directly. This data is then printed with the dump() function (discussed below):

function process_function(f, statements) {
  usespc = false;
  calls = {};

  for each (let v in iterate_vars(statements)) {
    if (v.name == "JSFrameRegs::pc") {
      usespc = true;
    }
    if (v.isFunction) {
      calls[v.name] = true;
    }
  }
  dump(f.name, usespc, calls);
}

The remaining question is how to structure our output. Outputting it as data declarations for some programming language seems like an easy way to do it. Since I am more comfortable with Python than JavaScript, I output the data as Python code:

function dump(name, usespc, calls) {
  s = '@@@';
  s += '\t"' + name + '": ({';
  for (let f in calls) {
    s += '"' + f + '", ';
  }
  s += '}, ' + (usespc ? "True" : "False") + '),';
  print(s);
}

We create a dictionary mapping function names to tuples of the set containing the name of each function called and whether the PC is accessed directly. When doing a build, the output will be intermixed with output from other parts of the build infrastructure, so we tag all of the output lines with ‘@@@’ so that a post-processing shell script can recognize and extract the relevant data.

The relevant bit of the shell script (which is linked below), is:

(echo "callgraph = {";
cd "$DIR" && make -s CXX="$CXX" 2>&1 | grep ": @@@" | cut -d@ -f4-;
echo "}")

This data gathering method could easily be modified to analyze different problems. For simplicity, I extracted only the relevant information and converted it directly to Python data structures. Another approach would be to dump all of the function information (probably in JSON), allowing a later analysis script access to everything.

The analysis

I wrote an analysis script in Python to process the data. The input is a large dictionary, mapping functions to the set of functions they call and whether they touch PC directly.

I viewed the problem in terms of graph theory. The mapping from functions to the functions they call is simply a directed graph. Each function is a node and there is a edge from a function to each function that it calls. In this graph, some nodes (those that touch the PC) are initially marked. We want to color red every node that has a path to one of the initially marked nodes.

Another way to state this is that a node is colored red if and only if it is either initially marked or has an edge to a red node. Doing the coloring is a simple problem. We simply compute the reverse graph (reversing all of the edges) and then perform a depth first search of the reverse graph starting from the marked nodes. Every node we see, we color red.

When doing the DFS, we keep track of which node we first reached a newly colored node from, so that we can determine a path back to an initially marked node.

My implementation also supports providing a predicate to exclude certain nodes from the search, in order to investigate how fixing certain functions to not require the PC would change things.

Caveats

While my method is useful, it is not perfect. It can produce both false positives and false negatives.

False negatives result from polymorphism in the form of virtual functions and function pointers. When a call to such a function is made, there needs to be an edge from the caller to all of the functions that could be called. For virtual functions, this is all functions overriding the virtual function. For function pointers, I think this is every function of the proper type that is used in a way that it not a call at some point. It should be possible to address this problem, but at a significantly increased complexity compared to what I have. Fortunately for me, Tracemonkey does not use virtual classes much and does not use function pointers in places where it matters for my analysis.

False positives are a little trickier, and can’t be worked around in general. Consider the following:

void foo(bool bar) {
    if (bar)
        // access the PC
}
void baz() { foo(false); }

Calling baz() will not result in the PC being accessed, but my analysis will report that it can access the PC (since foo() can). Knowing whether a function can actually cause the PC to be accessed is isomorphic to the halting problem and thus undecidable.

The code

My code is available here. make_callgraph.sh expects to find g++ and Dehydra under ~/gcc-dehydra/, as suggested in the Dehydra installation instructions. make_callgraph.sh must be run with its output redirected to callgraph.py. search.py contains both the general search algorithm and code that uses it to analyze functions introduced in my inline threading patch.

Pejman Pour-Moezzi: The unbearable heaviness of mobile applications

Pejman — Tue, 04 Aug 2009 00:50:29 +0000

There’s an app for this and there’s an app for that – we get it. And with the iPhone app store sporting figures like 1,000,000,000 downloads and 50,000 different apps it’s easy to call such a platform a runaway success. However after reflecting on my own usage of mobile apps, I’ve concluded one thing – the user experience sucks*.

A friend recently asked me how many iPhone apps I use regularly. My response: 2.

Facebook and Tweetie are really the only apps I use. A couple months ago I even took the unnecessary step of deleting all the apps that were collecting dust on my iPhone, simply because I got tired of looking at them. I’m not the only one like this. A recent study found that 20 days after download only 5 percent of apps are used.

So what’s wrong here? My view: It’s partly the apps but mostly it’s the app store. It’s too heavy. Let me paint you a picture.

* My intention is not to single out the iPhone here. I mean mobile applications in general (e.g., iPhone, Android, Palm, etc.)

A day in the life

I’m wandering around a Best Buy (see hypothetical) and am having trouble locating Blu-Ray players. While I could go ask someone for help, I decide to pull out my trusty smart phone instead (here an iPhone). Here are the steps I have to go through:

Click App Store
Search “Best Buy”
Review app list & select the official Best Buy app
Wait about a minute for the download to finish over 3G
Launch the Best Buy app and wait for it to load
Find Blu-Ray devices

Finally I’m presented with a Blu-Ray page and what are my options?

“View Online.”

Two major issues here:

1) Wow, that was a lot of work.

2) I’m standing in a Best Buy and the Best Buy app is telling me to shop online.

I, of course, am operating under an assumption here. Namely, mobile applications should enhance my physical environment. That’s the difference between a desktop app and mobile app for me. While a desktop app is immersive and provides its own context, a mobile app is auxiliary and responds to context. Mobile apps that don’t fit this bill are simply desktop apps fitted to small screens – ubiquity with no added utility.

Unfortunately, mobile app stores are designed for these types of apps. The arduous setup process, discoverability and, more fundamentally, the notion of an “application” itself are hindering true innovation in the mobile space.

So, let me paint you another picture and present three concepts that illustrate a different approach.

#1 Transitory not transactional

App stores are geared towards transactions. You browse, buy (sometimes for free), and keep goods (applications). In the Best Buy example, I not only stood in the store for almost two minutes before realizing that the application wouldn’t help me but I now had a Best Buy app sitting on my phone. I visit a Best Buy next to never – so why is it still there?

Same thing happened when I downloaded a French dictionary to use in France and a snow report application while in Tahoe. Months later those apps (and their many updates) were still in my face. This is poor design in that it forces a transactional framework onto a transitory interaction. This is what I mean when I say that mobile apps are “heavy.” Getting from inspiration to an open app requires too much work.

There is of course one platform that handles transitory interactions particularly well: the web. I should be able to call up the Best Buy “app” much like I do a website. No downloads, updates or uninstalls, simply “Go.”

#2 Context not subject

While the open (generative) web makes for a great, lightweight app platform, organization via URLs and search engines makes for horrible discovery on mobile. More fundamentally, the challenge is that the web has been developed to interpret user input – but not environmental input. That made sense back when computers were bolted onto desks but today’s “computer” lives in the pocket and the catalyst for usage is often tied to some measurable environmental factors.

Some applications have done a good job responding to such factors. And here I must really commend the iPhone, in particular, for providing so many valuable inputs. I would count Shazam as a great mobile app; with one click the song you’re hearing but don’t know the name of is analyzed and, if successful, the song name returned. That wouldn’t have much application on a desk-bolted computer but on a mobile device that’s with you in cafes and bars, it’s golden.

But how does one get to downloading Shazam? Well, you have to know it by name or do some novel searches to find it, or in other words it’s only discoverable via user input. Wouldn’t it make more sense if it were suggested to you when the phone detects a song playing? What I’m really getting at is designing an App Store around discoverability via context.

Let’s revisit the Best Buy example to see what I mean. This time I’m packing an iPhone with a very context-sensitive app store and applications.

A better day in the life

I’m wandering around a Best Buy and am having trouble locating Blu-Ray players. While I could go ask someone for help, I decide to pull out my trusty iPhone. Here are the steps I have to go through:

Open App Store (i.e., a customized browser)
Search “nearby” or just click the location button
1. This contextual search uses information about the surrounding area to present relevant applications. Since I’m standing in a Best Buy that application is presented first. The Starbucks next door is also presented.
Select Best Buy from the list
1. Note: With one click I not only load Best Buy (no download needed) but I’m put directly into the context of the specific store I’m standing in.
Ask “Where’s Blu-Ray?”
1. I’m presented with GPS-like directions. As I move throughout the store the screen continuously updates and I can simply replace “Blu-Ray” with “Checkout” or “Restroom.”

So there you have it. A much better user experience driven by context both in the app store and in the application itself. As a bonus, this kind of discovery can reinforce synergies found in the physical environment. There’s a good reason why a Starbucks is located next to a Best Buy – we should replicate that on mobile as well and perhaps suggest to the user to order their drink when they are waiting in the Best Buy checkout line.

#3 Eco not silo

So far I have suggested we kill the transactional nature of app stores and reorganize them based on context but my last suggestion may be the most radical – let’s kill the concept of an “application” altogether. Here’s my beef (it’s one that was first articulated to me by my Mozilla colleague, Aza Raskin, so consider this section co-production):

Applications are selfish – they keep innovations to themselves. While Web 2.0 has done a better job of “mash ups” this really occurs at the data level – what applications need to do is share functionality as well. What do I mean? Let’s say a word processor does a great job of producing rainbow colored text like this and that you love it so much that you want every word you ever type to be in rainbow. Ideally you’d set that up once and then no matter what application you are using, be it Word, Facebook, Photoshop, your type would be colorful. What I’m really suggesting is an architecture where features, as well as data, are pervasive. An application here would be redefined as a particular grouping of global features and data. Differentiation here purely resides in user experience as all applications could share in the best features and data available.

Why is this particularly important in mobile? Because while on the desktop we’ve developed task bars and shortcuts to help us manage the dozens of applications that we have running, on mobile we don’t have the same power or screen real estate. When we launch a mobile application it effectively takes over our phone. That makes not having access to data or features that much more painful.

Or put more positively wouldn’t it be great to have all your favorite features within reach? What if the Best Buy app utilized the same “nearby” feature that I had used to launch it in the first place? I could recursively search “nearby” again and now see what’s around me in the store:

And since this functionality transcends the app, the Best Buy app could deliver a lot more than just product information. It could even tell me that a friend is in the store too.

Not bad for a brick-and-mortar, eh?

Matthew Noorenberghe: Improved Form History

matthew — Mon, 03 Aug 2009 21:03:49 +0000

My first project this summer as an intern at Mozilla on the Firefox team was to improve the form history feature. It's a feature that most people use when they fill out forms but don't even realize it. For those of you who don't know what I'm talking about, it's the dropdown of previously submitted text that appears when typing into a form input field. The two main improvements that I have been working on in form history (which are also known as form awesomecomplete) for Firefox 3.6 are detailed below.

Frecency Sort

For the longest time, the entries in the dropdown were sorted alphabetically, which is fine with a small number of results. When you have many saved entries that match what you've typed, an alphabetical sort doesn't help you find the ones that you are likely to use again, since ones that you use regularly are mixed in with the others you've only used once. To make the order of results more useful and reduce the number of keypresses required to select a previous entry, I have implemented a frecency calculation to rank the results. Frecency is a concept that was introduced in Firefox 3 with the "Awesomebar", Firefox's smart address bar. The term is derived from the combination of frequency and recency whereby the more often or the more recently you’ve used the entry, the higher it ranks. Since the most relevant entries will now be at the top of the list of results, this should reduce the number of keypresses to select the entries that you use most often.

Substring Matches

Sometimes when filling out a form or typing search terms in the search bar, you may remember only a portion of the text that you previously submitted and you want to retrieve again. An example of this is when you want to repeat a previous search from the search bar such as one for "location". In the past, only previous entries that started with the text "location" would be displayed, and so you would not see a previous search for "firefox 3.5 geolocation". With my improvements, any text that you previously entered which contains the typed text anywhere in the entry will be displayed. Consider another example: if you don't remember your friend's entire email address when filling out a form but you happen to remember that you filled it out in this form before and they have a Mozilla address. Simply enter "@mozilla" in the text field and all email addresses for that field that contain "@mozilla" (ie. @mozilla.com or @mozilla.org) will be displayed. Bonuses are given to matches that are at the beginning of a word or if they are exact prefix matches (like the previous method) so that irrelevant results that happen to contain the search text shouldn't get in the way of relevant results. This should make finding past entries easier as you don't have to type the exact prefix.

For more information on the frecency algorithm used and some preferences to tweak the results, see the wiki page. Feel free to experiment with these features and the associated preferences and file bugs in Toolkit::Form Manager.

James Boston: Taking another look at Mozilla Education

James — Wed, 29 Jul 2009 22:15:35 +0000

Some random thoughts after talking to M___.

Random thought one: Early on in designing the structure of education.mozilla.org, I envisioned a big button for teachers to click that would take them directly to courseware. But that only works on a site that is focused on one discipline. Mozilla Education is for design, marketing and business people as much as it is for computer science people. Teachers and students in the same discipline are more likely to follow the same path through the site than teachers from differing disciplines.

Therefore, the site devolves into different disciplines from the top level. I think this makes sense in terms of organizing content, but something is lost. One of the use cases that needs to happen is professors contributing courseware or other content. Maybe they don't host the content on education.mozilla.org, but they should be able to connect to it. What is taking shape serves students and self-learners fine, but it doesn't cover all the use cases for professors.

I think think I need to go back a step and draw up some more use cases.

Another random thought: As far as computer science goes, teachers arriving at the site are in much the same position as their students. They may know everything there is to know about coding, but be Mozilla virgins. They are learners themselves. I suspect this is less the case in other disciplines. Those professors don't need info about their trade, or even Mozilla, but rather some ideas for doing what they already do in a more open source inspired way.

Random thought the third: Mozilla has a kajillion different websites. Just today I learned about library.mozilla.org (unless I was told and then forgot which I do a lot). I really need to put together of list of resources that already exist and reach out to the people behind those resources.

Last thought, not random: Regarding my earlier post on a platform other than MediaWiki for the site, the best feedback I've had is that TikiWiki is the best choice. It has the CMS and user management features that MediaWiki lacks, but is still a good wiki. It's used for support.mozilla.com, so you can see it themes nicely and there is some in house expertise.

James Boston: Limitations of prototyping with a wiki

James — Tue, 28 Jul 2009 20:11:30 +0000

The Mozilla Education website is being prototyped using MediaWiki, but as the content and organization part of project begins to take shape, I begin to feel the limitations of using a wiki for everything.

For one thing, the website doesn't have its own living space. It co-exists with all the other content at wiki.mozilla.org. I can't install extensions or plugins that would make the site more dynamic. For instance, the map of students or the video content from the Design Challenge are limited to screen shots and links because I can't use iframes or embedded content.

There's also the problem of separating public and private information. There's no conspiracy to hide data, but it would be useful to have email lists with availability restricted to various privilege levels. A wiki isn't a good tool for that.

I've tested Moodle. It looks great for running courses, but it doesn't really function well as a content management system without major hacking. It can be integrated with MediaWiki, but that looks painful.

I'm partial to using Drupal. It has the capability to manage users with a vast shading of roles and permissions. It works well for organizing content hierarchically. You lose the wiki markup syntax, but I think it's a reasonable tradeoff. There are wysiwyg plugins for page editing. Plus, you can lock the permissions of certain pages to certain roles very easily. It would be useful to have the main page include dynamic content through php scripting. Obviously, you can't allow php scripting that anyone can edit.

I don't know if it's a worthwhile use of my remaining time on this project, but I'd like to make a mockup of how the site could look and function on Drupal.

Brian Krausz: Speaking at Boston WordPress Meetup Tonight

Brian — Mon, 27 Jul 2009 04:20:30 +0000

Totally forgot to post this, but I’ll be the speaker at tonight’s (Monday July 27) Boston WordPress Meetup at Microsoft’s New England R&D Center (1 Memorial Dr in Cambridge). If you’re interested in hearing about WordPress plugins, or WordPress in general, feel free to show up. Should be a blast!

I’ll post my slide deck after the presentation.

Brandon Pung: Ubiquity in a Nutshell

admin — Thu, 23 Jul 2009 22:50:27 +0000

The project I’m working on at Mozilla this summer is Ubiquity. In this post I will explain what Ubiquity is and why I am so excited about it.

The Problem

The web is full of interesting and useful services. People access information by harnessing the power of search engines like Google, Bing, and Yahoo, as well as services like Wikipedia, Ask, and Answers. They view pictures on Flickr, watch videos on Youtube, search for restaurants on Yelp, get directions on Google Maps, discover interesting articles on Digg, and look up movies on IMDB. They stay in touch with friends through Twitter, Facebook, GMail, and more.

As the number of web services that we use on a daily basis increases, so does our desire for an easy way to access all of these services at once, without having to navigate to different sites and applications. This has led to the growing popularity of mashups, in which you can interact with several web services at once. There are twitter services that allow you to update your facebook, map services that allow you to view locations on flickr, and Digg streams that integrate with the top bookmarks on Delicious. With mashups, you can use one service as a platform for harnessing the power of several separate services.

However, these mashup models don’t really scale. They’re good for bringing together a few similar services, but beyond that they become cumbersome. A website that allowed the user to see their twitter, facebook and digg feeds while also displaying restaurant recommendations, movie reviews, driving routes, weather updates, and music videos would be disastrous. What we need is a fast and intuitive way to bring different web services to us when we want them and where we want them. This is where Ubiquity comes in.

What is Ubiquity?

Ubiquity is a natural-language command line interface to the web. Ubiquity allows the user to gain access to web services and perform tasks by entering commands in a very intuitive manner. In its current form, Ubiquity is a Firefox Add-on. The Ubiquity window can be brought up using a designated keyboard shortcut.

The user can input a command into Ubiquity using natural-language, and Ubiquity will give suggestions about what the user is trying to do based on their input. The user can then pick the suggestion which matches the action they are intending to perform, and Ubiquity will execute that action for them.

A preview of the action is displayed alongside the selected command, and pressing enter will execute the given command. In this case, it would take the user to the google maps page of the desired address, similar to what is viewable in the preview.

Why a Command Line?

For many people, a command line interface sounds confusing. But perhaps that’s simply a result of the kinds of command line interfaces we’re used to. The confusing part of a command line interface is that you’re often unsure of what to type. This is not because you don’t know what you want, but rather because you’re unsure of what you need to input to make the system understand what it is that you want. People like graphical user interfaces because graphics can easily aid the user in seeing what they need to do to make the system perform the task they want. However, the ideal interface is one that is so simple that such guidance becomes unnecessary. The user simply tells the system what they want to do, and the system makes sense of it. I believe that this can be best served in a command line, due to the command line’s ability to scale to a very large range of requests. This is best summed up in the following quote by Aza Raskin:

“Standard GUIs, with their drop-down menus, check buttons, and tree-lists, cannot compare to the range of options that a text interface effortlessly provides. With just five alphanumeric characters, we can choose one out of 100,000,000 possible sequences…It’s difficult to come up with a non-text-based interface that can perform as well.”

–Aza Raskin, Head of User Experience at Mozilla Labs

Thus the goal is to make a command line interface that understands natural language inputs well enough to give accurate suggestions based on the user’s intentions. If we can accomplish this, then a command line interface could prove to be far superior to a GUI for bringing web services to the user.

And There We Have It

Ubiquity in a nutshell. I’m very excited about what the future holds for this technology, and I look forward to continuing to contribute to it. There are many questions still unanswered in the design and implementation of Ubiquity, and I will be blogging about several of them in the near future. To install the Ubiquity Firefox Add-On or learn more about the project, you can visit http://ubiquity.mozilla.com/.

Anant Narayanan: The Golden Ratio

Anant — Thu, 23 Jul 2009 06:51:55 +0000

Today we had the pleasure of having Brendan Eich hosting a brown bag for all us interns, and he started out his talk with slides on the Golden Ratio.

I did have a vague idea of what the ratio was – but today I found out a lot more about it – like how it occurs in almost every natural creation or phenomenon. The mysteriousness of the universe is very humbling. Perhaps if we used a different number system that was based on 1.6180339887 instead of 10, everything would make perfect sense…

Anyway, one thing it definitely explains is my love for 16:9 screens as opposed to the old 4:3 ones

Brandon Pung: Mozilla Summer Internship!

admin — Tue, 21 Jul 2009 23:19:44 +0000

This summer I’ve been working for Mozilla in Mountain View, CA. It’s been an amazing experience, and it’s all going so fast! I’m working on the Ubiquity project in Mozilla Labs (http://ubiquity.mozilla.com/). I’m really excited about the work I’ve been doing this summer, and I look forward to continuing to contribute as much as I can in my remaining weeks here. I will go into further detail about Ubiquity in my next post. For this post, I wanted to give you all a look at our headquarters here in Mountain View. Mozilla changed offices at the beginning of the summer, moving a couple miles away from its previous office which was next to Google. We are now at 650 Castro Street, which is still in Mountain View.

The new office is absolutely beautiful. Functionally, it’s far superior to our old office. The conference rooms and meeting spaces are much larger, with lots of monitors, speakers, and microphones. The desk areas are also more spacious. In terms of aesthetics, it’s on a totally different scale than our old place. Everything is so sharp and refreshing. It has a fair amount of modern architectural influences, lots of glass and curvy lines.

I have posted some pictures below. To see all the pictures, check out my flickr set at http://bit.ly/yFnvk.

Anant Narayanan: THIS IS MOZILLAAAAAA

Anant — Sat, 18 Jul 2009 05:43:54 +0000

Very cool.

Anant Narayanan: Audio recording in the browser

Anant — Fri, 17 Jul 2009 07:05:13 +0000

I’m really excited to announce a new feature in Jetpack 0.4 – Audio Recording. “Jetpacks” can now access the microphone with just a few simple lines of Javascript:

jetpack.future.import('audio'); jetpack.audio.recordToFile(); var path = jetpack.audio.stopRecording();

The result is an audio file encoded in Ogg/Vorbis, which you can then playback with jetpack.audio.playFile(), or if you choose to upload the file to a remote location, using the <audio> tag.

A sample Jetpack I came up with that uses this feature is Voice Memos. It lets you record a memo that is mapped to the page you were on when you recorded it (which is achieved using Simple Storage), and also displays a list of recorded memos in a SlideBar. If you revisit a page attached to a memo, you will be notified via the SlideBar.

The code to achieve this was written in a couple of days, but I spent the better part of last week trying to build the component on Windows. The Mac/Linux versions seem to (mostly) run without issues, but Windows support is a little flaky at the moment. Part of the problem is that the XPCOM component dynamically links against portaudio and libsndfile, after which DLL Hell ensues. We’re looking to resolve these issues in upcoming releases as well as reducing the size of the XPIs.

One of my future goals is to allow raw PCM streaming rather than just recording to a file so you can do cool things like manipulating audio on the fly

In the meantime, do play around with this feature – we’d love to know what you think! The JEP for Audio support can be found here, and there’s a group for Jetpack-related discussion.

Brandon Pung: An Introduction

admin — Mon, 13 Jul 2009 00:28:43 +0000

I am officially starting my tech blog! I have been meaning to start this blog for quite some time, but I’ve been pretty busy since arriving in California for the summer. An introduction to the blog:

The author:

MIT undergraduate major in computer science, about to start my senior year
Interning for Mozilla during the summer of 2009, working on Ubiquity (http://ubiquity.mozilla.com/)
Interests include web design, artificial intelligence, and entrepreneurship

In this blog, I hope to:

Pose open design questions I am thinking about, which currently revolve around:
- Ubiquity
- Other Mozilla Projects
- General web design
Give my opinion on new tech products
Discuss the future of the web, artificial intelligence, and other interesting frontiers for technological advancement

Aaron Train: The Beauty of the Community

Aaron — Sun, 12 Jul 2009 17:45:00 +0000

It was only about 12 days ago that we released Firefox 3.5 and unveiled one of the new core features; support for the HTML5 <video> and <audio> elements including native support for Ogg Theora encoded video and Vorbis encoded audio. Less than 12 days later, community members have created basic full screen support for the video element; an enhancement feature in design phase on Bugzilla!

That’s incredible!

Full Screen Video, is the name of the add-on, and it adds a Full Screen option to the context menu for HTML5 videos.

Cheers, ‘design-noir’

Aaron

Adrian Kalla: Koala - Release Schedule

Thu, 02 Jul 2009 23:45:58 +0000

It has been a while since we announced the Koala - Komodo Advanced Localization Assistant - Project. While we work on the project on a nearly daily basis, we are just three students that need to do other work (like preparing for the upcoming examinations...), and because of that, the progress isn't as fast as it could be, if Koala would be our only project, but: we have a target for the final release: August, 23rd - September, 15th - and we plan not to miss it.

Our project schedule is of course more detailed - it consists of four big stages: preparation, implementation, integration and stabilization. That's the process of software development we did learn at our university, and our goal is to develop Koala that way.

During the first project stage, preparation, we've investigated as much as possible how Koala should work and look like, and as a result, we have written the Software Requirements Specification and Software Architecture documents.

In the Software Requirements Specification, we've listed the must-have features and have split them into modules with similar or dependent functionalities. In the now ongoing implementation stage, we are working on that modules separately. What does this mean? We code e.g. the "compare-locales" access module, make a few tests to be able to test it if it works as expected - and leave it there. So it's a single module, not (yet) connected with other modules.
As a result of this software development model, it's not possible to have something you "could touch" now - there won't be anything really usable until the next phase of development.

During the integration stage, we will make an working extension out of the many standalone modules. We will connect the modules through the, in the preparation stage specified, API's, one by one. It may look easier than it'll be, because this stage never comes as expected.
That will be also the time where we will start releasing pre-release versions of Koala: alpha and beta releases. They are to be expected late July.

After getting rid of the biggest blockers, we will enter the stabilization phase, where we will just fix known bugs and look for yet undiscovered bugs, by: testing, testing and testing. Because of that, in the middle of August you can expect an release candidate (hopefully just one).

The final release target is August, 23rd with a margin up to September, 15th.

If you'd like to help us in any way with this project, please drop a line in the comments.

Short update: between writing this posting and publishing it, we already entered the integration stage - but because of our examination session, the integration will start at full speed not earlier than in about three weeks.

Aaron Train: A Week of Milestones

Aaron — Thu, 02 Jul 2009 15:30:06 +0000

In the spirit of an exciting successful week, I would like to congratulate our friends at SourceForge who have delivered their 4,000,000,000th open source download. That’s one of a few major open source milestones this week. That’s a lot of downloads.

Aaron Train: Mozilla and the Future of the Internet

Aaron — Sun, 28 Jun 2009 12:00:59 +0000

Having just watched Yann Arthus-Bertrand’s hymn for the planet, titled HOME – an ode to the planet’s beauty and its delicate harmony, it triggered some thinking on what’s going on in the world.

HOME is more than a documentary with a message, it is a magnificent movie in its own right and has an impact on anyone who sees it. It awakens in us the awareness that is needed to change the way we see the world. It embraces the major ecological issues that confront us and shows how everything on our planet is interconnected. Everything is interconnected.

How can we take this means of awakening, interconnection and global consanguinity to bring everyone together on the web? Can we accelerate an integrated worldview towards critical mass by opening a medium where people can see what happens when they are empowered by each other?

We all want to live in a better world, and many among us are working to make that world a possibility. Improvement is achieved through ideation, innovation, cultivation and application of solutions to problems. However, due to the blindingly complex nature of the problems we currently face, equally sophisticated solutions are required. These solutions are beyond the realm of any one person or small group of people. It is the globe that faces these problems and thus it is the global mind that must develop matching solutions.

There are now more links, websites, documents and files on the internet than there are synapses in a single human brain. Having reached into every attribute of human life, it is now steering the course of history.

It is estimated that over 1.5 billion individuals have access to the internet with user growth ever increasing in the developing world. Classified as the most capable and sophisticated tool ever developed by mankind, the internet represents the pinnacle of thousands of years of technological development.

Accelerating at rapid growth at blazing speeds in development, it affirms rather than conflicts with human identify. In essence, it connects us in real and personal ways to other human beings. With higher potential beginning to reveal itself, an opportunity is presented to forge a network which interconnects those who improve our world. We now have the means and the wisdom to implement a system that fosters world-changing collaboration amongst the people of this planet.

We are, without question, living in the most exciting time in human history. Human potential is expanding as technology continues to bring awareness to the great realm of our knowledge and understanding, the populace of our planet are beginning to awaken, en masse, to our true inner nature and our integrated relationship with the world around us.

As the world wakens to its indissoluble oneness, we still see an escalating disarray. Fears of governmental paranoia and terrorism run amok, global economic collapse looms, and of course the earth herself is exhibiting the symptoms of feeble health.

We are now at a crossroads. Despite all the incalculable knowledge available at our fingertips, we are unable to predict the days forthcoming. There comes a point when every new and competing idea is put to a test. If that idea is to be successful it must reach a critical mass.

How can Mozilla and the internet of tomorrow work to accelerate an integrated worldview towards critical mass by opening a medium where people can see what happens when they are empowered by each other?

- AaronMT

Anant Narayanan: Labs Night: Openness and Competition

Anant — Fri, 26 Jun 2009 18:50:27 +0000

Last night, Joseph Smarr from Plaxo was our guest speaker and he talked about how the “web is going social”, and how the “social web is going open”. We discussed all the elements that make up the social web today: identity providers, social web providers and content aggregators, and how each of them are leveraging open standards and protocols such as OpenID and OAuth to create better experiences for their users. Check out his slides here.

This talk was a nice prelude to some interesting discussion about the role that the browser can play in handling the user’s data and identity on their behalf. Very relevant to this was also the recent experimentation by Weave on identity in the browser, and Myk gave us a demo of the auto-sign-in features.

Labs Night is also a chance for everybody to talk about cool stuff they’ve been working on, so Brandon gave us an update on what’s new in Ubiquity 0.5. There’s some really neat stuff in there: Ubiquity is possibly one of the first pieces of software that perform truly internationalized natural language parsing (0.5 rolls out with support for Japanese and Danish). Do check out this blog post for a detailed discussion of the features in 0.5.

I followed with an update on some of the work I’ve been doing with Jetpack – namely providing the capability for “jetpacks” to record audio. The code to enable this is checked into the repository, but you’ll have to wait until a release later this month if you’re not feeling brave enough to build the extension from source to play around with it. I was especially interested to know the kinds of applications that might be possible with this capability, so you if you have any ideas, I’d love to hear them. Myk also gave us a demo of the new streamlined way of subscribing to feeds using Snowl, check out this release announcement for more details on what’s new with the message reader you know you want to use!

Paul Tarjan from the Searchmonkey team at Yahoo! gave us some really cool demos demonstrating Searchmonkey Objects and YQL. I’m especially excited about YQL because it can make some of the back-end ubiquity code really simple and efficient. Incidentally, the Bing team was here at Mozilla just a couple of days ago and they also demoed some features similar to Searchmonkey Objects, albeit restricted to video and snippets of data for now.

Search is starting to feel exciting again, a sentiment similar to one we feel in the browser space today. There’s a lot of innovation in the area outside of the big daddy, and it is indeed heartening to see that major players in the web are beginning to recognize the importance of openness and competition

Labs Nights are monthly events, so we look forward to seeing you sometime in July to discuss more cool stuff that everyone’s been working on!

Anant Narayanan: Back for more Labs action

Anant — Thu, 25 Jun 2009 06:18:07 +0000

It’s been 3 weeks since I started my (second) summer internship at Mozilla Labs, and needless to say it’s been a blast! I’m continuing my work on Weave, besides helping out with the gamut of experiments that are currently running at the Labs. Weave is going to see some major strides forward in the near future, as we now have our very own Product Manager (Welcome, Ragavan!) in addition to the awesome Mike Connor joining the team

Within the first week of my arrival here, Mozilla made the move to the new office, which is possibly the sweetest workplace I’ve ever seen in my life. Check out selected pictures here.

There’s been the usual slew of intern activities, including, but not limited to: Canoeing, Movie nights, Birthday celebrations, Music discovery, and even a few dungeon runs on WoW

Look for more posts on labsy stuff in the near future. Peace!

David Tran: Hello Mozilla!

dtran320 — Tue, 23 Jun 2009 00:01:28 +0000

Hey everyone, I’m David, an IT/Ops Tools intern at Mozilla this summer. I will be entering my senior year (wow, those first three went by fast) at Stanford University in the fall and am looking forward to RA-ing in Gavilan (woo)!

Anyway, I am finishing up my second week here and having an amazing time so far! I have been working on the Mozilla Status Dashboard. Think something similar to Google’s Apps Status Dashboard and Amazon’s Web Services Dashboard.

I think services, especially web services, are increasingly putting an emphasis on transparency – when something’s wrong, they want their users to know what’s going on. In this day and age, nothing should be a black box anymore – making information available and easily accessible to users both makes IT’s job easier as well as acknowledges that users are intelligent and web-savvy. In that vein, Mozilla is really in a special situation with its relationship to the community and open source developers that allows us to share things that most corporations would not.

With that in mind, I present the initial mockup for the Mozilla Status Dashboard 0.0.0.0.1, which temporarily lives at http://mozdash.doesntexist.com/. Just to be clear, it’s currently hooked up to DUMMY DATA and does not represent the actual current status of these services, with the exception of the response time charts for http://addons.mozilla.org and http://www.mozilla.com. In the spirit of being open, I warmly welcome any feedback that anyone has for this project – what status information about Mozilla services would you like to see? What would be useful to as part of the Mozilla community? When we’re constantly being inundated with information from Facebook, Twitter, and RSS feeds, at what point does too much of a good thing (information) become a burden? I’d love to hear your thoughts in the comments below.

David Tran: Hello Mozilla!

dtran320 — Tue, 23 Jun 2009 00:01:28 +0000

Aaron Train: The Open Web with HTML5 Video & Firefox 3.5

Aaron — Thu, 11 Jun 2009 03:20:08 +0000

Each day, it is becoming more and more evident that the Open Web and the technology of tomorrow is expanding and blossoming into beautifully crafted future Internet.

As Firefox 3.5 is rounding the track towards the finish line, I can’t help but put my personal focus on that of HTML5 video. Firefox’s implementation of the HTML5 video API accompanied with royalty-free codecs, fundamentally progress the movement towards bringing an open video to the web.

HTML5 video truly is fascinating stuff, as Mike Beltzner explains, gone are the days of static videos played on static pages. With HTML5 video, we can treat video’s like web pages – which makes sense in a dynamic web.

These past few weeks, I have been progressively focused – eye-to-eye with trying to dig deep and unveil any remaining issues and it has been fun.

It’s been a real treat observing the progression from design to implementation of this feature and can’t wait to see it ship with Firefox 3.5 and how it will grow in the near future.

Tomorrow is a MoCo company wide internal test of Firefox 3.5 Preview Release, let’s work together to iron out any hidden creases in HTML5 video, and across the entire board in order to bring forth the next iteration of the browser by the people for the people, they deserve it!

Cheers,

Aaron Train (AaronMT)

Brian Krausz: On Spriting and Website Build Processes

Brian — Wed, 03 Jun 2009 06:11:06 +0000

Ryan, my mentor from when I was at MoCo, wrote an excellent article on spriting a few days ago. Man, I miss all the good conversations…that’s what I get for not subscribing to the webdev feed. That’s all changed now.

I have an interesting history with spriting. For both of my internships (Mozilla and Yahoo), one of my first projects was to sprite sites (AMO & Yahoo! Real Estate, respectively). AMO is still using my work (for now), and YRE long ago gave up on rounded corners, and have few icons now, so spriting is more or less useless for them now.

I guess that qualifies me to weigh in a bit. I’m not going to talk about the memory usage or anything on the client-side past delivery for two reasons. First: size in RAM has a tiny impact on page-loads compared to downloading for most users. Second: I’m horrible unqualified to talk about how web browsers load and store images in ram. Not my field.

There are some issues (many fixable) with spriting:

In both instances of spriting I got an email a few months after I left the company asking me where my source sprite file was located. Once it was due to me not putting the file in the right place, but the fact still remains that a source sprite file is one more thing to lose, and losing it is pretty annoying.
Not everyone knows how to compress images properly. If you do it wrong, you’ll end up with a huge PNG file that is worse than a bunch of small files.
Spriting removes any connection between CSS styles and the images they are associated with. If I want to know what a class with a background image looks like, I have to either find a reference to it on the site, or figure out where the hell -123px -72px is. It’s more or less obfuscating your CSS.
repeat-x or repeat-y images need to span the whole width/height of the sprite…they should have their own sprite files (if you have enough of them)
Like Ryan said, images that are supposed to be near the left of an element (i.e. they need an arbitrary amount of space to the right of them) should be at the right side of the sprite. This makes an internationalized site that supports right-to-left text (an insanely difficult thing to achieve, and something which many MoCo sites do impressively well) much more difficult. It’s very frustrating to discover halfway through that your sprites show up wrong in RTL. Not many sites need to worry about this, but it’s annoying if you do.

With that being said, spriting can be useful when done properly. A very good example is how Yahoo Mail sprites. They group similarly-size things in a file. They have an icon file, a rounded corners file, etc. This makes things easier to manage, but still suffers from some of the above issues.

I don’t know how Yahoo’s build process works, but to make sprites worth it I would propose some kind of CSS build step. Ideally all the developer would have to do is specify which images are displayed which ways (whether there needs to be whitespace to the left, right, top, or bottom), and the system will build the sprite and generate a complied CSS file that is minimized and concatenated.

AMO’s build process got halfway there. It was originally a shell script written by yours truly, converted to python by FWenzel. The shell script is described here (the python script is essentially the same). It concatenates a bunch of files, compresses them with YUI Compressor, and creates a PHP file with the current revision numbers (to append to the URL for long expires headers). Pretty standard web build system.

I’d really love to see a system that also parses out background*: rows with comments at the end (identifying what type of spriting should be done), places them, replaces the URL, and adds a background-position. That, combined with AMO’s build process, would allow an algorithm to determine what’s best for download times vs. memory usage.

The best part: an automated system would easily allow bucket tests on load times based on different sprite files. Now wouldn’t that be useful?

James Boston: Mapping EdMo (again)

James — Tue, 02 Jun 2009 19:55:53 +0000

I've received some feedback on my last attempt at creating a straw man info architecture for the Mozilla Education site.

Some of the criticism:

Mixes up high level and low level pages at the same depth in the hierarchy.
Separating high level paths for teachers and students doesn't make sense. For instance, teachers are more likely to identify with students who share their area of study than with teachers in other fields.
Serves only one constituency. Computer science students.
Works for the Seneca College model of teaching Mozilla, but maybe not other schools. Universities, for instance, may be looking for more info about research projects.

For the revision, there needs to be three things on the front page:

an overview that explains what Mozilla Education is
a path for people to contact us or get involved
links to orientation pages for various disciplines

Hence this top level view (click for larger view):

At the moment, I don't have a clear idea of how non-coders will be served, but the Design Challenge is an example of something that would be linked to.

As far as coders go, their section would expand out as follows:

In the above example, I follow one path to it's terminus, "Using XPCOM interfaces", but all the topics listed would similarly expand.

In addition to this, there is one more diagram about collaboration. This would be common to all all disciplines and would attach to the overview page for each.

Brian Krausz: Why YouTube Can’t Cost $1.65M a Day

Brian — Fri, 29 May 2009 07:38:42 +0000

I know I’m a little late on the bandwagon, but I’m sick of seeing articles claiming Google is losing so much money from YouTube. They’re based on estimates that I find a little absurd.

Let’s take just one example - http://www.internetevolution.com/author.asp?section_id=715&doc_id=175123&:

Disclaimer: I’m going to use low-ball estimates to guess where Google stands. I am by no means a professional when it comes to estimating this, or even educated in such things, but I feel like Google has so many tricks up their sleeves that I have only slightly less credibility than Credit Suisse or Bear Stearns. I repeat: I am making up numbers

Bandwidth

Maybe I’m not understanding something here, but from what I know a mutually beneficial peering agreement doesn’t require paying for anything other than labor or hardware. ISPs don’t want to provide users with fast internet without having it bounce around too many places, as does Google. Assuming Google has a datacenter close enough to every major ISP to just peer to them (not unreasonable), their only potential non-labor cost is communication between their datacenters. But wait! Hasn’t Google been buying up dark fiber left and right? That means their costs are adding additional capacity and redundancy, plus network maintenance (hardware and labor). Like I said, I’m not a hardware guy, but knowing people who owned datacenters, this is how I understood it. Please call me stupid if I’m wrong, but I’m going to cut this down to $10,000 (~$3.5M/year).

Revenue Share

This one’s just BS…they’re counting “making less money” as an expense. Sure, it’s less money, but that’s a little misrepresenting, no? Plus, I assume the estimating companies already took this into account. $0

Content Acquisition

Google isn’t dump…I doubt they’re putting themselves in the red solely on content costs. Media companies also get a huge amount of exposure from being on YouTube that they can’t get anywhere else (Excluding TV shows and Hulu, but YouTube mostly deals in music videos anyway). So let’s cut this in half and say $360,000 (~$131/year, a lot of clams, and generous in my opinion!).

Hardware

“Given market estimates of about $2 per gigabyte”. Really? Google is famous for using off-the-shelf hardware. I can buy a 1TB HDD for $100, and I’m not buying a million of them. I’m not saying this quote isn’t accurate when you account for electricity, cooling, redundancy, etc, but Google is far above the average for all of these, so I feel like using a market estimate is unfair. I’m gonna cut this in half, so $18,000 (~$6.5M/year).

New Results

Let’s calculate Google’s break-even point for YouTube:

Bandwidth	$10,000
Content Acquisition	$360,000
Revenue Share	$0
Hardware	$18,000
Subtotal	$388,000
Administrative Costs	38.4%
Math!	x*(1-.384)-388000=0
Break-even Revenue	x=$629,870

Now I’m not saying that Google is definitely making money off of YouTube, but $630K/day is less than Credit Suisse estimates Google’s daily revenue at, so it’s entirely possible they’re in the black.

James Boston: Mozilla Education diagram unveiled

James — Fri, 29 May 2009 02:45:09 +0000

In a previous post I wrote:

One of the goals of EdMo should be lowering the barrier for contributing back to Mozilla. The material we are producing is something that teachers and students can take and use anyway they find useful. But how can we make it easier for them to feed back into the project?

One way is for EdMo to be a place like the Ubuntu Community Documentation that invites contribution.

Some people liked that idea. However, developers have made it clear to me that more places for documentation are not wanted by them. I agree. There must be no duplication of MDC and anything that properly belongs on MDC should go there.

So what does belong on EdMo?

Big picture narratives
Because of it's scale, MDC doesn't necessarily work well as an introductory text. For instance, if you go to Participating in the Mozilla project page the list of tools is a bit confusing for the beginner. The Tinderbox link goes straight to Tinderbox, and the link to an MDC page underneath leads to a mostly empty cupboard. Newcomers need to know why they would care about Tinderbox.

Learning modules
Think of teachable units revolving around a task that needs to be completed rather than something purely reference oriented. In some (most?) cases, this will be a curated way of getting into MDC or other documentation.

...

I've put together a long chart trying to describe how Mozilla Education will be organized. Every box maps to a page. However, some pages near the bottom of the hierarchy could be joined or split. What's more important is their connections.

I'm sure that I've forgotten XYZ topic, and I'm glad to hear suggestions. But I'm more interested to hear if the the overall structure makes sense, if you would know intuitively where a new topic should be plugged in.

The landing page leads into six major tasks:

Teaching using Mozilla
Connecting the various schools involved
Connecting the students from different schools
Learning how to hack Mozilla code
Learning how to get help from the Mozilla community (and give back)
Getting involved with EdMo as Mozillan (is that a word?)

Following each of these tasks leads to an overview of what you need to accomplish those tasks. And digging deeper takes you the learning units. I haven't show links to external references in all units to avoid clutter.

All comments and criticism welcome.

Pejman Pour-Moezzi: the unexamined life

Pejman — Sun, 24 May 2009 00:18:30 +0000

“There is a secret bond between slowness and memory, between speed and forgetting. Consider this utterly commonplace situation: A man is walking down the street. At a certain moment, he tries to recall something, but the recollection escapes him. Automatically, he slows down. Meanwhile, a person who wants to forget a disagreeable incident he has just lived through starts unconsciously to speed up his pace, as if he were trying to distance himself from a thing still too close to him in time.

In existential mathematics, that experience takes the form of two basic equations: the degree of slowness is directly proportional to the intensity of memory; the degree of speed is directly proportional to the intensity of forgetting.”
- Milan Kundera, Slowness

I was leafing through my copy of Big Issues: The Examined Life in a Digital Age the other night and was struck by this quote. Owen Edwards excerpts this in his essay “Remembrance of Things Fast” in which he critiques the speed with which we live in the modern era. Some call it “social acceleration” and when pushed to its limit it is characterized by the acceleration of change such that experiences blur and memories vanish.

Edwards wrote the essay in 2001. If then he was anxious, today he must be utterly overwhelmed. In many ways, the internet has gone from mere accessory to displacing the world that built it. Bits are replacing atoms at an alarming rate. In 2008 alone, the world created 487 billion gigabytes of information (up 73% from 2007).

This is both beautiful and terrifying. The internet is the great democratizer, unlocking information and making it accessible to anyone that can plug in. It proliferates on the principle that there is virtually no cost in participation. It is that paradoxical book shelf that can accommodate seemingly infinite books at little to no marginal cost. But while the economics can justify an infinite stream of information, something must be said of the psychological implications. Today, amidst the flurry of activity that is one’s inbox, mobile phone, tweets, and web apps, many are overstepping the line of hyper-productivity. In a world of one-to-many communications, simply keeping up with the stream at times requires super-human capabilities. Which is really to say that we’re going too fast.

The internet opened up a landscape of unfathomable possibilities. And here we are at the foot of the New World, itching to grab all we can. The new Manifest Destiny is reaching the end of the internet. And with every new bit consumed and new level of productivity, we experience more but retain less. The new thesis is 140 characters long. It’s delivered in real-time and flashes across the screen and our minds in a matter of seconds. The phone is buzzing, the browser several tabs deep. unread emails number into the hundreds. We are awash in all of it. The answer is in your sigh, in your closed eyes and refrain. The key isn’t more information. It’s more focus.

Slow down.

James Boston: Brainstorming with profs about Mozilla Education

James — Fri, 22 May 2009 21:30:21 +0000

An interesting round of meetings surrounding Mozilla Education this week. At the start of the week, professors from a diverse collection schools joined the weekly conference call. On Thursday, some professors came into the Mozilla Toronto office for further discussions.

There were some high level discussions and some nuts and bolts discussions about using Mozilla in the classroom. Here's my completely non-comprehensive observations of issues raised in no particular order and being of unassigned value.

Research versus applied schools
Institutions that produce primary research (universities) will approach open source in the classroom room differently from institutions that do not (community colleges, polytechnicals).

Working with open source may be easier for colleges. The emphasis on practical skills and finding student placements in industry connects to open source organically. Colleges may not realize this yet, but it makes sense.

Universities have more of a theoretical focus. More importantly, professors have a research focus. How can working with Mozilla further that research and create value for Mozilla? Developers and researchers need to find an alignment of self-interest.

Being like the community
The methodologies used to teach should map to the methodologies used in open source (ie. using Mozilla's tools and not creating your own parallel universe). Not doing things the way the community you are engaging with does can lead to working in isolation. This is a novel way of working for teachers.

Inviting contribution
One of the goals of EdMo should be lowering the barrier for contributing back to Mozilla. The material we are producing is something that teachers and students can take and use anyway they find useful. But how can we make it easier for them to feed back into the project?

One way is for EdMo to be a place like the Ubuntu Community Documentation that invites contribution. DevMo is a great reference source, but it's not a place for random how-to pages. Changing DevMo is not unlike changing the Mozilla source code. There's a sense of changes being reviewed to see if they belong.

EdMo could be a place where people create the kind of documentation that doesn't belong on DevMo. (It's important to create something that will be used by the wider community and not duplicate something that already exists.)

There are some important differences between Ubuntu and Mozilla. The Ubuntu docs are process oriented. (eg., how to install a LAMP server). Only a portion of Mozilla documentation is about duplicating a process with expected results (eg. building source).

James Boston: nsIProcess2: The Awakening

James — Tue, 19 May 2009 04:26:00 +0000

People have been asking me for a status update on nsIProcess. Here's the scoop.

If you want to follow along the best place to bookmark is the project wiki page:
http://zenit.senecac.on.ca/wiki/index.php/User:Jamesboston/nsIProcess

The other place to look is the mercurial server that I use to publish code:
http://hg.jamesboston.ca/mozilla/nsiprocess

If you want a plain text patch containing all the changes from trunk visit:
http://jamesboston.ca/misc/patch.cgi

I will push code there every Sunday at the very least. For now I am working on top of revision 28222 of mozilla-central.

The first push is a jsm file with a simple wrapper for nsIProcess. I've never written a js module before so I wanted to figure that out first. I've piggy backed on the Makefile for a few existing jsm files, but doubt that js/src/xpconnect/loader is best place for the file. However, it will be a trivial task to relocate it later when it wraps nsIProcess2.

The next push creates the skeleton necessary for implementing nsIProcess2. I've started with the proposed API.

Now all I have to do is fill in the code that does stuff.

James Boston: Use twitter from irssi

James — Sun, 17 May 2009 01:56:12 +0000

If you don't know about the magic of screen + irssi this probably won't interest. (We don't want your kind around here anyway.)

I've written an irssi script to work with Twitter. It allows you to send and receive tweets from irssi.

Instructions:
Install the perl module Net::Twitter. On Fedora you would do it like so:

$ yum install perl-CPAN

$ cpan

cpan> install Net::Twitter 

Download this script twitter.pl:
twitter.pl [zip]

Edit the script with your own twitter credentials.

Put it in your ~/.irssi/scripts folder.

In irssi load the script:

/script load twitter.pl

To send a twitter:

/twitter Hey, I'm a tweeting fool.

Tweets from people you are following appear in your current window in a typical irc style, but prepended with the text "tweet:" like this:

<mhoye> tweet: Someday, my daughter will say "My dad says that pink is the thin, pale colour of the blood of my weakest enemies."

The tweets you send and receive are not visible to the channel. Only you (and your twitter followers) see them.

If you want to submit a patch the development version is here:
http://hg.jamesboston.ca/irssi/twitter/

Nino D'Aversa: JavaScript Error Console for Fennec

Nino D'Aversa — Thu, 14 May 2009 23:11:28 +0000

JavaScript Error Console on Fennec

This week as the mobile guys finalize the alpha for Windows Mobile I have busied myself with adding the JavaScript console to Fennec. Both Mark, Doug and Brad had expressed interest in the feature and it sounded like a nice chunk of work to keep me productive while the other guys concentrated on pushing out the alpha. I have a WIP patch up. I still need to spruce up the warning and error rows to more completely represent the data, however the whole console (filter and evaluation) currently functions just like the desktop version.

It has been very interesting to move away from C++ and into XUL and JavaScript. I have enjoyed being outside my comfort zone and lucky enough to have Mark right over my shoulder to help me along the way. I plan to spend some time reading my JavaScript book and XUL tutorials on the road to LA this weekend.

The second week here at Mozilla is somehow even better then the first. I enjoyed going out with the mobile team last night to take in some dinner and movie (Star Trek), it was nerdtacular. I’m lucky to be here and I don’t plan on forgetting that anytime soon.

James Boston: EdMo big picture revision

James — Thu, 14 May 2009 22:43:13 +0000

I revised the Mozilla Education front page today. Some information that was previously located one or two links into the site is now the first thing you read. The intro section focuses on the big picture of bringing open source methods into the classroom.

I've also added a new section beneath the site introduction called "Mozilla in the Classroom". It still needs to be fleshed out with more detail, but the I think that explaining how teachers are going to use/benefit from partnering with Mozilla needs to be explained in a separate unit from the big picture. I think I may steal some information from the case studies page.

I've put together a page for my notes on an info architecture for the site:
https://wiki.mozilla.org/User:Jamesboston/InfoArchitecture

One of the products of that is the addition of a site map. When you organize the site map according to the existing naming conventions, the site is easier to understand. But if you look at the how the site is navigated by links instead, it is harder to understand.

What this tells me is that it is easier to group pages by content than it is to find paths through that content. But the latter problem needs to be solved.