The Mozilla Blog: 11 secret tips for Firefox that will make you an internet pro

Среда, 09 Июня 2021 г. 00:40 + в цитатник

With Firefox, getting around the internet is fast, straight-forward and easy. Now you can go beyond the basics with these secret and not-so-secret tricks that make your internetting experience even more fun. Read on for some of our favorite Firefox features that you may not know about… yet.

1. Send tabs across the room

If you’ve ever been reading an article, recipe or website on your phone and thought it would look better and bigger on your computer, what do you do? Email or text yourself the link, right? Friends, there is a better way to do this with Firefox. Send that tab (or several tabs) to any device where you’re logged into your Firefox account, and it’ll be waiting for you when you get there. It also works in reverse, so you can send a tab from your computer to your phone as well. Pick up where you left off with send tabs in Firefox.

How to do it:

From Firefox on your computer: Right-click (PC) or two-finger tap (Mac) on a tab and select Send Tab to Device.
From Firefox on your phone: Tap the share icon, which will open up the Send to Device option.
Don’t see these options? Sign into your Firefox account on both devices, then they’ll appear.

2. Search for a needle in a tabstack

Tab hoarders, we see you. Heck, we are you. Don’t ever let anyone shame you for having dozens (and dozens³) of open tabs, implying you don’t have it together and can’t find the right one. Instead, dazzle them with this trick. Add a % sign to your URL search to search specifically through all your open tabs, including tabs in different windows. Then you can click over to the already open tab instead of creating a duplicate, not that anyone has ever done that.

Bonus tip: If you love that tab search trick, try searching through your Bookmarks with * or your History with ^.

3. Screenshots made simple

Ever need a screenshot, but don’t remember how to do it? Or you snapped one successfully but lost it in the bowels of your hard drive? The built-in Firefox screenshot feature takes all the stress away. Right-click (PC) or two-finger tap (Mac) to call up the Firefox action menu (see above tip) and scroll to Take Screenshot. Bam, you’re screenshotting!

Bonus tip: Here’s how to add a screenshot button to your Firefox toolbar so it’s at your fingertips.

4. Reopen a closed tab

Tabs are life, and life is in tabs. Closing the wrong one leads to that sinking oh no feeling we know all too well. So we made a fix for that.

How to do it: Type Ctrl + shift + T for PC. Command + shift + T for Mac. Boom, tab instantly resurrected. You can even do that multiple times to reopen multiple closed tabs.

5. Pocket the best for later

There is so much good stuff to read and watch online that you’re not going to finish the internet in your lifetime. But, you can save the best for later. Click the Pocket icon to save any article, video or page straight from Firefox. Then, when you’ve got some extra time on your hands, it’ll be waiting in the Pocket app (available for Android and iOS) on your phone. How brilliant is that?

Where to get it: Look for the Pocket symbol to the right of your toolbar to get started saving any article, video or page from Firefox.

6. Video multitasking with picture-in-picture

Got things to do and games to watch? One of our most popular features, picture-in-picture, lets you pop out a video from Firefox so that it plays over the other windows on your screen. It’s perfect for watching things on the side — sports, hearings, live news, soothing scenes and, even cute animals. Plus, it has multi-mode.

Where to get it: Hover over any playing video and look for the picture-in-picture icon. Try it:

7. Sample any color with the built-in eyedropper

This one is for the creators out there. The web is a colorful place, and every color has a code called a HEX value assigned to it. With the eyedropper tool built into Firefox, you can go around the web quickly sampling colors and copying the HEX value to use elsewhere.

How to use it: Click the main menu in the upper right corner, scroll to More Tools and then to the eyedropper. Have fun sampling!

8. Fuggedaboutit!

There might be times when you want to erase your recent browsing history super fast, and when that time comes, Firefox is here for you with the forget feature. Instead of asking a lot of complex technical questions, forget asks you only one: how much do you want to forget? Once you tell Firefox you want to forget the last 5 minutes, or 2 hours or 24 hours, it takes care of the rest. This is extra handy if you share a computer with friends or family. Or if you forgot to open a private browsing window. Or if you just don’t want your recent browsing history (~~royal family gossip~~) reappearing.

Where to get it:

Click the main menu in the upper right corner and select More Tools.
Next, select Customize Toolbar.
Locate the Forget shortcut
Grab it with your mouse and drag it up to the Toolbar.
Then click the Done button.
Now the Forget button is at your fingertips everywhere you go in Firefox.

9. Password headache fixer

If you’ve heard it once, you’ve heard it a million times — use strong unique passwords. You might complain that it’s easier said than done, but in Firefox it’s actually so easy to do. With the built-in password generator, you can create and save strong unique passwords without ever leaving Firefox. No extra downloads, software or sketchy websites needed. Bonus tip: Sync your Firefox account between multiple devices to get your logins and passwords on your mobile.

How to use it:

Right-click in the Password field and select Suggest Strong Password.

To find saved passwords on your computer: Click the main menu in the upper right corner and select Passwords.
To find saved passwords on your phone, go to your Firefox settings and select Logins and Passwords.

Bonus tip: Set up a Primary Password to guard all those strong, unique passwords.

10. Restore session

Everyone has been through the struggle of restarting their computer or just the browser and losing tabs. It’s soul draining. By default, Firefox starts with a single open window. If you want to get back to where you left off, use the session restore feature that revives everything you had open last time. Tap the main menu in the upper right. Click History, then select Restore Previous Session. Soul restored.

Make it permanent: You can set Firefox to always show the windows and tabs from your previous session each time you start Firefox. Here’s how.

11. The hidden menu

Maybe you know about this one, but for those who do not, it’s essential. You need to know about the hidden Firefox action menu that appears and changes depending on where you open it. When you open the menu on a website, an image or the menu bar, the actions are contextual to what you’re doing at the moment. Smart! Fun fact: The top 25 context menu entries cover 97% of the things people want to do.

How to use it: Right-click (PC) or two-finger tap (Mac) throughout Firefox.

Now that you’re practically a pro, pass this article onto your friends to share the secret tips of Firefox.

The post 11 secret tips for Firefox that will make you an internet pro appeared first on The Mozilla Blog.

https://blog.mozilla.org/en/products/firefox/firefox-tips/firefox-secret-tips/

Комментарии (0)

Dennis Schubert: WebCompat Tale: CSS Flexbox and the order of things

Вторник, 08 Июня 2021 г. 21:40 + в цитатник

Have you thought about the order of things recently? Purely from a web development perspective, I mean.

The chances are that you, just like me, usually don’t spend too much time thinking about the drawing order of elements on your site when writing HTML and CSS. And that’s generally fine because things usually just feel right. Consider the following little example:

Source:


span> id="order-demo-one">
  span> class="box first">

span> class="box second">

Result:

You could probably tell, without even looking at the result, that the second box - the red one - should be “on top”, completely covering up the blue box. After all, both boxes have the same size and the same position, but since the second box is placed after the first box, it’s drawn on top of the first one. To me, this feels pretty intuitive.

Let’s add some Flex to it

Now, let’s make things a bit more complicated. If you’re reading this article, I hope you’re at least slightly familiar with CSS Flexbox. And as you might know, flex-items have an order property, which you can use to reorder the items inside a flex container. Here’s the same example as before, but this time inside a flexbox container, with the items reordered. Note that this demo uses the same source as above, but I’m only showing relevant changes here.

Source:


span> id="order-demo-two">
  span> class="box first">

span> class="box second">

Result:

Okay, now we used order to swap positions of the first and second boxes. And as you can see in the demo … nothing changed. What? This is where things start becoming a bit counter-intuitive because this test case is actually a bit of a trick question.

Here is what the CSS Flexbox spec says about the order property:

A flex container lays out its content in order-modified document order, starting from the lowest numbered ordinal group and going up. Items with the same ordinal group are laid out in the order they appear in the source document.

This also affects the painting order, exactly as if the flex items were reordered in the source document.

Absolutely-positioned children of a flex container are treated as having order: 0 for the purpose of determining their painting order relative to flex items.

(List points added by me; the original is a single block of text.)

