[6252 total ]
Posted
about 16 hours
ago
by
tglek
I work on static analysis by lamp-light and proudly cycle wearing Firefox imagery by daylight. Today I was pleased to discover that the flyer for the Portland Century ride now prominently features the Firefox logo in one of the 4 photos. It’s also
... [More]
in the scrolling thing on the website =D
This picture was taken on one ride with the most firefox fans ever. On parts of the course, it felt like every 5 minutes someone was volunteering info on how awesome firefox is. [Less]
Posted
about 19 hours
ago
by
nor...@blogger.com (David Bolter)
Aaron Leventhal has started a thread called: "Mozilla accessibility -- collecting stories & dreams". If you'd like to read what folks say about the Mozilla Foundation and its relentless commitment to keeping the internet a place for everyone, check it out.
Posted
about 20 hours
ago
by
dmandelin
Tamarin (technically, tamarin-tracing, henceforth TT)-related projects keep peeking up at me from the horizon. First, there’s a good chance I’ll have an intern working on TT this summer. And then there’s this “Tracehydra” idea. It’s a way
... [More]
to connect Spidermonkey’s JS parser with the TT execution engine. This is the plan:
Where “profit” means “run Javascript really fast”. Tracehydra would be the fluffy cloud that translates Spidermonkey bytecode to Tamarin IL (or possibly LIR-the details get confusing fast). (In the interest of reducing confusion slightly, I’ll say that IL stands for intermediate language, and is roughly a synonym for bytecode. TT people often refer to their IL as “Forth” because they based the design on Forth or something, but I know nothing more about Forth than that it involves stacks, so that doesn’t help me.)
Specifically, Tracehydra means using Treehydra to translate the Spidermonkey (SM hereafter) C code that interprets each bytecode into C that emits equivalent (to the C) Tamarin IL. So I guess it reduces the problem from translating SM bytecode TT IL to translating SM C cases to TT IL-building code. Put that way, it’s not clear this actually helps, but I think SM bytecode is believed to have complex semantics that would be difficult to code in TT IL by hand, and maybe the C in SM has fewer constructs that are easier to translate. Seems possible, anyway.
If I’m gonna make any sense out of this I need to learn something about TT IL and how the TT VM uses it.
Digging in to Tamarin. There doesn’t seem to be a lot of documentation on TT, so I thought I’d write up whatever I managed to figure out, for my own benefit at least. By the way, I’ve probably gotten some things wrong, so any TT experts are highly encouraged to correct me.
I should mention that Chris Double’s Tamarin posts have been invaluable-they are the best source I know of that explains how to actually build and run TT. And Graydon Hoare’s diagrams and comments are what got me started on having any idea where to look for anything in the code.
My first question was, what is the “life cycle” of a program run by TT? The TT shell as it exists today runs ActionScript programs, specifically ABC files (ActionScript bytecode). Once the tracer kicks in, TT is running machine code traces (e.g. x86-64 ISA). (Ugh. This is turning in alphabet soup.) What goes on in between? Here’s what I found.
By the way, this picture gives an overview. (Picture does not exist yet.)
Program Form 0: ActionScript. I followed a sample program, the simplest program I could think of that will get traced (you need a hot loop), through TT. Here’s my program:
var sum = 0;
for (var i = 0; i < 1000000; i) {
sum = i;
}
print(sum);
By the way, on my MacBook, this runs in 1.7s in interpreted mode (tracing disabled) and .28s with tracing enabled, a 6x speedup. And that includes VM startup time. For comparison, Java runs the equivalent program in .13s. (But Java gets the answer “wrong”, because ActionScript uses unlimited-precision integers while Java uses int32s. So this test is unfavorable toward TT.) Excluding startup time, Java takes about 4ms, apparently, the same as C. I’ll have to retest TT excluding startup time, once I figure out how.
Program Form 1: ABC. This is the ActionScript bytecode and is the input to the current Tamarin shell. I don’t need to know too much about this, but the real Tamarin stuff is generated from here, so I peeked at the ABC for my program. ABC is apparently a stack-based bytecode language, much like Java bytecode. Here’s a snippet from my sample program, with my annotations after //:
// var sum = 0;
// sum was assigned local variable ’slot 0′ in ABC file headers
// Stack starts as: [stuff]
pushbyte 0
// Pushed a 0 value onto the stack. Stack is now: [stuff] 0
getglobalscope
// Pushed the global ‘this’ onto the stack. Stack is now: [stuff] 0 this
swap
// Swapped top 2 elements of stack. Stack is now: [stuff] this 0
setslot 1
// Stored top of stack into slot 1 of next stack element. Stack is now: [stuff]
I’m not entirely sure how the compiler writers manage to get all swap, over, dup, pick3, etc. operators right, but the code itself is understandable enough.
Transformation 0->1: ActionScript->ABC. This can be done externally to TT by the ActionScript Compiler, ASC, which is part of the Flex SDK.
Program Form 2: IL. Tamarin IL is yet another stack-based bytecode. This is the IL that the VM executes directly when in interpreter mode. The basic operations include:
Stack manipulators, such as DUP, DROP, OVER,
Arithmetic and logical operators, such as IADD,
Control flow operators, such as LBRT,
Object and variable storage operators, such as SETSLOTVALUE_I,
Interpreter internals operators, such as _debugenter, verify_x, and
Weird stuff like op_ROTNAME2_SWAP_ROT_SETRT.
I think the weird stuff might be “superinstructions”, which are instructions that just implement a short sequence of basic instructions. Apparently they help interpreters run faster because by reducing decode overhead, like old CISC processors.
These instructions are defined in files named core/vm_*.h, e.g., vm_min_interp.h. These files are heavily macroized, which allows the actual meaning to be controlled by defining those macros in different ways, although I’m not sure exactly how this feature is used yet. Here’s IADD:
INTERP_FOPCODE_INTERP_BEGIN(IADD)
/* IADD None {’stktop’: 0} */
const int32_t tmp_i_0 = int32_t(sp[-1].i) int32_t(sp[0].i) ;
INTERP_ADJUSTSP(-1)
sp[0].i = tmp_i_0;
INTERP_INVALBOXTYPE(sp[0])
INTERP_FOPCODE_INTERP_END(IADD)
As you can see, it adds the top two elements of the stack (sp) as integers, cuts the top element off the stack, and stores the sum in the new stack top. There’s also some junk about invalidating the box type, which seems to be some kind of debugging feature. When this is included in VMInterp.cpp, the begin and end macros will turn it into a switch case. From VMInterp.ii in my build:
foplabel_IADD: { pre_interp(interp, f, ip -1, sp, rp);
const int32_t tmp_i_0 = int32_t(sp[-1].i) int32_t(sp[0].i) ;
sp = (-1);
sp[0].i = tmp_i_0;
do { } while (0);
goto *k_foplabels_interp[*ip ]; }
pre_interp just prints out a trace of the instruction if the interpreter is in verbose mode and a bunch of other conditions are true. The “computed goto” at the end is an indirect jump to the case for the next instruction. This is some kind of optimization but I’ve never gotten a really convincing answer as to why it works, or if in fact it works, so I won’t go into it here. Processor experts, feel free to educate me.
The main control flow operators (i.e., used for if) seem to be LBRT and LBRF (local branch if true/false?). LBRT branches to a selected point in the IL sequence if the top of the stack is true, interpreted as a boolean. The target is specified as an offset from the address of the LBRT instruction. The target is given in the IL stream in the 2 16-bit units immediately following the LBRT code.
I also wanted to know what a function call looks like in IL, and it was surprisingly hard to figure out for some reason that I still don’t understand. But it looks like a standard call to a JS function is through an opcode w_callprop_only or w_callprop_argcok. These opcodes don’t seem to be defined in the usual vm_*_interp.h, but somehow they are made to branch to foplabel_TRACE_super_or_extern in VMInterp.ii. That code does the usual saving of a return pointer and setting the instruction pointer. Returning is accomplished with a less mysterious w_returnvalue or w_returnvoid opcode.
The type of the instructions is FOpcode, which is a 16-bit int.
Transformation 1->2: ABC->IL. This is where Tamarin starts. This step is really important because some other system, like Tracehydra, that wants to use Tamarin, should basically do the same thing, except for some other form of input instead of ABC.
Tamarin performs this transformation on one method at a time, which is typical of JITs. The transformation is perfomed by Verifier::verify, which simultaneously verifies the ABC (checks for ill-formed ABC, like the Java bytecode verifier) and outputs Tamarin IL. The entry point to the verifier is apparently Interpreter::verify_x, which is just the implementation of an IL instruction also called verify_x.
That last part was probably pretty confusing. It surprised me, at least. It means the interpreter is already running IL by the time it actually translates and runs any ABC. I think what this means is that when the shell starts up, it starts the interpreter with a bit of boilerplate IL. The IL itself has code to verify and run the ABC program.
[Warning: compiler-expert-level material.] The verifier works as an abstract interpretation of the ABC. It uses the information gathered both to check for problems with the ABC and to guide IL generation. The state of the abstract interpretation is an abstraction of the ABC stack, just a list of types of objects on the stack, along with a lot of flags describing other conditions.
A standard abstract interpreter works as a fixed-point solver that possibly makes several iterations over the code. But TT’s verifier doesn’t work like that at all. The reason is that it requires that the states be equal at every join point, otherwise the ABC is invalid. So if the ABC is valid, then the interpreter never needs to look at a given instruction twice. And because backward branches in the ABC exist only for loops, this means the verifier can just run in a single forward pass through the ABC bytecode sequence. But it’s still really an abstract interpreter. Pretty neat. [End super-hard stuff.]
So the verifier runs over the ABC in sequence, always tracking the current abstract stack state. For each instruction, it generates IL. Part of generating the IL is generating any IL needed to fetch operands-the verifier can use the stack state to figure out where they are. After generating IL, the verifier simulates the effect of the instruction on the stack. This is all handled by a big switch on the ABC opcode, and each case has separate logic to generate IL and simulate the results.
The actual writing of the bits and bytes of IL is delegated to a class MethodWriter, which in turn delegates to ForthWriter (there’s that Forth stuff again). ForthWriter is a small class that maintains a buffer of IL bytecodes. It has a small API with methods like emit_simple(), which emits a simple IL instruction. MethodWriter is a wrapper used to generate Forth from ABC. The MethodWriter API takes ABC instructions as input and then tells the ForthWriter to emit the corresponding Forth bytecodes. For ABC opcodes with a direct IL equivalent, it looks up the equivalent in k_abc_opcode_map, which ultimately comes from vm_*_codepool.h. Otherwise it just has to work a little harder.
Time for a little example. I’ll use the same snippet I used above, with the IL translation trace straight out of the log file:
frame: global * * global
2:pushbyte 0
000D LITC0
000E w_ibox
frame: global * * global int
4:getglobalscope
000F OVER
frame: global * * global int global
5:swap
0010 SWAP
frame: global * * global global int
6:setslot 1
0011 LITC4
0012 w_ck_setslot_box
frame: global * * global
I had no idea what any of this was the first time I looked at it. There are 3 kinds of lines. First, the “frame: ” lines are the abstract interpreter’s stack state (”stack frame”) at each point. Second, the lines that start with numbers are ABC bytecodes. Third, the lines that start with “ ” are the IL translation of the ABC code just above them.
The first bytecode:
frame: global * * global
2:pushbyte 0
000D LITC0
000E w_ibox
frame: global * * global int
‘pushbyte 0′ in ABC pushes the value 0 onto the stack. In IL, this is two steps: first, an opcode that pushes the literal C int value 0 (i.e., a machine word of 0 bits), then an opcode that boxes that C int into a Box. Box is Tamarin’s standard value type that can hold anything. To C, a Box looks like an IEEE-754 64-bit NaN. I guess any float that has an exponent (bits 52-62) of all 1s and a fraction that is not all 0s is a NaN, so there are really 2^53-1 different NaN values. Tamarin cleverly uses only one of those in floating-pointer computations so it can pack other data types, like 32-bit ints, into the 2^53-2 spare NaNs. A Box starting with the bit pattern 1111111111000 is an int, and the rightmost 32 bits contain the int data. See Box.h.
In our example, note how the verifier knows the top of the stack now holds an int.
The second bytecode:
frame: global * * global int
4:getglobalscope
000F OVER
frame: global * * global int global
This is kind of interesting. An object-model-type ABC instruction, getglobalscope (pushes scope to use for unqualified name lookups), got translated into a stack manipulation IL instruction, OVER (pushes the value just under top of the stack). Apparently, the global ‘this’ scope goes on the stack at the start of a method, and the interpreter records its position. If no other scopes have been entered (no with blocks), then the verifier can just emit an instruction to pick it from its current depth in the stack, since of course the interpreter also always knows the stack size. If there are other scopes in play, then the verifier emits a w_getouterscope instruction, which calls the interpreter C method Interpreter::getscopeobj, which goes through a few levels of direction but is ultimately pretty simple, grabbing a scope chain for the current method, and then picking off the first scope. Well, I really don’t know what that means, because I’m not too clear on scope chains yet, but it’s only a few lines of code, anyway.
That’s enough for now. [Less]
Posted
about 20 hours
ago
by
beltzner
Please note: The Firefox 3 Release Candidate is a public preview release intended for developer testing and community feedback. It includes new features as well as dramatic improvements to performance, memory usage and speed. We recommend that you
... [More]
read the release notes and known issues before installing this release.
The first Firefox 3 Release Candidate is now available for download. This milestone is focused on testing the core functionality provided by many new features and changes to the platform scheduled for Firefox 3. Ongoing planning for Firefox 3 can be followed at the Firefox 3 Planning Center, as well as in mozilla.dev.planning and on irc.mozilla.org in #granparadiso.
New features and changes in this milestone:
Improvements to the user interface based on user feedback, including changes to the look and feel on Windows Vista, Windows XP, Mac OS X and Linux.
Changes and fixes for new features such as the location bar autocomplete, bookmark backup and restore, full page zoom, and others, based on feedback from our community.
Fixes and improvements to platform features to improve security, web compatibility and stability.
Continued performance improvements: changes to our JavaScript engine as well as profile guided optimization continues to improve performance over previous releases as measured by the popular SunSpider test from Apple, and in the speed of web applications like Google Mail and Zoho Office.
(You can find out more about all of these features in the “What’s New” section of the release notes.)
Testers can download the Firefox 3 Release Candidate builds for Windows, Mac OS X and Linux in over 45 different languages. Developers should also read the Firefox 3 for Developers article on the Mozilla Developer Center.
Note: Please do not link directly to the download site. Instead we strongly encourage you to link to this Firefox 3 Release Candidate announcement so that everyone will know what this milestone is, what they should expect, and who should be downloading to participate in testing at this stage of development. [Less]
Posted
about 22 hours
ago
by
david.humphrey
I’m too tired to write this properly, but it’s satisfying enough to do before I quit. If you’ve been following my progress, you’ll know that I’ve been trying to solve Dave’s mxr-dehydra challenge, looking for all possible methods that
... [More]
SetParent could be in privatePrevAccessible->SetParent(this) (which is really nsPIAccessible->SetParent(nsIAccessible*)). As Dave discovered the hard way, there are two. Using my code, which builds a SQLite database of the tree’s type info while you build, I can do it in a fraction of a second:
sqlite> select members.mtname, members.mdecl, members.mdef from impl, members where impl.tbase="nsPIAccessible" and impl.tconcrete=members.mtname and mname="SetParent(nsIAccessible*)";
mtname|mdecl|mdef
nsAccessible|/home/dave/mozilla-central/src/accessible/src/base/nsAccessible.h:111|/home/dave/mozilla-central/src/accessible/src/base/nsAccessible.cpp:460
nsHTMLListBulletAccessible|/home/dave/mozilla-central/src/accessible/src/html/nsHTMLTextAccessible.h:110|/home/dave/mozilla-central/src/accessible/src/html/nsHTMLTextAccessible.cpp:338
This shows the declaration and definition of nsAccessible::SetParent and nsHTMLListBulletAccessbile::SetParent. I’ve written a dehydra script to generate .sql files for everything that gets compiled, and then a script to assemble these into a simple database (~45M) that can be queried about any class/type, member, or inheritance relationship in the tree.
I’ve run into all sorts of strange edge cases over the past two days, but it’s getting pretty close. The cases I’ve tested work, which isn’t the same as saying it works. I’m going to try and iron out some more of the bugs I know about, and then move on to solving the problem of how to map tokenized source to the output of process_function(), which breaks down all the variables, assignments, function calls within the code. The thought of it overwhelms me tonight, and it’s enough to make me want to quit for the weekend. But I’m quitting with a smile on my face :). [Less]
Posted
about 23 hours
ago
by
bhashem
Mark Finkle & Dave Townsend wrote in their blogs (& here too) about the new add-ons newsletter. Receive timely news about changes to the AMO site as well as add-ons related news. You can subscribe here.
Posted
1 day
ago
by
Mark Finkle
Mozilla is starting a new newsletter, about:addons, strictly for add-on related development and hosting. A lot of changes were made to the way extensions are built and hosted during the last Firefox / Mozilla release cycle. Many changes and new
... [More]
features have been happening on AMO as well. It can be hard to keep track of the add-on related changes with all the other types of information coming out of Mozilla, on MDC or blogged on Planet Mozilla. With that in mind, it was decided that a dedicated newsletter could be the best way to get add-on information to add-on developers.
Deb Richardson started the about:mozilla newsletter about seven months ago and it has been a great way for community members to keep informed about news in the Mozilla ecosystem. We’d like to create the same kind of success with about:addons.
Dave Townsend covered some of the details in his post. Use the sign up page to subscribe. The newsletter is primarily an email-based service, but we will post it on DevNews weblog too.
We hope to get the first newsletter out sometime next week. We’ll post more information about submitting news as we get things nailed down. For now, feel free to leave comments about what you want to see. [Less]
Posted
1 day
ago
by
sheppy
When Mark Finkle’s blog today talked about parental controls support on Windows Vista, I was taken slightly by surprise. You see, I’d never heard of the nsIParentalControlsService interface, despite a great many months (a year, in fact) of
... [More]
trying to hunt down all the new APIs added to Firefox 3.
So, after wondering how I missed that one, I settled down and cranked out the reference documentation for the nsIParentalControlsService interface. Enjoy. [Less]
Posted
1 day
ago
by
Mossop
Being an add-on developer can be hard work. So many different places to look for information about releases, new features and changes to the platform. How can you be expected to keep up with all this?
Well starting next week hopefully
... [More]
we’ll be taking a big step in the right direction. Mozilla are launching about:addons, a newsletter dedicated to getting add-on developers all the important information they need. There will be announcements about when to check your add-ons against new releases of applications, new features added to addons.mozilla.org, plans for the future that you can get involved with and early warning of API changes.
So what are you waiting for? Go and sign up to receive the newsletter direct to your inbox. We’ll also be posting each issue to a blog but the email is more convenient in my opinion. You can of course unsubscribe any time you like. The newsletter should be out about once a month or occasionally more often if there is something important to announce.
Why not let me know if there are important kinds of news that we should be including in the newsletter. [Less]
Posted
1 day
ago
by
nor...@blogger.com (Tau Central)
In a recent post, dbaron suggested that people inappropriately judge Mozilla by, for example, the age of the bugs that one can see. I think he is right, but I think there is a reason for this. It is usually completely impossible to look at a bug and
... [More]
figure out whether it will be fixed or not. There are long-standing reasons for the use of nobody as an assignee, but this can be un-helpful.
Mozilla code development is socially driven. This may seem obvious, but the effects of this are not necessarily obvious, especially to someone in coming from commercial software. Look at the recent revisions of the module ownership system and you can see how tenuous the ownership of code can be. Nobody has to care about any bug. Or, to say it another way, only 'nobody' actually has to care about the vast majority of bugs.
It is very hard to look at a bug and see who actually cares about it. No. I will not gripe about bugzilla. Really. But I will just say that anything in a bug is not what it says, but how that is looked at by which group does the work. Priority, Confirmed, and many other terms mean different things to different groups of people. And everyone seems to be ok with that.
I have filed many bugs thinking that Firefox should just 'do the right thing' and that people would want to know. Is still have this idealism at times, but I recognize the other viewpoint as being valid. It may be true that one should not fix something that does not need to be fixed.
And as dbaron has pointed out to me many times, one is always welcome to file a patch. And, actually, that turns out to be the key to many things. I used to think there was value in asking about a bug to understand it. I used to think there was value in discussing a solution before creating a patch. But, as a practical matter, the number of people willing to talk about making changes is vastly more huge than the number of people who will make changes. So, considered questions almost always get silence while patches that are crap get responses. If I have 10 years of database experience and ask a question about sqlite use by Places, and a 12-year-old asks a question with a patch he came up with in five minutes, who will get a response? Who will be more likely to get something started on a bug? It seems obvious to me now.
So when in doubt, submit a patch. Any patch.
So, this leaves a question. How does Mozilla want to manage bugs submitted by or read by or tracked by non-developers? It seems clear that bugzilla is really best only for developers. Asking users to look at bugzilla and make sense of what they see is, I would suggest, not realistic. Maybe the idea behind Hendrix needs to be developed further. A lot of what is in bugzilla looks like graffiti in a train station. So maybe something is needed manages that graffiti and relates it to actual bugs that people may actually work on. But then, the people who do the work do not mind looking at the graffiti and just working on what they talk about. They seem to know which ones are actually significant, so why fix it if it's not broken? [Less]
Posted
1 day
ago
by
Matthew Gertner
I’ve been using Flock all week, and I have to say that I’m pretty impressed. Flock is way out in front of the pack in driving innovation in the browser space (although Mozilla is catching up with their various Labs efforts). It’s refreshing to
... [More]
see a vendor thinking big and experimenting with adding all kinds of bold new capabilities to the browser.
Specific things I liked about Flock:
It’s based on Firefox, so it feels like Firefox with a bunch of extensions installed for the various social features. I didn’t get any of the cognitive dissonance one might expect when switching to a new browser. It didn’t migrate my numerous Firefox 3 windows and tabs when I installed it, but I was able to fix this by copying the sessionstore.js file from my Firefox profile by hand.
The blog editor is simple and convenient. The Web Clipboard is a better mechanism than bookmarks for grabbing links, pictures, etc. for later blog posts. For example, I used it to gather links for my Bits and Bobs articles. Configuring the editor to post to my WordPress blog tooks seconds and worked without a hitch. Unfortunately you can’t add WordPress tags to your post directly in the editor, so I had to add them afterwards by hand (a major drag). Apparently a fix for this is already in the works.
There’s a nifty button in the tab bar for adding a new tab so I don’t have to grope around for the right mouse button.
Like Firefox, Flock detects when a page has RSS feeds and displays an icon in the URL bar. But it also detects search engines and media feeds. So you can add a new engine to the search box with a single click, or browser media (images and videos) in Flock’s very slick media bar.
At least some (and perhaps all) Firefox extensions appear to work without modification. I spent less than five minutes on Facebook, with it’s skull-shattering Flash ads, before I was compelled to install Flashblock. I grabbed it from the Mozilla add-on site and it works perfectly.
Flock makes heavy use of the “yellow bars” (modeless alerts displayed at the top of the browser window) to keep you abreast of what’s going on. Most of them can be turned off by clicking a “don’t show this again” checkbox.
A little icon lights up next to users in the Facebook sidebar when they have shared new pictures. One click and you’re browsing them in the media bar.
I’m sure a lot of users will appreciate the photo uploader. Personally I don’t take a lot of digital photos so I didn’t try it.
The biggest drawback of Flock is that it is gunning for a moving target. The version I tested (1.1) is based on Gecko 1.8, the platform that underpins Firefox 2 (yes, this will be on tomorrow’s quiz). Gecko 1.9, which serves as the basis for Firefox 3, has much improved memory consumption and performance, which I missed immediately upon switching to Flock. And once you’ve experienced Firefox 3’s awesomebar, it’s nigh on impossible to live without it. To be fair, Firefox 3 is still in beta, and Flock 2.0 (which will be based on Gecko 1.9) is under development and slated for release later this year.
More generally, it’s questionable whether Flock’s fancy social features have a strong enough appeal to attract a significant user base when compared to heavyweights like Firefox, Internet Explorer and Safari. The blog editor build into newer WordPress versions is pretty good in its own right, and it’s a darn sight easier than switching to an entirely new browser. Many if not all of Flock’s features can be duplicated using Firefox extensions. The fact that Firefox benefits from a robust third-party developer ecosystem, rather than relying on a single company to implement advanced functionality, means that it has already leapfrogged Flock in some areas. For instance, the visual impact of the PicLens extension blows away Flock’s media bar.
There has been much speculation about Flock releasing a Firefox extension instead of continuing to push its own browser brand. This would certainly help to solve many of these issues. At the same time, the technical challenge would be significant since they would no longer have the luxury of adapting the guts of the browser to their specific needs. (I’ve got my share of experience with complex Firefox extensions, however, and I don’t believe the task would be impossible.) A bigger obstacle is the fact that Flock relies primarily on a search partnership with Yahoo to generate revenue. Finding a viable business model for an extension would be much harder, although I think some of the ideas I mentioned earlier this week might be applicable, particularly the notion of tracking surfing habits and delivering highly targeted and relevant ads.
Radical steps along these lines will probably be necessary if Flock is intent on world domination. If they are content to carve out a niche among the digital avant-garde with a very slick browser boasting a range of innovative features and a straightforward business model, however, they seem to be on the right track already.
Blogged with the Flock Browser [Less]
Posted
1 day
ago
by
Bryan Clark
Dear friendly neighbors to the north. Only Defence Scheme No.1 can save you now for I will soon be en route.
A Great Invention
The Canadian Broadcasting Corporation ranks Poutine as #10 in The 50 Greatest Canadian Inventions
... [More]
, impressive. And I intend to eat a lot of poutine while I’m up in Montreal this weekend. In fact I hope to stop at Au Pied de Cochon for their famous varieties.
hopefully I’ll see this sweatshirt that I can’t seem to find anywhere [Less]
Posted
1 day
ago
by
Mark Finkle
[Thanks to Jim Mathies, Firefox developer, for writing this post - with minor edits]
Firefox 3 will have some support for Parental Controls on Vista (see bug 355554). The download manager is now aware of situations where content gets blocked
... [More]
by proxies. Downloads that are blocked display correct UI message to indicate what happened.
A good example would be a right-click Save As on an image link that’s offensive. Something like that might get blocked by a proxy, so we handle that case correctly in the download manager.
As for the main browser area, inline display of offensive content tends to be handled by the proxies themselves, so that content downloaded by the browser will get replaced by some sort of “blocked message” content, or it’ll simply be displayed as a broken image. In general, we rely on proxy blocking in the main window right now. This is something we want to eliminate down the road by detecting blocked content before we issue the request and display our own message.
In preparation for that and for more general use, we now have an interface (nsIParentalControlsService) that interacts with the operating systems parental controls services, so extension developers and XULRunner apps can respect local parental controls restrictions.
Currently, we support querying of application level flags like file blocking, logging of blocked content, and requesting overrides for a single or list of URIs. We don’t yet support for querying whether a particular URI will be blocked, but we’ll be adding that soon. Until then, developers can rely on HTTP status results to detect blocked downloads.
Looking forward to Firefox 3.x, we’ll have better support for inline blocked content, and we’ll be adding checks of file blocking flags in other places, like the extension manager. We weren’t able to get that in this release because it required UI changes and parental control support was added pretty late in the release cycle.
[thanks Jim] [Less]
Posted
1 day
ago
by
Shawn Wilsher
[I use a Mac, so all the images in this post are of the Mac user interface. The UI for other platforms will differ slightly. Click on pictures to view other sizes.]
Firefox 3 brings a brand new download manager to the scene. There were lots
... [More]
of issues that existed with the old download manager both in terms of the UI and in the code that made it work. So for Firefox 3, we redid the whole thing to provide a better experience all around. It’s one of my favorite features in Firefox 3, but then I’m a bit biased. This post discusses the new features of the UI.
Old Meets New - a UI Comparison
The Firefox 2 download manager (above) would display the download’s icon (but not on Linux), its name, its status, and two text links to open and remove the download. In contrast, the Firefox 3 download manager (below) displays the download’s icon (even on Linux now), it’s name, the time of the download, the download size, and where it was downloaded from. For an active download, the size of the download changes to the amount downloaded so far. The main goal was to provide more useful information to the user.
You might notice, however, that there is now primary UI to open or remove the download. The idea here was to provide a less cluttered UI. However, just like before with Firefox 2, you can open your download by selecting it and pressing enter, double clicking it, or selecting open from the context menu. In fact, the context menu has grown a lot too!
The middle two options provide functionality that was once available from the old properties dialog. That dialog was removed because it was out of place. One of the new features of the new download manager is the ability to select more than one download (as hinted to by the “Select All” entry in the context menu). You can select multiple downloads (below) to perform an action on them such as remove, pause, or resume.
Searching
The new download manager also adds the ability to search through your download history. Let’s say that you recently downloaded a bunch of pdf documentation from threadingbuildingblocks.org and want to open it. The folder where all your downloads go is hopelessly cluttered, so you open up the download manager, and search for “pdf threading”. In a matter of moments, you are presented with the documents you wanted so you can now open them, or if they were deleted, you can re-download them.
Status Bar Indication
Perhaps the most useful feature that has been added in Firefox 3 is a little status indicator that can be found at the bottom right of your browser window:
Firefox will now let you know how much time is left for your active downloads. When you click on the indicator, it will open up so you can see more detailed information about your active downloads.
That wraps up the changes to the UI. Stay tuned for a post about what new features have been added to the download manager in Firefox 3! [Less]
Posted
1 day
ago
by
Mike
Five years ago, I had just left IBM, and was pretty unsure about what I really wanted to do next. I didn’t know whether I wanted to switch my goals back to software development, or stay on the IT track I’d picked before the bubble blew.
... [More]
Firebird 0.6 came out that day, and I found some bugs, so I started poking around Bugzilla. Things sort of snowballed from there, as I got more involved with QA, and later fixing UI bugs. I ended up hacking cookies with dwitte, and front end with Ben and Blake, and I found myself more and more involved and enmeshed with Mozilla.
Its pretty fantastic to look back at those five years, from the uncertainty of the Foundation startup, through the huge buzz around Firefox 1.0 and the launch, the growth and maturity of the organization through the challenges of shipping follow-on releases, all the way up until today, where we expect to ship the first release candidate for Firefox 3. I can say honestly that its the best release we’ve ever done, and I’m excited about getting it to 170 million people as soon as possible.
What’s most interesting to me is that we’ve now grown enough that we’re no longer aiming for It Just Works. We’ve done that already, so now we’re aiming for the holy grail of Does What I Mean. Its a much higher bar, but that’s where we need to go next. We need to do it on mobile, we need to do it on the desktop, and we need to figure out how help people do it everywhere. And that is my new Five Year Plan.
I hope you’ll all come along for the ride. [Less]
Posted
1 day
ago
by
Standard8
In the address book there has been, for quite a while, various problems whilst managing addition and deletion of address book cards to and from Mailing Lists - things like cards not being removed from the display, duplicated cards displayed (but
... [More]
click onto a different address book and back again and it sorts itself out).
With thanks to Siva (from Spicebird), all these problems have now been fixed (with the exception of one remaining problem).
This is an excellent fix and should hopefully reduce at least some of the confusion for users have experienced whilst updating mailing lists, and ensure that we’ve got the right notifications being fired for extensions to pick up on.
The remaining issue we’ll probably take another look at once we’ve got some other back end work done. If you want to try it out then get the latest trunk nightly (at your own risk!) or wait for Shredder Alpha 2/SeaMonkey 2.0 Alpha 1. [Less]
Posted
1 day
ago
by
Marco
Aaron Leventhal posted a great summary of the impact of Mozilla Accessibility to the mozilla.dev.accessibility newsgroup.
Have anything to add? Any success story to share where the accessibility in Mozilla product had an impact on you? Either comment here on the blog, or go to the thread and reply there!
We want to hear from you!
Posted
1 day
ago
by
roc
Yesterday I gave a talk at Stanford in Dawson Engler's Advanced Operating Systems class. It was a variation on talks I've given before, but with a bit more about open source project issues and spec design issues. I pushed the meme of the virtuoso
... [More]
spec editor, something I hope will spread. I also talked about the economics of error recovery --- the fact that recovering from malformed input, instead of hard failure, is a competitive advantage for client software so in a competitive market it's sure to develop and you might as well put it in specifications.
Today I've been at the Berkeley OSQ retreat. As usual it's a lot of fun hanging out with Berkeley and Stanford students and faculty, plus people from Microsoft, Intel and IBM, talking about software improvement research. I especially enjoy it because I know this community well from my research background, but I also have a lot to contribute from my experiences in the Mozilla trenches.
One point I keep making is that we are pretty good at finding bugs, but we need to improve the fixing process. One part of that is to work on debugging, hence Chronicle. Another part is to apply software verification techniques to patches --- we do care very much about avoiding regressions, so identifying new bugs that would be introduced by a patch would be extremely useful (more useful than just identifying existing bugs in the tree).
Another interesting observation is that we want to avoid bug fixes that increase complexity, if possible. That often means a bug fix involves restructuring code followed by a small fix, where the goal of the restructuring is to allow the fix to be small. We can factor this into two changes, where the first change should preserve existing behaviour. It would be great if we had good tools for checking the first change ... and that actually seems like a feasible goal, since the problem is quite crisply defined and should often be solvable using local reasoning. It would certainly be nice, as a code reviewer, if cleanup patches came with a proof that they do not change behaviour (or at least a statement that intensive automated analysis had failed to uncover any issues). [Less]
Posted
1 day
ago
by
bhashem
The webdev team has updated AMO with a set of key fixes in a new incremental release. This revision includes:
New list views for Newest & Recently Updated add-ons
Display of last modified date on add-on pages
A revised version
... [More]
history page
Ability for users to change their email address and many fixes related to the user signup process, email address and password handling
Easy discovery of languages and dictionaries details pages
Various search items: new search button, themes, dictionaries and language packs showing now up correctly
There were other fixes as well - full bugzilla fix list. We plan to revise AMO with another release in about 2 weeks. [Less]
Posted
1 day
ago
by
David Baron
Lately, I've seen some people criticize Mozilla because a particular
bug (often a request for a new feature) that they care a lot about
hasn't been fixed, on the basis that the bug was filed some
number of years ago (generally more than
... [More]
five). I think this
line of criticism is undeserved and seriously misguided.
People who make this argument are, effectively, criticizing us for our
openness.
We have an open bug
system where anybody in the world can report bugs the way any
participant in the project would. We use bug reports not just for
things that are obviously incorrect, but also for things that might be
incorrect, or for things we can to do make our products better.
Reporting a bug, especially when done well, makes it much more likely
that the bug will be fixed (and has the potential to get the reporter
more involved in the project). But it doesn't create any obligation to
fix the bug. We (the developers of Mozilla) can't let anybody in the
world order us around. (If we did, I'm sure our competitors would
have fun abusing the system.)
Bugzilla has been open
for a long time, so there are pretty old bugs in it. In an ideal world,
when people working on Mozilla decide which bugs to fix, they should
consider how important the bug is to fix (the benefit of fixing it), and
how much work it is to fix (the cost). There's no reason to consider
(directly) when the bug was filed.
(By the logic of this line of criticism, presumably, we should
implement support for
Word documents before we implement anything suggested since April of
2000.)
We've had an open bug system for almost ten years, so there are bugs
that are worth fixing, but not top priority, that have been sitting
around in our bug system for almost ten years. Some of these bugs are
worth investing energy in now. Some of them probably should have been
fixed years ago, if we had prioritized optimally. But for many of them
our choices were probably correct. (In the case of the bugs that attract
the most attention, this is because the cost of fixing the bug is high,
not because the benefit is low.) [Less]
Posted
1 day
ago
by
David Baron
Lately, I've seen some people criticize Mozilla because a particular
bug (often a request for a new feature) that they care a lot about
hasn't been fixed, on the basis that the bug was filed some
number of years ago (generally more than
... [More]
five). I think this
line of criticism is undeserved and seriously misguided.
People who make this argument are, effectively, criticizing us for our
openness.
We have an open bug
system where anybody in the world can report bugs the way any
participant in the project would. We use bug reports not just for
things that are obviously incorrect, but also for things that might be
incorrect, or for things we can to do make our products better.
Reporting a bug, especially when done well, makes it much more likely
that the bug will be fixed (and has the potential to get the reporter
more involved in the project). But it doesn't create any obligation to
fix the bug. We (the developers of Mozilla) can't let anybody in the
world order us around. (If we did, I'm sure our competitors would
have fun abusing the system.)
Bugzilla has been open
for a long time, so there are pretty old bugs in it. In an ideal world,
when people working on Mozilla decide which bugs to fix, they should
consider how important the bug is to fix (the benefit of fixing it), and
how much work it is to fix (the cost). There's no reason to consider
(directly) when the bug was filed.
(By the logic of this line of criticism, presumably, we should
implement support for
Word documents before we implement anything suggested since April of
2000.)
We've had an open bug system for almost ten years, so there are bugs
that are worth fixing, but not top priority, that have been sitting
around in our bug system for almost ten years. Some of these bugs are
worth investing energy in now. Some of them probably should have been
fixed years ago, if we had prioritized optimally. But for many of them
our choices were probably correct. (In the case of the bugs that attract
the most attention, this is because the cost of fixing the bug is high,
not because the benefit is low.) [Less]
Posted
1 day
ago
by
Samuel Sidler
Talkback is getting huge. Most people don’t realize that the size of Talkback (the database and the amount of processing needed) has grown immensely in the last couple of years as the userbase of Firefox has grown. Talkback wasn’t made to scale
... [More]
in the way we’ve needed it to. This is one of the (many) reasons it’s being replaced in Firefox 3 with Breakpad/Socorro.
The Talkback database is now around 500 GB, which is way too large to be manageable. As a result, the scripts that removed old data are unable to complete and, thus, unable to lower the size of the database. There are several ways we can “fix” the issue:
Let the size of the database grow infinitely until Talkback is replaced.
Manually run clean up commands to (hopefully) keep the database in good shape.
Remove a bunch of data to all the scripts to run and move to keeping 60 days worth of data instead of 90.
There are advantages and disadvantages of all of these, but after some discussion, we’ve decided to do #3. Removing data will allow us to have a manageable database and will allow us to keep the database in shape for the long term by lowering the amount of data we keep.
Sadly, as a result of this, we’re going to lose some (critical) data. Namely, remove this data will affect full stacks, topcrash reports, and smart analysis reports.
Tomorrow we plan to take Talkback down for a few hours and do a full cold backup of the database. After the backup, next week we plan to remove full stacks from existing crash reports. If you have a stack you want to save, please put it in the relevant bug.
New reports will, of course, generate full stacks, but all stacks from old crash reports (about 90 days worth, give or take) will be gone. Because full stacks will be gone, the main topcrash reports will not necessarily be correct and the smart analysis reports will be completely broken (they rely on full stacks to generate properly). This will last for a period of 10 days, then both reports will return to normal.
Note: The removal of full stacks does not affect the stack signature. The signature will remain.
We know this situation isn’t ideal, but it’s just yet another reason to convince your friends to upgrade to Firefox 3.
If you have comments or questions, please email me. [Less]
Posted
1 day
ago
by
dmose
I don't recall who suggested Shredder as our code name originally, but they done good! Today I got the following compliment from a friend:btw dmose, thunderbird 3 alpha 1 deserves an award for best name for inducing fear of unstable development code...
Posted
1 day
ago
by
sheppy
Work continues apace. We’re in the process of installing a new build of Deki Wiki that enables caching support as well as other performance enhancements that should help deal with our load better. The new update also has some improvements to
... [More]
the editor and other changes we’ve requested. The folks at MindTouch have been really great to work with, and have bent over backward to make us happy.
A very minor skin tweak is forthcoming to deal with minor breakage that will be caused by the new build we’re installing today, but once those things are both done, I expect that we’ll be able to open things up for everybody to try out. [Less]
Posted
1 day
ago
by
david
I just got back from doing a podcast for RainCity Radio, with Zak, Boris, and Dave Olson as host.
The podcast was fun, as was the conversation afterwards with Zak and Boris. Unfortunately, the day was so beautiful that we went out for a
... [More]
beer to complement our strategy brainstorming. Nothing like drinking a good belgian beer in the sun to impact the afternoon’s productivity! Still, it resulted in some ideas bouncing around in our heads, and time will tell which ones survive.
Given that my brain was a bit shot, I decided to do what I seem to do now that I don’t have TV — watch some TED videos (preferably with Miro). I know, it’s awfully highbrow, but it’s what I seem to have lying around. I watched two. A relaxing one about artistic juggling, which is fun to watch, and Dave Eggers’ TED Prize wish video, which simply should be watched. Take the time and watch it, it’s butt-kickingly inspirational. [Less]
Posted
1 day
ago
by
Wil Clouser
As previously mentioned we’re planning on updating addons.mozilla.org for the 3.4.2 changes tonight. There are 32 bugs that will be fixed with the update.
Please let us know if you see any regressions or anything you’d like to see
... [More]
changed.
The next update is scheduled for May 29th and will be mainly a bug fix release with minor new features (like bug 432669). There are currently 28 bugs scheduled for the 3.4.3 push. [Less]
Posted
1 day
ago
by
Cesar
I started writing this a week and a half ago, but just finished it today.
First day at interning at Mozilla. I finally found out what I get to do this summer. I got the OK to blog about it, because you know how secret them Mozilla folks are
... [More]
about their secret in-house project (ie. What is this guy up to? ;)).
The actual wiki page was apparently out in the open, but no-one heard about it. It’s called WildOnAddons. While a new name is, IMO, mandatory, it’s actually a pretty neat idea. There are many great extensions such as Ted’s Extension Developer’s Extension that aren’t hosted on AMO. Some other extensions are hosted on AMO, but frequently have updates much sooner on their website before it goes public.
Sometimes, extensions come in bundled with packages such as Norton and McAfeee. Google Notebook is one of many Google Labs extension hosted on their own server.
In short, they’re hosted everywhere. But that presents a problem, how many are out there and can find and index them?
This is actually a lot harder then going on google and typing filetype:xpi, because according to those results, AMO only has 78 extensions. In fact, there are several repositories of addons each catering to a different crowd (yes, we are counting all addons). While I don’t think that AMO can satisfy everyone all the time. It might help us figure out how many extensions are out there and how many are hosted on our servers. Actually figuring this out will take a lot of work, and not as straight-forward as it sounds (ie. All of AMO’s sandboxed addons require authentication, so a web crawler would have to know about it if we were crawling through the web), but it will be worth it in the end.
I’ll keep blogging about it under wildon tag RSS feed if your interested on how progress goes. [Less]
Posted
1 day
ago
by
polvi
Last week Slater and I ( aza spoke) attended SF MusicTech.
The goal being to see what is going on in the modern music industry, particularly in tech. It definitely helped me realize that the music industry is not dead — just the “selling
... [More]
round plastic at a store” part is.
There were a couple re-occurring themes that I picked up on.
1) Artists seem to be gaining more control as everything moves on to this internet. That is, the internet is slowly cutting out the labels and artists are able to self promote.
2) There are various efforts to help bands “do good” while they have an audience. For example, one of pkim’s old friends, Erin Potts, runs a company called Air Traffic Control. They are pretty much dedicated to the idea of an artists ability to cause social change. I think this aligns pretty well with our ideas around “doing good AND promoting Firefox”.
3) The term “band-analytics” came up a few times. That is, the internet is helping bands understand their fan base — in ways never possible with-out it.
It was a very interesting conference, with many cool people. Slater had a nice conversation with folks from Pandora, and I got to meet Elise from Indie Pop Rocks! We are continuing to work on potential campaigns that promote artists along with Firefox. Hopefully we will have more to share more in the next couple weeks. [Less]
Posted
1 day
ago
by
seth bindernagel
Mean responses and the missing values
In the last two posts about survey 2, we learned the purpose of the survey and who took it.
For this post, we will start looking into the responses to our questions. Remember that we asked the
... [More]
following:
Please rate the overall quality of the support for each product;
How much does the user agree or disagree with a list of statements describing the support experience;
Please rate the usefulness of particular content types (tutorials, screencasts, chats, etc.).
We can start by summarizing the means to each answer, typically the easiest statistic to interpret and visualize. But, as a forewarning, the chart below is pretty long!
Darker bars are the mean responses and the thin vertical grey lines represent the levels of the scale for each question:
‘Lowest quality’ to ‘Highest quality’ for the first question
‘Strongly Disagree’, ‘Disagree’, ‘Neutral’, ‘Agree’ and ‘Strongly Agree’ for the remaining two questions
Perhaps it’s not surprising, but Firefox’s support was rated highest (our guess: because of its depth and completeness), whereas products like SeaMonkey, Calendar and Camino had a very high ratio of missing values (the ‘I don’t know’ responses). As the support rating lowers for each product, the percentage of the missing values increases, which also constitutes an important piece of information. 60-70% of the survey takers didn’t know how to rate the quality of support for SeaMonkey or Calendar—probably because they hadn’t used support or the application itself. For Firefox, we can say that its support was rated between 4 and 5, where 5 was “highest quality”. NB, only about 6% of the survey takers didn’t know how to rate Firefox support. Please keep in mind that every respondent was thinking about support in their language, so in our next post we will calculate the mean responses to this question for every locale.
For the next two questions, we should interpret the bars differently. Each of the thin vertical grey lines corresponds to a level starting with ‘Strongly Disagree’ on the left, through ‘Disagree’, ‘Neutral’, ‘Agree’ and, for the rightmost line, ‘Strongly Agree’. The length of the darker bar for the first statement means that, again on average, the respondents tended to agree that “the support sites loaded quickly.” As for the brighter bar, we interpret it in the same way as above: about 10% of the survey takers didn’t know how to react to this statement.
When you look at the average responses to the second question, you’ll see some interesting findings:
“Support in English is sufficient” scores lowest (between ‘disagree’ and ‘neutral’), and at the same time, it has very few missing values. So, people certainly had an opinion on this one since there were not many “Don’t Know” responses.
Two to three other statements have neutral response means (the corresponding dark bars end close to the middle of the chart)
Six statements show that the survey takers well above the midpoint and reflecting agreement.
Is this helpful data if we see mostly “Agrees”, “Neutrals” and one “Disagree”?
Keep in mind that every person who responded to these two questions reflected on their unique support experience and then submitted their response. Also, remember that support of the Mozilla products
can be accessed in different languages (and the quality of the support depends on quality of the localization),
is often decentralized (each local community has its own discussion board),
and aims to satisfy each users distinct needs.
If the cumulative responses were “Agree”, the means may still differ across certain groups of people. We can see that the “Most of the relevant support can be found in my language” statement scores high (respondents tended to agree with it), which is a good first step toward understanding how the local communities are doing in terms of the user-to-user support. One interesting thing to note is the “The support sites make use of video” statement. It scores low, but also has an outstanding ratio of missing values. Could you argue that an “I don’t know” answer is close to “Disagree”? If someone hadn’t ever seen a video on a support site, but was careful in their judgments and supposed that there might be other support sites where videocasts were available, they were probably more likely to answer “I don’t know” instead of “Disagree”. In this survey, we assumed that an “I don’t know” answer equaled “I haven’t ever seen any of them”. Therefore, we decided that the survey takers who described themselves as end-users were more likely to give an “I don’t know” answer to this statement.
Mean responses by user profile
Thanks to the user profile variable, we were ablt to split the cases and plot new charts for 3 different user profiles. These were community members (49% of respondents), active community members (localizing, coding, etc.; 32%) and end-users (19% of the survey takers).
We observe the biggest discrepancies between two extreme profiles: end-users and active contributors. The community member profile seems to be in the middle for most of the questions. For example, end-users rate the quality of the support for each product poorer than the contributors (green bars are longer than the yellow ones). More visible differences can also be observed in the “Most of the relevant support can be found in my language” statement. It seems that active contributors are more enthusiastic here. Why is this the case? Perhaps, it’s due to prior knowledge about the products (and computers in general), greater familiarity with the technology, and a better command of English. What do you think?
Two other statements bring forward even bigger differences in the way the end-users and the active contributors responded.
“The support sites make use of video”
Why do end-users agree more than active contributors that there are support sites using video? This is probably a result of what we have discussed above: respondents might have preferred the “I don’t know” answer to this question over “Strongly disagree” or “Disagree”, even if these ones would have been more accurate. We can see that there were nearly 50% of end-users answering “I don’t know” to this statement, and only half as many of the active contributors. Some end-users did agree on this topic, but some didn’t and we can assume that some of them selected the “I don’t know” answers instead of “Disagree”. Using this theory, we can understand why end-users scored this higher: there were not enough “disagree” responses to counterbalance the “agree” ones.
“Users rarely ask the same question more than once”
It seems understandable that active contributors are more likely to disagree. After all, they’d probably seen lots of duplicated questions in the forums and Bugzilla.
In the third question we see that end-users tend to favor direct communication (IM, VoIP) over text-based communication, compared to other user profiles. We also notice that forums turned out to be one of the most favorite channels of communication for active contributors—and much less so for the other profiles.
Finally, here is the graph of the missing values across different user profiles.
* * *
In the next posts we will reduce the number of variables by means of the factor analysis. This will allow us to better synthesize the analysis without loosing much of the information enclosed in the original set of variables.
Thanks for reading this to the end!! [Less]
Posted
1 day
ago
by
kkovash
We’ll eventually be talking a lot more about this, but for today, I wanted to present one slice of data that got me excited. Mozilla recently implemented Omniture as our web analytics solution for www.mozilla.com and we’re just starting to poke
... [More]
around in understanding how Firefox users interact with our web site. As an example, the report below shows the top 10 cities with visitors to mozilla.com so far in the month of May:
A few things that stand out:
Manila is #4!
There’s only one U.S. city in the top 10
Our web traffic has a verrrry long tail. The top 10 cities represent about 10% of our web traffic and the top 1,000 cities represents 83% of mozilla.com visitors. [Less]