Point 1 is what we intuitively know. An element with order: 2 is shown after order: 1. So far, so good. Point 2, however, says that if you specify order, the elements should behave as if they have been reordered in the HTML. For our example above, this should mean that both of these HTML snippets should behave the same:

span> id="order-demo-two">
  span> class="box first">

span> class="box second">

span> id="order-demo-two">
  span> class="box second">

span> class="box first">

But we can clearly see that that’s not how it works. That is because in the spec text above, point 3 says that if a flex item is absolutely-positioned, it is always treated as having order: 0, so what we define in our CSS doesn’t actually matter.

Flex order, for real this time.

So instead of having the absolutely positioned element as the flex item, let’s build another demo that has the absolute element inside the flex item.

Source:


span> id="order-demo-three">
  span> class="box first">
    span> class="inner">

span> class="box second"> span> class="inner">

Result:

And now, I might have lost you. Because, as of the time of writing this, what you see as the result depends on which browser you read this blog post in. In Firefox, you’ll see the blue box on top; but pretty much everywhere else, the red box will still be on top.

The question now is: who is right? And instead of just telling you the answer, let’s work it out together. Rule 3 from above does not apply here: The flex items are not absolutely positioned, so the order should be taken into consideration. To check if that’s the case, we can look at rule 2: the code should behave the same if we reorder the elements in the HTML. We can build a test for that:

Source:

span> id="order-demo-four">
  span> class="box second">
    span> class="inner">

span> class="box first"> span> class="inner">

Result:

(again, the code is the same as the one in #order-demo-three, but I’m just showing the HTML to keep it easier to read)

If you’re reading this in Firefox, then the last two test cases behave the same: they’ll show the blue box. However, if you’re in Chrome, Safari, or Edge, there will be a difference: the first case will show the red box, the second case shows the blue box. If you now think that this is a bug in Blink and WebKit: you are right, and that bug has been known for a while.

Uh, what now?

This might sound like a super weird edge-case, and that’s probably right. It is a weird edge case. But unfortunately, as with pretty much all things that end up on my desk, we discovered this edge-case by investigating real-world breakage. Here, we received a report about the flight date picker on flydubai.com being broken, where in Firefox, there is an advertising banner on top of the picker. That’s caused by what I described here.

The Blink issue I linked earlier was opened in 2016, and there hasn’t been much progress on there since. I’m not saying this to blame Google folks; that’s just highlighting that changing things like this is a bit tricky sometimes. While there appears to be a consensus that Firefox is right, changing Chrome to match Firefox could result in an undefined number of broken sites. So you have to be careful when pushing such a change.

For now, I decided to go ahead and add a web-platform-test for this, because there is none yet. Currently, there’s also a cross-browser compat effort, “Compat2021”, going on, and CSS Flexbox is one of the key areas everyone wants to work on to make it a bit less of a pain for web developers. Maybe we can get some progress done on this issue as well. I will certainly try!

And with that, I have to end this post. There is no happy end, there isn’t even a certainty on what - if anything - will happen next. Sometimes, that’s the nature of our work. And I think that’s worth sharing, too.

https://overengineer.dev/blog/2021/06/08/webcompat-flex-order.html

Комментарии (0)

Hacks.Mozilla.Org: Implementing Private Fields for JavaScript

Вторник, 08 Июня 2021 г. 18:26 + в цитатник

This post is cross-posted from Matthew Gaudet’s blog

When implementing a language feature for JavaScript, an implementer must make decisions about how the language in the specification maps to the implementation. Sometimes this is fairly simple, where the specification and implementation can share much of the same terminology and algorithms. Other times, pressures in the implementation make it more challenging, requiring or pressuring the implementation strategy diverge to diverge from the language specification.

Private fields is an example of where the specification language and implementation reality diverge, at least in SpiderMonkey– the JavaScript engine which powers Firefox. To understand more, I’ll explain what private fields are, a couple of models for thinking about them, and explain why our implementation diverges from the specification language.

Private Fields

Private fields are a language feature being added to the JavaScript language through the TC39 proposal process, as part of the class fields proposal, which is at Stage 4 in the TC39 process. We will ship private fields and private methods in Firefox 90.

The private fields proposal adds a strict notion of ‘private state’ to the language. In the following example, #x may only be accessed by instances of class A:

class A {
  #x = 10;
}

This means that outside of the class, it is impossible to access that field. Unlike public fields for example, as the following example shows:

class A {
  #x = 10; // Private field
  y = 12; // Public Field
}

var a = new A();
a.y; // Accessing public field y: OK
a.#x; // Syntax error: reference to undeclared private field

Even various other tools that JavaScript gives you for interrogating objects are prevented from accessing private fields (e.g. Object.getOwnProperty{Symbols,Names} don’t list private fields; there’s no way to use Reflect.get to access them).

A Feature Three Ways

When talking about a feature in JavaScript, there are often three different aspects in play: the mental model, the specification, and the implementation.

The mental model provides the high-level thinking that we expect programmers to use mostly. The specification in turn provides the detail of the semantics required by the feature. The implementation can look wildly different from the specification text, so long as the specification semantics are maintained.

These three aspects shouldn’t produce different results for people reasoning through things (though, sometimes a ‘mental model’ is shorthand, and doesn’t accurately capture semantics in edge case scenarios).

We can look at private fields using these three aspects:

Mental Model

The most basic mental model one can have for private fields is what it says on the tin: fields, but private. Now, JS fields become properties on objects, so the mental model is perhaps ‘properties that can’t be accessed from outside the class’.

However, when we encounter proxies, this mental model breaks down a bit; trying to specify the semantics for ‘hidden properties’ and proxies is challenging (what happens when a Proxy is trying to provide access control to properties, if you aren’t supposed to be able see private fields with Proxies? Can subclasses access private fields? Do private fields participate in prototype inheritance?) . In order to preserve the desired privacy properties an alternative mental model became the way the committee thinks about private fields.

This alternative model is called the ‘WeakMap’ model. In this mental model you imagine that each class has a hidden weak map associated with each private field, such that you could hypothetically ‘desugar’

class A {
  #x = 15;
  g() {
    return this.#x;
  }
}

into something like

class A_desugared {
  static InaccessibleWeakMap_x = new WeakMap();
  constructor() {
    A_desugared.InaccessibleWeakMap_x.set(this, 15);
  }

  g() {
    return A_desugared.InaccessibleWeakMap_x.get(this);
  }
}

The WeakMap model is, surprisingly, not how the feature is written in the specification, but is an important part of the design intention is behind them. I will cover a bit later how this mental model shows up in places later.

Specification

The actual specification changes are provided by the class fields proposal, specifically the changes to the specification text. I won’t cover every piece of this specification text, but I’ll call out specific aspects to help elucidate the differences between specification text and implementation.

First, the specification adds the notion of [[PrivateName]], which is a globally unique field identifier. This global uniqueness is to ensure that two classes cannot access each other’s fields merely by having the same name.

function createClass() {
  return class {
    #x = 1;
    static getX(o) {
      return o.#x;
    }
  };
}

let [A, B] = [0, 1].map(createClass);
let a = new A();
let b = new B();

A.getX(a); // Allowed: Same class
A.getX(b); // Type Error, because different class.

The specification also adds a new ‘internal slot’, which is a specification level piece of internal state associated with an object in the spec, called [[PrivateFieldValues]] to all objects. [[PrivateFieldValues]] is a list of records of the form:

{
  [[PrivateName]]: Private Name,
  [[PrivateFieldValue]]: ECMAScript value
}

To manipulate this list, the specification adds four new algorithms:

These algorithms largely work as you would expect: PrivateFieldAdd appends an entry to the list (though, in the interest of trying to provide errors eagerly, if a matching Private Name already exists in the list, it will throw a TypeError. I’ll show how that can happen later). PrivateFieldGet retrieves a value stored in the list, keyed by a given Private name, etc.

The Constructor Override Trick

When I first started to read the specification, I was surprised to see that PrivateFieldAdd could throw. Given that it was only called from a constructor on the object being constructed, I had fully expected that the object would be freshly created, and therefore you’d not need to worry about a field already being there.

This turns out to be possible, a side effect of some of the specification’s handling of constructor return values. To be more concrete, the following is an example provided to me by Andr'e Bargull, which shows this in action.

class Base {
  constructor(o) {
    return o; // Note: We are returning the argument!
  }
}

class Stamper extends Base {
  #x = "stamped";
  static getX(o) {
    return o.#x;
  }
}

Stamper is a class which can ‘stamp’ its private field onto any object:

let obj = {};
new Stamper(obj); // obj now has private field #x
Stamper.getX(obj); // => "stamped"

This means that when we add private fields to an object we cannot assume it doesn’t have them already. This is where the pre-existence check in PrivateFieldAdd comes into play:

let obj2 = {};
new Stamper(obj2);
new Stamper(obj2); // Throws 'TypeError' due to pre-existence of private field

This ability to stamp private fields into arbitrary objects interacts with the WeakMap model a bit here as well. For example, given that you can stamp private fields onto any object, that means you could also stamp a private field onto a sealed object:

var obj3 = {};
Object.seal(obj3);
new Stamper(obj3);
Stamper.getX(obj3); // => "stamped"

If you imagine private fields as properties, this is uncomfortable, because it means you’re modifying an object that was sealed by a programmer to future modification. However, using the weak map model, it is totally acceptable, as you’re only using the sealed object as a key in the weak map.

PS: Just because you can stamp private fields into arbitrary objects, doesn’t mean you should: Please don’t do this.

Implementing the Specification

When faced with implementing the specification, there is a tension between following the letter of the specification, and doing something different to improve the implementation on some dimension.

Where it is possible to implement the steps of the specification directly, we prefer to do that, as it makes maintenance of features easier as specification changes are made. SpiderMonkey does this in many places. You will see sections of code that are transcriptions of specification algorithms, with step numbers for comments. Following the exact letter of the specification can also be helpful where the specification is highly complex and small divergences can lead to compatibility risks.

Sometimes however, there are good reasons to diverge from the specification language. JavaScript implementations have been honed for high performance for years, and there are many implementation tricks that have been applied to make that happen. Sometimes recasting a part of the specification in terms of code already written is the right thing to do, because that means the new code is also able to have the performance characteristics of the already written code.

Implementing Private Names

The specification language for Private Names already almost matches the semantics around Symbols, which already exist in SpiderMonkey. So adding PrivateNames as a special kind of Symbol is a fairly easy choice.

Implementing Private Fields

Looking at the specification for private fields, the specification implementation would be to add an extra hidden slot to every object in SpiderMonkey, which contains a reference to a list of {PrivateName, Value} pairs. However, implementing this directly has a number of clear downsides:

It adds memory usage to objects without private fields
It requires invasive addition of either new bytecodes or complexity to performance sensitive property access paths.

An alternative option is to diverge from the specification language, and implement only the semantics, not the actual specification algorithms. In the majority of cases, you really can think of private fields as special properties on objects that are hidden from reflection or introspection outside a class.

If we model private fields as properties, rather than a special side-list that is maintained with an object, we are able to take advantage of the fact that property manipulation is already extremely optimized in a JavaScript engine.

However, properties are subject to reflection. So if we model private fields as object properties, we need to ensure that reflection APIs don’t reveal them, and that you can’t get access to them via Proxies.

In SpiderMonkey, we elected to implement private fields as hidden properties in order to take advantage of all the optimized machinery that already exists for properties in the engine. When I started implementing this feature Andr'e Bargull – a SpiderMonkey contributor for many years – actually handed me a series of patches that had a good chunk of the private fields implementation already done, for which I was hugely grateful.

Using our special PrivateName symbols, we effectively desuagar

class A {
  #x = 10;
  x() {
    return this.#x;
  }
}

to something that looks closer to

class A_desugared {
  constructor() {
    this[PrivateSymbol(#x)] = 10;
  }
  x() {
    return this[PrivateSymbol(#x)];
  }
}

Private fields have slightly different semantics than properties however. They are designed to issue errors on patterns expected to be programming mistakes, rather than silently accepting it. For example:

Accessing an a property on an object that doesn’t have it returns undefined. Private fields are specified to throw a TypeError, as a result of the PrivateFieldGet algorithm.
Setting a property on an object that doesn’t have it simply adds the property. Private fields will throw a TypeError in PrivateFieldSet.
Adding a private field to an object that already has that field also throws a TypeError in PrivateFieldAdd. See “The Constructor Override Trick” above for how this can happen.

To handle the different semantics, we modified the bytecode emission for private field accesses. We added a new bytecode op, CheckPrivateField which verifies an object has the correct state for a given private field. This means throwing an exception if the property is missing or present, as appropriate for Get/Set or Add. CheckPrivateField is emitted just before using the regular ‘computed property name’ path (the one used for A[someKey]).

CheckPrivateField is designed such that we can easily implement an inline cache using CacheIR. Since we are storing private fields as properties, we can use the Shape of an object as a guard, and simply return the appropriate boolean value. The Shape of an object in SpiderMonkey determines what properties it has, and where they are located in the storage for that object. Objects that have the same shape are guaranteed to have the same properties, and it’s a perfect check for an IC for CheckPrivateField.

Other modifications we made to make to the engine include omitting private fields from the property enumeration protocol, and allowing the extension of sealed objects if we are adding private field.

Proxies

Proxies presented us a bit of a new challenge. Concretely, using the Stamper class above, you can add a private field directly to a Proxy:

let obj3 = {};
let proxy = new Proxy(obj3, handler);
new Stamper(proxy)

Stamper.getX(proxy) // => "stamped"
Stamper.getX(obj3)  // TypeError, private field is stamped
                    // onto the Proxy Not the target!

I definitely found this surprising initially. The reason I found this surprising was I had expected that, like other operations, the addition of a private field would tunnel through the proxy to the target. However, once I was able to internalize the WeakMap mental model, I was able to understand this example much better. The trick is that in the WeakMap model, it is the Proxy, not the target object, used as the key in the #x WeakMap.

These semantics presented a challenge to our implementation choice to model private fields as hidden properties however, as SpiderMonkey’s Proxies are highly specialized objects that do not have room for arbitrary properties. In order to support this case, we added a new reserved slot for an ‘expando’ object. The expando is an object allocated lazily that acts as the holder for dynamically added properties on the proxy. This pattern is used already for DOM objects, which are typically implemented as C++ objects with no room for extra properties. So if you write document.foo = "hi", this allocates an expando object for document, and puts the foo property and value in there instead. Returning to private fields, when #x is accessed on a Proxy, the proxy code knows to go and look in the expando object for that property.

In Conclusion

Private Fields is an instance of implementing a JavaScript language feature where directly implementing the specification as written would be less performant than re-casting the specification in terms of already optimized engine primitives. Yet, that recasting itself can require some problem solving not present in the specification.

At the end, I am fairly happy with the choices made for our implementation of Private Fields, and am excited to see it finally enter the world!

Acknowledgements

I have to thank, again, Andr'e Bargull, who provided the first set of patches and laid down an excellent trail for me to follow. His work made finishing private fields much easier, as he’d already put a lot of thought into decision making.

Jason Orendorff has been an excellent and patient mentor as I have worked through this implementation, including two separate implementations of the private field bytecode, as well as two separate implementations of proxy support.

Thanks to Caroline Cullen, and Iain Ireland for helping to read drafts of this post, and to Steve Fink for fixing many typos.

The post Implementing Private Fields for JavaScript appeared first on Mozilla Hacks - the Web developer blog.

https://hacks.mozilla.org/2021/06/implementing-private-fields-for-javascript/

Комментарии (0)

The Talospace Project: Firefox 89 on POWER

Вторник, 08 Июня 2021 г. 04:37 + в цитатник

Firefox 89 was released last week with much fanfare over its new interface, though being the curmudgeon I am I'm less enamoured of it. I like the improvements to menus and doorhangers but I'm a big user of compact tabs, which were deprecated, and even with compact mode surreptitously enabled the tab bar is still about a third or so bigger than Firefox 88 (see screenshot). There do seem to be some other performance improvements, though, plus the usual more lower-level changes and WebRender is now on by default for all Linux configurations, including for you fools out there trying to run Nvidia GPUs.

The chief problem is that Fx89 may not compile correctly with certain versions of gcc 11 (see bugs 1710235 and 1713968). For Fedora users if you aren't on 11.1.1-3 (the current version as of this writing) you won't be able to compile the browser at all, and you may not be able to compile it fully even then without putting a # pragma GCC diagnostic ignored "-Wnonnull" at the top of js/src/builtin/streams/PipeToState.cpp (I still can't; see bug 1713968). gcc 10 is unaffected. I used the same .mozconfigs and PGO-LTO optimization patches as we used for Firefox 88. With those changes the browser runs well.

While waiting for the updated gcc I decided to see if clang/clang++ could now build the browser completely on ppc64le (it couldn't before), even though gcc remains my preferred compiler as it generates higher performance objects. The answer is now it can and this time it did, merely by substituting clang for gcc in the .mozconfig, but even using the bfd linker it makes a defective Firefox that freezes or crashes outright on startup; it could not proceed to the second phase of PGO-LTO and the build system aborted with an opaque error -139. So much for that. For the time being I think I'd rather spend my free cycles on the OpenPOWER JavaScript JIT than figuring out why clang still sucks at this.

Some of you will also have noticed the Mac-style pulldown menus in the screenshot, even though this Talos II is running Fedora 34. This comes from firefox-appmenu, which since I build from source is trivial to patch in, and the Fildem global menu GNOME extension (additional tips) paired with my own custom gnome-shell theme. I don't relish adding another GNOME extension that Fedora 35 is certain to break, but it's kind of nice to engage my Mac mouse-le memory and it also gives me a little extra vertical room. You'll notice the window also lacks client-side decorations since I can just close the window with key combinations; this gives me a little extra horizontal tab room too. If you want that, don't apply this particular patch from the firefox-appmenu series and just use the other two .patches.

https://www.talospace.com/2021/06/firefox-89-on-power.html

Комментарии (0)

The Mozilla Blog: Feel at home on your iPhone and iPad with Firefox

Понедельник, 07 Июня 2021 г. 19:00 + в цитатник

When we set out earlier this year to reimagine Firefox for desktop to be simpler, more modern and faster to use, we didn’t forget about your Apple mobile devices. We use our laptops and computers for work and play, but our tablets and phones sit a lot closer. They’re the first screens we see in the morning, and the last we see before we go to bed.

Firefox is only one of the many apps you use throughout the day, so our browser can’t just look good. It also needs to feel at home. The newest Firefox for iOS and iPadOS represents what we think online life should be: fast, beautiful and private – presented in a package that looks and feels intuitive and natural.

It’s fast

You can already one-tap to go to your top sites, and we’ve brought the same speed to search. Every time Firefox or a new tab opens, the keyboard will now come up, ready for you to start searching right away.

When typing takes too long, you can build search suggestions word by word.

Firefox syncs your bookmarks, history, passwords and more between devices. But when you have many tabs open on your iPhone, iPad and computer, they’re often hard to find. Now you can simply start typing the tab’s name, and Firefox will show the tabs you have opened, no matter where they’re located.

And if you don’t quite know what something is called, you can browse for it easily. Open the main application menu, and all your bookmarks, history, downloads and reading list are there.

It’s beautiful

We’ve rebuilt parts of Firefox in native components, making it feel more iPhone and iPad-like than ever before. You’ll notice design elements that look and work identically to those found in many other apps, so our browser feels instantly familiar. We’ve also taken a major step up in accessibility. Firefox now supports more text sizes and integrates better with screen readers.

Our menus take up less space and work like all other menus you’re used to.

All your tabs, including ones synced from other devices, now appear side by side. And your bookmarks, history, downloads and reading list are browsed just like tabs do. Switching between them is a breeze.

And we’ve given Firefox for iPadOS the same productivity-inspired new tab design, simplified navigation and streamlined menus. Your favourite browser now looks and feels consistent, no matter where you are.

It’s private

The App Store now includes app privacy labels that help you understand our data collection practices.

Here’s what we collect and why:

When you sign into your Firefox account with your email, you’ll receive updates about all the awesome things happening at Mozilla in your inbox. You can manage your Newsletter subscriptions here.

You may choose to share information about feature usage, crashes and other technical data with us. We collect them, but we do not link them to your Firefox account identity! This information helps us improve Firefox performance and stability, and to support our marketing. You can read more about it here.

What’s next for Firefox

We’re excited to share a fast, beautiful and private Firefox experience across all your devices. No matter what device you choose to tackle the web in the future, Firefox will be there for you. Download the latest version of Firefox for your iOS and Mac and to experience the latest fresh clean look and feel.

The post Feel at home on your iPhone and iPad with Firefox appeared first on The Mozilla Blog.

https://blog.mozilla.org/en/products/firefox/feel-at-home-on-your-iphone-and-ipad-with-firefox/

Комментарии (0)

Daniel Stenberg: Bye bye metalink in curl

Понедельник, 07 Июня 2021 г. 10:06 + в цитатник

In 2012 I wrote a blog post titled curling the metalink, describing how we added support for metalink to curl.

Today, we remove that support again. This is a very drastic move, and I feel obliged to explain it so here it goes! curl 7.78.0 will ship without metalink support.

Metalink problems

There were several issues found that combined led us to this move.

Security problems

We’ve found several security problems and issues involving the metalink support in curl. The issues are not detailed here because they’ve not been made public yet.

When working on these issues, it become apparent to the curl security team that several of the problems are due to the system design, metalink library API and what the metalink RFC says. They are very hard to fix on the curl side only.

Unusual use pattern

Metalink usage with curl was only very briefly documented and was not following the “normal” curl usage pattern in several ways, making it surprising and non-intuitive which could lead to further security issues.

libmetalink is abandoned

The metalink library libmetalink was last updated 6 years ago and wasn’t very actively maintained the years before that either. An unmaintained library means there’s a security problem waiting to happen. This is probably reason enough.

XML is heavy

Metalink requires an XML parsing library, which is complex code (even the smaller alternatives) and to this day often gets security updates.

Not used much

Metalink is not a widely used curl feature. In the 2020 curl user survey, only 1.4% of the responders said that they’d are using it. In the just closed 2021 survey that number shrunk to 1.2%. Searching the web also show very few traces of it being used, even with other tools.

The torrent format and associated technology clearly won for downloading large files from multiple sources in parallel.

Violating a basic principle

This change unfortunately breaks command lines that uses --metalink. This move goes directly against one of our basic principles as it doesn’t maintain behavior with previous versions. We’re very sorry about this but we don’t see a way out of this pickle that also takes care of user’s security – which is another basic principle of ours. We think the security concern trumps the other concerns.

Possible to bring back?

The list above contains reasons for the removal. At least some of them can be addressed given enough efforts and work put into it. If someone is willing to do the necessary investment, I think we could entertain the possibility that support can be brought back in a future. I just don’t think it is very probable.

Credits

Image by Ron Porter from Pixabay

https://daniel.haxx.se/blog/2021/06/07/bye-bye-metalink-in-curl/

Комментарии (0)

The Talospace Project: Progress on the OpenPOWER SpiderMonkey JIT

Воскресенье, 06 Июня 2021 г. 02:53 + в цитатник

Progress!

% gdb --args obj/dist/bin/js --no-baseline --no-ion --no-native-regexp --blinterp-eager -e 'print("hello world")' GNU gdb (GDB) Fedora 10.1-14.fc34 Copyright (C) 2020 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later /gnu.org/licenses/gpl.html> This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Type "show copying" and "show warranty" for details. This GDB was configured as "ppc64le-redhat-linux-gnu". Type "show configuration" for configuration details. For bug reporting instructions, please see: /www.gnu.org/software/gdb/bugs/>. Find the GDB manual and other documentation resources online at: /www.gnu.org/software/gdb/documentation/>. For help, type "help". Type "apropos word" to search for commands related to "word"... Reading symbols from obj/dist/bin/js... (gdb) run Starting program: obj/dist/bin/js --no-baseline --no-ion --no-native-regexp --blinterp-eager -e print\(\"hello\ world\"\) warning: Expected absolute pathname for libpthread in the inferior, but got .gnu_debugdata for /lib64/libpthread.so.0. warning: Unable to find libthread_db matching inferior's thread library, thread debugging will not be available. [New LWP 2797069] [LWP 2797069 exited] [New LWP 2797070] [New LWP 2797071] [New LWP 2797072] [New LWP 2797073] [New LWP 2797074] [New LWP 2797075] [New LWP 2797076] [New LWP 2797077] hello world [LWP 2797072 exited] [LWP 2797070 exited] [LWP 2797074 exited] [LWP 2797077 exited] [LWP 2797073 exited] [LWP 2797071 exited] [LWP 2797076 exited] [LWP 2797075 exited] [Inferior 1 (process 2797041) exited normally]

This may not look like much, but it demonstrates that the current version of the OpenPOWER JavaScript JIT for Firefox can emit machine language instructions correctly (mostly — still more codegen bugs to shake out), handles the instruction cache correctly, handles ABI-compliant calls into the SpiderMonkey VM correctly (the IonMonkey JIT is not ABI-compliant except at those edges), and enters and exits routines without making a mess of the stack. Much of the code originates from TenFourFox's "IonPower" 32-bit PowerPC JIT, though obviously greatly expanded, and there is still ongoing work to make sure it is properly 64-bit aware and takes advantage of instructions available in later versions of the Power ISA. (No more spills to the stack to convert floating point, for example. Yay for VSX!)

Although it is only the lowest level of the JIT, what Mozilla calls the Baseline Interpreter, there is substantial code in common between the Baseline Interpreter and the second-stage Baseline Compiler. Because it has much less overhead compared to Baseline Compiler and to the full-fledged Ion JIT, the Baseline Interpreter can significantly improve page loads all by itself. In fact, my next step might be to get regular expressions and the OpenPOWER Baseline Interpreter to pass the test suite and then drag that into a current version of Firefox for continued work so that it can get banged on for reliability and improve performance for those people who want to build it (analogous to how we got PPCBC running first before full-fledged IonPower in TenFourFox). Eventually full Ion JIT and Wasm support should follow, though those both use rather different codepaths apart from the fundamental portions of the backend which still need to be shaped.

A big shout-out goes to Justin Hibbits, who took TenFourFox's code and merged it with the work I had initially done on JitPower way back in the Firefox 62 days but was never able to finish. With him having done most of the grunt work, I was able to get it to compile and then started attacking the various bugs in it.

Want to contribute? It's on Github. Tracing down bugs is labour-intensive, and involves a lot of emitting trap instructions and single-stepping in the debugger, but when you see those small steps add up into meaningful fixes (man, it was great to see those two words appear) it's really rewarding. I'm happy to give tips to anyone who wants to participate. Once it can pass the test suite at some JIT level, it will be time to forward-port it and if we can get our skates on it might even be possible to upstream it into the next Firefox ESR.

For better or worse, the Web is a runtime. Let's get OpenPOWER workstations running it better.

https://www.talospace.com/2021/06/progress-on-openpower-spidermonkey-jit.html

Комментарии (0)

Mozilla Privacy Blog: The Van Buren decision is a strong step forward for public interest research online

Суббота, 05 Июня 2021 г. 00:30 + в цитатник

In a victory for security research and other public interest work, yesterday the U.S Supreme Court held that the Computer Fraud and Abuse Act’s (CFAA) “exceeding authorized access” provision should be narrowly interpreted and cannot be used to criminalize every single violation of a computer-use policy. This is encouraging news for journalists, bug bounty hunters, social science researchers, and many other practitioners who could legitimately access information in a myriad of ways but were at the risk of being prosecuted as criminals.

As we stated in our joint amicus brief to the Court in July 2020, over the years some federal circuit courts had interpreted the CFAA so broadly as to threaten important practices to protect the public, including research and disclosure of software vulnerabilities by those in the security community. The scope of such broad interpretation went beyond security management and has also been used to stifle legitimate public interest research, such as looking into the advertising practices of online platforms, something Mozilla has pushed back against in the past.

In its ruling, the Supreme Court held that authorized access under the CFAA is not exceeded when information is accessed on a computer for a purpose that the system owner considers improper. For example, the ruling clarifies that employees would not violate the CFAA simply by using a work computer to check personal email if that is contrary to the company’s computer use policies. The decision overrules some of the most expansive interpretations of the CFAA and makes it less likely that the law will be used to chill legitimate research and disclosures. The decision does, however, leave some open questions on the role of contractual limits in the CFAA that will likely have to be settled via litigation over the coming years.

However, the net impact of the decision leaves the “exceeding authorized access” debate under the CFAA in a much better place than when it began and should be celebrated as a clear endorsement of the years of efforts by various digital rights organizations to limit its chilling effects with the goal of protecting public interest research, including in cybersecurity.

The post The Van Buren decision is a strong step forward for public interest research online appeared first on Open Policy & Advocacy.

https://blog.mozilla.org/netpolicy/2021/06/04/the-van-buren-decision-is-a-strong-step-forward-for-public-interest-research-online/

Комментарии (0)

Firefox Nightly: These Weeks in Firefox: Issue 95

Пятница, 04 Июня 2021 г. 18:26 + в цитатник

https://blog.nightly.mozilla.org/2021/06/04/these-weeks-in-firefox-issue-95/

Комментарии (0)

Ryan Harter: Getting Credit for Invisible Work

Четверг, 03 Июня 2021 г. 10:00 + в цитатник

Last month I gave a talk at csv,conf on "Getting Credit for Invisible Work". The (amazing) csv,conf organizers just published a recording of the talk. (slides here). Give it a watch! It's only 20m long (including the Q&A).

Invisible work is a concept I've been trying to …

https://blog.harterrt.com/invisible-work.html

Комментарии (0)

About:Community: Firefox 89: The New Contributors To MR1

Среда, 02 Июня 2021 г. 22:29 + в цитатник

Firefox 89 would not have been possible without our community, and it is a great privilege for us to thank all the developers who contributed their first code change to MR1, 44 of whom were brand new volunteers!

rai.ankur0007: 1695253
rashadmad: 1702452
ryedu.09: 1633416, 1703119
theodorasabalou: 1703126
toby.she: 1703697
tom: 1695466
Aditi Singh: 1703128
Anshul Sahai: 1700195, 1702013
Ashita: 1697644, 1698105, 1699276
Ashwini Wankhede: 1702601, 1703597, 1703599
Bukola Felicia Akinnadeju: 1703596, 1704060, 1704976
Cameron: 1687318
Claudia Batista: 1625651, 1651012, 1701903
Darryl Pogue: 1350237
Dawit: 1701250
Dhanesh: 1679985, 1685806
Dylan Franken: 1680751
Evgenia Kotovich: 1703598, 1705198
Filipa Rocha: 1703131
Garima Mazumdar: 1687586, 1698595
George A. Michel: 1703408
Hamza Mahfooz: 1701460
Justus Winter: 1698510
Kajal Sah: 1664259, 1673269, 1701461, 1702538, 1702539, 1702542, 1702543, 1702557, 1702558, 1702559, 1702565, 1702567, 1702568, 1702570, 1702572, 1702573, 1702574, 1702575, 1702576, 1702578
Leslie: 1702451
Lia: 1699277
Luz De La Rosa: 1703579, 1703586, 1703626
Manuel Carretero: 1575105, 1667943
Michelle: 1704006
Osagie: 1702371
RJ Johnson: 1697721
Ramya Praneetha ramya: 1676067
Robert Bryer: 1698401
Sarah Ukoha: 1663143, 1700412, 1703813
Swapnik Katkoori: 1697616
TheEvilSkeleton: 1648029
Thomas Kluyver: 1705130
Tilda Udufo: 1631570
Umar: 1703155
Victor Alvarez: 1704425
akshita gupta: 1622676
disha: 1702372
mehaboob shariff: 1699273
pavel: 1699275, 1699279

https://blog.mozilla.org/community/2021/06/02/firefox-89-the-new-contributors-to-mr1/

Комментарии (0)

Data@Mozilla: This week in Glean: Glean Dictionary updates

Среда, 02 Июня 2021 г. 19:16 + в цитатник

https://blog.mozilla.org/data/2021/06/02/this-week-in-glean-glean-dictionary-updates/

Комментарии (0)

William Lachance: Glean Dictionary updates

Среда, 02 Июня 2021 г. 19:01 + в цитатник

https://wrla.ch/blog/2021/06/glean-dictionary-updates/?utm_source=Mozilla&utm_medium=RSS

Комментарии (0)

Mozilla Security Blog: Updating GPG key for signing Firefox Releases

Среда, 02 Июня 2021 г. 11:29 + в цитатник

Mozilla offers GPG signing to let you verify the integrity of our Firefox builds. GPG signatures for Linux based builds are particularly important, because it allows Linux distributions and other repackagers to verify that the source code they use to build Firefox actually comes from Mozilla.

We regularly rotate our GPG signing subkey — usually every two years — to guard against the unlikely possibility that the key has been leaked without our knowledge. Last week, such a rotation happened, and we switched over to the new signing subkey.

The new GPG subkey’s fingerprint is 14F2 6682 D091 6CDD 81E3 7B6D 61B7 B526 D98F 0353, and will expire on 2023-05-17.

If you are interested in performing a verification of your copy of Firefox, you can fetch the public key directly from our KEY files from the Firefox 89 release, or alternatively directly from below.

The post Updating GPG key for signing Firefox Releases appeared first on Mozilla Security Blog.

https://blog.mozilla.org/security/2021/06/02/updating-gpg-key-for-signing-firefox-releases/

Комментарии (0)

The Mozilla Blog: Sharing your deepest emotions online: Did 2020 change the future of therapy?

Вторник, 01 Июня 2021 г. 18:59 + в цитатник

COVID-19 forced the U.S. into a new era of telehealth. Therapists hope it’s here to stay.

———

2020 was the worst year of Kali’s life.

“Going through something like the pandemic and not having family around, feeling out of control—I was on edge all year,” says the 30-year-old Colorado resident. And she wasn’t alone.

Amid the COVID-19 lockdowns of early 2020, millions of Americans found themselves trapped at home with a backlog of unaddressed mental-health issues. As with so many other things, computer screens and video calls became the only portals out of lockdown—for work, entertainment and, ultimately, real psychological help.

By spring 2020, nearly all therapy was forced online, a shift that initially worried therapists and patients alike.

“You do all these years of school to become a psychologist and all the training is in-person,” says Dr. Justin Puder, a therapist and licensed psychologist based in Boca Raton, Florida. “So when you transition to online, you have these doubts—will the connection be as genuine? Will it be as effective?”

But by summer, many therapists, including Puder, were experiencing an unprecedented surge in new-patient inquiries.

“About six months into the pandemic, I was over capacity, and that was the first time that my private practice had filled up like that,” Puder says.

Many of Puder’s clients were teens or young adults struggling with the transition to online school and the loss of important milestones like prom or graduation. Other therapists, like Dr. Jeff Rocker in Miami, Florida, saw an influx of Black men seeking therapy after a summer of highly publicized shootings of unarmed Black males at the hands of police. Others still, like K. Michelle Johnson, a sex and relationship coach and therapist based in Denver, Colorado, saw their practices flooded with struggling couples.

“I think the pandemic created a bit of a pressure cooker for people who were suddenly unable to avoid or escape the issues they’d been having,” Johnson says.

For Johnson’s clients, the shift to virtual therapy had both pros and cons. One issue was privacy. Virtual therapy nearly always takes place on specialized HIPAA-compliant platforms that ensure a secure connection, but interruptions from nosy roommates, curious children and needy pets are facts of life at home.

Still, Jennifer Dunkle, a Certified Gottman Couples Therapist who specializes in financial coaching and is based in Fort Collins, Colorado, says many of the parents she works with still prefer online therapy—it freed them to get the help they needed without having to find or pay for childcare, she says.

That new therapy-from-anywhere paradigm has also helped improve access for people in more rural settings. Angela, 31, raises pigs and vegetables with her partner on a farm in southern Colorado. They live about 60 miles from the nearest mental health center.

With that commute, “Going into therapy could be a three-hour ordeal,” Angela says. “So virtual—I’m all about it.”

The Pocket Joy List Project

The stories, podcasts, poems and songs we always come back to

Virtual therapy also just feels more accessible for some patients.

Haley, a 26-year-old in Atlanta, Georgia, says the idea of having to meet a therapist face-to-face had always intimidated her. That was compounded by anxiety around having to locate a new office, find parking and be somewhere on time. Conversely, just opening up a laptop from the comfort of her kitchen or bedroom? “That felt so much easier,” she says.

Puder suspects that there’s another phenomenon at play in the public’s newfound openness to virtual therapy: social media.

Puder currently has 335,000 followers on his TikTok. Rocker, better known in Miami as the “Celebrity Therapist” for his work with elite athletes and entertainers, has over 62,000 followers on Instagram. Both are part of a new wave of influencer-therapists who build their followings through bite-size mental health tips, often infused with humor and a lot of personality.

The trend has been enormously effective, Rocker says.

“People are seeing that there are so many different approaches and ethnicities and cultures within the mental health space,” Rocker says. “People are seeing that they can receive mental health services from people who look like them and talk like them and who they can relate to.”

Puder also suspects that TikTok’s rise in popularity during the pandemic has helped cultivate a new light-hearted, open, stigma-free approach to mental health, which has in turn encouraged more people to give therapy a try. After all, the difference between watching weekly videos from your favorite therapist and signing up for weekly video chats is an easy leap to make.

Better yet: According to a 2018 analysis of 64 different trials, internet-delivered therapy is just as effective as face-to-face therapy. And for some patients, it could be even more effective. Johnson reports that when clients can talk to her from a serene setting like a park, they’re able to open up and be more vulnerable than they may have been in person.

“With virtual therapy, there’s that little bit of separation between me and the client,” she says. “Sometimes that helps them let their guard down a little more.”

Kali had been going to therapy for years to help her manage her anxiety and depression. Pre-pandemic, she says she never would have considered virtual therapy. But between the political and social unrest and general pandemic anxiety, she found herself making the switch from weekly in-person sessions to weekly online sessions — something she said was “absolutely” critical to her surviving 2020.

“I genuinely have no idea what I would have done without it,” she says. “I don’t know that I would have made it through this year.”

While she looks forward to going back to in-person sessions, Kali says her opinions of virtual therapy have changed.

“I do feel like that deep connection can still be felt,” she says, “Now when I’m away on a trip, I’m more inclined to keep therapy on the schedule.”

Johnson doesn’t expect virtual therapy to ever completely replace in-person therapy. After all, in-person sessions are still a better fit for some clients, like those who may be starting deep trauma work, she says. Rocker adds that kids and teens often have trouble focusing on a screen.

But one thing is certain: Virtual therapy is here to stay, and the events of 2020 have pushed the mental health conversation in America into a new era—one Puder expects to snowball as more people continue to try therapy and talk about it online.

“When you have the opportunity to be vulnerable and talk about a low you’re in, it’s freeing,” he says. “And I think when people get a taste of that, they’ll continue the conversation.”

The post Sharing your deepest emotions online: Did 2020 change the future of therapy? appeared first on The Mozilla Blog.

https://blog.mozilla.org/en/internet-culture/deep-dives/online-zoom-therapy-after-covid19-pandemic/

Комментарии (0)

Hacks.Mozilla.Org: Looking fine with Firefox 89

Вторник, 01 Июня 2021 г. 18:19 + в цитатник

While we’re sitting here feeling a bit frumpy after a year with reduced activity, Firefox 89 has smartened up and brings with it a slimmed down, slightly more minimalist interface.

Along with this new look, we get some great styling features including a force-colors feature for media queries and better control over how fonts are displayed. The long awaited top-level await keyword for JavaScript modules is now enabled, as well as the PerformanceEventTiming interface, which is another addition to the performance suite of APIs: 89 really has been working out!

This blog post provides merely a set of highlights; for all the details, check out the following:

forced-colors media feature

The forced-colors CSS media feature detects if a user agent restricts the color palette used on a web page. For instance Windows has a High Contrast mode. If it’s turned on, using forced-colors: active within a CSS media query would apply the styles nested inside.

In this example we have a .button class that declares a box-shadow property, giving any HTML element using that class a nice drop-shadow.

If forced-colors mode is active, this shadow would not be rendered, so instead we’re declaring a border to make up for the shadow loss:

.button {
  border: 0;
  padding: 10px;
  box-shadow: -2px -2px 5px gray, 2px 2px 5px gray;
}

@media (forced-colors: active) {
  .button {
    /* Use a border instead, since box-shadow is forced to 'none' in forced-colors mode */
    border: 2px ButtonText solid;
  }
}

Better control for displayed fonts

Firefox 89 brings with it the line-gap-override, ascent-override and descent-override CSS properties. These allow developers more control over how fonts are displayed. The following snippet shows just how useful these properties are when using a local fallback font:

@font-face {
  font-family: web-font;
  src: url("/example.com/font.woff>");
}

@font-face {
  font-family: local-font;
  src: local(Local Font);
  ascent-override: 90%;
  descent-override: 110%;
  line-gap-override: 120%;
}

These new properties help to reduce layout shift when fonts are loading, as developers can better match the intricacies of a local font with a web font. They work alongside the size-adjust property which is currently behind a preference in Firefox 89.

Top-level await

If you’ve been writing JavaScript over the past few years you’ve more than likely become familiar with async functions. Now the await keyword, usually confined to use within an async function, has been given independence and allowed to go it alone. As long as it stays within modules that is.

In short, this means JavaScript modules that have child modules using top level await wait for that child to execute before they themselves run. All while not blocking other child modules from loading.

Here is a very small example of a module using the >a href=”https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API”>Fetch API and specifying await within the export statement. Any modules that include this will wait for the fetch to resolve before running any code.

// fetch request
const colors = fetch('../data/colors.json')
  .then(response => response.json());

export default await colors;

PerformanceEventTiming

A new look can’t go unnoticed without mentioning performance. There’s a plethora of Performance APIs, which give developers granular power over their own bespoke performance tests. The PerformanceEventTiming interface is now available in Firefox 89 and provides timing information for a whole array of events. It adds yet another extremely useful feature for developers by cleverly giving information about when a user-triggered event starts and when it ends. A very welcome addition to the new release.

The post Looking fine with Firefox 89 appeared first on Mozilla Hacks - the Web developer blog.

https://hacks.mozilla.org/2021/06/looking-fine-with-firefox-89/

Комментарии (0)

Henri Sivonen: Bogo-XML Declaration Returns to Gecko

Вторник, 01 Июня 2021 г. 17:02 + в цитатник

Firefox 89 was released today. This release (again!) honors a character encoding declaration made via syntax that looks like an XML declaration used in text/html (if there are no other character encoding declarations).

Before HTML parsing was specified, Internet Explorer did not support declaring the encoding of a text/html document using the XML declaration syntax. However, Gecko, WebKit, and Presto did. Unfortunately, I didn’t realize that they did.

When Hixie specified HTML parsing, consistent with IE, he didn’t make the spec sensitive to the XML declaration syntax in a particular way. I am unable to locate any discussion in the WHATWG mailing list archives about whether an encoding declaration made using the XML declaration syntax in text/html should be honored when processing text/html.

When I implemented the specified HTML parsing algorithm in Gecko, I also implemented the internal encoding declaration handling per specification. As a side effect, in Firefox 4, I removed Gecko’s support for the XML declaration syntax for declaring the character encoding in text/html. I don’t recall this having been a knowingly-made decision: The rewrite just did strictly what the spec said.

When WebKit and Presto implemented the specified HTML parsing algorithm, they only implemented the tokenization and tree building parts and kept their old ways for handling character encoding declarations. That is, they continued to honor the XML declaration syntax for declaring the character encoding text/html. I don’t recall the developers of the either engine raising this as a spec issue back then.

The closest to the issue getting raised as a spec issue was for the wrong reason, which made people push back instead of fixing the spec.

When Blink forked, it inherited WebKit’s behavior. When Microsoft switched from EdgeHTML to Blink, Gecko became the only actively-developed major engine not to support the XML declaration syntax for declaring the character encoding text/html. Since unlabeled UTF-8 is not automatically detected, this became a Web compatibility issue with pages that declare UTF-8 but only using the XML declaration syntax (i.e. without a BOM, a meta, or HTTP-layer declaration as well).

And that’s why support for declaring the character encoding via the XML declaration syntax came to the HTML spec and back to Gecko.

What Can We learn?

When the majority of engines has a behavior, we should assume that content is authored with the expectation that that behavior exists, and we can’t rely on assuming that all content is tested with the engine that doesn’t have the behavior even if that engine has the majority market share.
(In general, the HTML parsing algorithm upheld IE behaviors a bit too much. I regret that I didn’t push for non-IE behavior in tokenization when a less-than sign is encountered inside a tag token.)
Instead of just trusting the spec, also check with other engines do.
If you aren’t willing to implement what the spec says, you should raise the issue of the standardization forum.
If an issue is raised for a bad reason, pay attention to if there is an adjacent issue that needs fixing for a good reason.
“We comply with the spec” is unlikely to be a winning response to a long-standing Web compatibilty bug.

https://hsivonen.fi/xml-decl/

Комментарии (0)

The Mozilla Blog: How to capture screenshots instantly with Firefox

Вторник, 01 Июня 2021 г. 16:00 + в цитатник

Sometimes you need to take a screenshot of something online to save it or share it with someone. Firefox has a built-in feature that makes grabbing a screenshot quick and easy. Here’s how to use the Firefox screenshot feature in your desktop browser:

Use the menu

Right-click for Windows or two-finger tap on Mac to call up the Firefox main action menu.
Scroll to the Take Screenshot action.

The Firefox screenshot feature shows up in the menu

Drag your mouse around the area of your screen that you want to capture.
Or, you can select one of the pre-set options:
- Save visible captures only what you see in your browser window without scrolling.
- Save full page captures everything on the page, which is handy for screenshotting a full webpage without awkwardly dragging your mouse the whole way down the screen.
Once you’ve selected the area to screenshot, you have two options.
- Click the copy button to add it to your clipboard. Then paste it somewhere (control-v), like in a chat, email, document or presentation — and even other software other than Firefox.
- Or you can download the screenshot image, which is handy for saving and reusing later.

Changed your mind about taking a screenshot? Hit the ESC key to back out.

Add the Firefox screenshot feature to your toolbar

If you love the screenshot feature and want it front and center, you can add it as a button in the space next to the Firefox toolbar. Here’s how:

Click the main menu in the upper right corner and select More Tools.
Next, select Customize Toolbar.
Locate the Screenshot shortcut:

Grab it with your mouse and drag it up to the Toolbar.
Then click the Done button.
Now the Screenshot shortcut is at your fingertips everywhere you go in Firefox.

Using the Firefox screenshot feature is so easy anyone can use it. You don’t need to remember any shortcuts or download additional software. It’s all built-in and ready to roll with Firefox.

The post How to capture screenshots instantly with Firefox appeared first on The Mozilla Blog.

https://blog.mozilla.org/en/products/firefox/how-to-capture-screenshots-with-firefox/

Комментарии (0)

The Mozilla Blog: A fresh new Firefox is here

Вторник, 01 Июня 2021 г. 16:00 + в цитатник

https://blog.mozilla.org/en/products/firefox/fresh-new-look-for-firefox/

Комментарии (0)

The Mozilla Blog: Modern, clean new Firefox clears the way to all you need online

Вторник, 01 Июня 2021 г. 16:00 + в цитатник

We set out in 2021 to reimagine Firefox’s design to be fast, modern and inviting the first time you run it and every day after. We’ve always had your back on privacy, and still do. Now with today’s new Firefox release we’re also bringing you a modern new look designed to streamline and calm things down so you have a fresh new web experience every time you use Firefox.

We’re living in a frenetic time, where people are dealing with tough changes in our daily lives and hard to solve problems are popping up everywhere. We think the browser should be a piece of software you can rely on to have your back, pleasant to look at and working seamlessly with the web.

We’re also on a mission to save you time, whether that’s by making pages load faster, using less memory, or by streamlining everyday use of the browser. Good design is invisible. So if things just work, you don’t really think about it. But a ton of thought has been put into the flow. Our users who have tried the new Firefox have said, “the fact that I was using a new web browser slipped into the background of my consciousness.” And that’s just what we were going for.

Today’s desktop and mobile releases represent the intentional and thoughtful touches we made to give you a safe, calm, and useful experience online. We made these changes with you and your online habits in mind. Check it out for yourself:

Today’s Firefox gets you where you want to go online

Here’s a quick and easy breakdown of what you’ll find:

For starters we’ve cleaned up the amount of things that demand your attention from prompts and notifications to actions in the menu bar.

Simplified unencumbered navigation: The first step to going anywhere online is the toolbar, just type in the URL and press return/enter, and you’re off. In some ways this area serves as your car’s dashboard that you look at every time you get behind the wheel. We kept it simple and focused on these three key areas of the toolbar: 1) Navigation – back, forward and refresh 2) Address Bar – privacy shield (so you know your ambient information is always protected), security lock and where to type in your URL. 3) Frequently Used Settings – reader mode, zoom level and bookmark. Our intent was to make it easier for people to focus on the frequently used items in this area and easily get to where they needed to go.

Streamlined clutter-free menus: There are many ways to get to your preferences and settings, and we found that the two most popular ways were: 1) the hamburger menu – button on the far right with three equal horizontal lines – and 2) the right-click menu. So, we prioritized the content based on what people clicked on when they visited the menu. We made the labels less cryptic and clear and easier to understand, and we removed some icons so that it was easier for people to see at a glance where they wanted to go.

Productivity-inspired new tab design: Tabs. We use them every day. They signal where you are, but we need them to do more work. Everything from conveying information about what video is playing to where your next Zoom meeting is. It’s no surprise that more than 50% of people have 4 tabs or more open. We redesigned these tabs so that they floated neatly, and we added the visual indicators, like blocking autoplay videos until you’re ready to visit that tab. We detached the tab from the browser to invite you to move, rearrange and pull out tabs into a new window to suit your flow, and organize them so they’re easier for you to find.

We shushed notifications: Your web experience shouldn’t be bogged down by a bunch of notifications, and if you have to be given a heads-up on something, it should look good and not be a distraction. You’ll see consolidated the panels so you can respond more quickly and get back to why you were online in the first place faster. We specifically reduced some of the frustration and re-prompting associated with getting in and out of Google Meet meetings. Thanks to this pared down interface, you can get to all your web calls and meetings with fewer clicks.

Fresh, new Firefox for iOS: And we took care to pay attention to the key touches particularly on Apple devices. The improved iPhone and iPad experience includes a modernized, optimized and differentiated Firefox user interface. We reduced the steps to search in a new tab by automatically popping up the keyboard, emphasizing the ability to do quick searches with the search engine logo, and adding the append feature. You’ll see improved navigation around the app with new tab views and moved the synced tabs into the tab tray for better discoverability on any device. We refreshed design elements such as iconography and menu items naming to be consistent across our desktop and Firefox for Android platforms.

17 billion clicks drove us to create a new Firefox

As you can see for the past couple of months we’ve obsessed over everything from the icons you click to the address bar to the navigation buttons and menus you use. When we embarked on this journey to redesign the browser, we started by taking a closer look at where people were spending their time in the Firefox browser. We needed to know what clicks led to an action and if people accomplished what they set out to do when they clicked. For a month, we looked closely at the parts of the browser that were “sparking joy” for people, and the parts that weren’t:

We learned there was an opportunity to create a more streamlined environment to get people where they needed to go with less clicks and distractions. Our goal was to get people to their destination faster, with the least amount of clicks. Based on our user data, we observed how people used Firefox to get to their online destinations:

In one month, there are 17 billion clicks in the Firefox browser. Out of those 17 billion clicks, there were three major areas within the browser they visited:

Tab Bar – About 43% of the clicks go to the top portion of the browser where they can open as many tabs as they want
Navigation Bar – About 33% of the clicks go to the area below the tab bar where people can move forward, backward or refresh; and add the URL in the address bar, as well as other functions on the navigation bar
Bookmark bar – About 5% of the clicks go to the section where people bookmark their frequently visited place

Another area we observed was the menu area. Previously, we had three menus: right-click menu, the meatball menu (it appears as three dots at the end of the address bar), and the hamburger menu (it appears as three parallel lines at the far right of the address bar). The two popular menus were the right-click menu and the three parallel lines menu. People love or intuitively believe what they need is in the right click menu. We also saw differences around the world like:

Canada – Gets the crown for efficiency with an average of 12+ keyboard shortcuts per user and about 19 right clicks per user.
France – At an average of about 93 clicks pers user, France users click around the most within the browser.
Great Britain – We always wondered which country had the most tab hoarders? In the UK, users have the most tabs opened at about 7% of users who have 16 or more tabs opened.
India – Are the tidiest in terms of how they use browsers with over 60% of the users having 3 or less tabs opened.
United States: We found they topped the list of countries who like to go to their settings and personalize their browser.

With these insights we wanted to create a place that felt fresh and modern, and kept things like icons and menus flowing in a cohesive way. This meant using simple design and easy-to-understand language to lessen people’s cognitive load, essentially getting them faster to the places they wanted to go. It also meant retiring intrusive alerts and messages to avoid a jarring experience and provide a more calming environment. Throughout this process, our extraordinary team of designers really thought about the colors and iconography and wanted to make them more refined and consistent.

We’ve taken Private Browsing mode to the next level

We’ve designed the new Firefox to ensure that using a browser with industry-leading privacy is always an inviting experience. For those who browse exclusively or occasionally in Private Browsing mode, we take privacy to another level with today’s privacy protections. In February, we rolled out Total Cookie Protection in ETP (Enhanced Tracking Protection) strict mode. This privacy protection stops cookies from tracking you around the web by creating a separate cookie jar for every website. Today, Total Cookie Protection is now available in Private Browsing mode.

What’s next for Firefox

We’re excited to share this new Firefox experience across your devices. We’re planning exciting new features to roll out this year that will build on the modern web redesign this new Firefox delivers. No matter what device you choose to tackle the web in the future, Firefox will be there for you. We’ll share more details once we have them.

You can download the latest version of Firefox for your desktop and mobile devices and get ready for a new look and feel.

The post Modern, clean new Firefox clears the way to all you need online appeared first on The Mozilla Blog.

https://blog.mozilla.org/en/mozilla/news/modern-clean-new-firefox-clears-the-way-to-all-you-need-online/

LiveInternetLiveInternet

-Поиск по дневнику

-Подписка по e-mail

-Постоянные читатели

-Статистика

Перейти к полной формеБыстрая запись

1. Send tabs across the room

2. Search for a needle in a tabstack

3. Screenshots made simple

4. Reopen a closed tab

5. Pocket the best for later

6. Video multitasking with picture-in-picture

7. Sample any color with the built-in eyedropper

8. Fuggedaboutit!

9. Password headache fixer

10. Restore session

11. The hidden menu

Let’s add some Flex to it

Flex order, for real this time.

Uh, what now?

Private Fields

A Feature Three Ways

Mental Model

Specification

The Constructor Override Trick

Implementing the Specification

Implementing Private Names

Implementing Private Fields

Proxies

In Conclusion

Acknowledgements

It’s fast

It’s beautiful

It’s private

What’s next for Firefox

Metalink problems

Security problems

Unusual use pattern

libmetalink is abandoned

XML is heavy

Not used much

Violating a basic principle

Possible to bring back?

Credits

COVID-19 forced the U.S. into a new era of telehealth. Therapists hope it’s here to stay.

The Pocket Joy List Project

forced-colors media feature

Better control for displayed fonts

Top-level await

PerformanceEventTiming

What Can We learn?

Today’s Firefox gets you where you want to go online

17 billion clicks drove us to create a new Firefox

We’ve taken Private Browsing mode to the next level

What’s next for Firefox