sstangl

I've maintained a well-used online Esperanto dictionary for several years now: https://www.tujavortaro.net.

The whole dictionary is loaded client-side and a lookup is performed on each keypress. Because of the search speed, it's surprisingly fun to use this dictionary to explore the language. I'd like to see such dictionaries built for other languages too.

If Slack offered a way to show all messages whether or not they're in a thread, as they come in, I'd be down.

This is how Zulip works. It's extremely effective.

Similar logic is used to toggle on/off GC write barriers in JS jitcode.

In my experience code quality falls out from making mental simulations easier to produce. Abstraction boundaries should be drawn where mental processing starts feeling burdensome.

When running abstract mental simulations, do you assume that I/O operations succeed or fail for knowable reasons? It seems likely. If the code were expressed to match your mental simulation, for example by not performing I/O within the function, but by merely receiving I/O messages from a foreign actor, it seems like you're not far away from offloading the full mental simulation to something like quickcheck and writing down explicit invariants!

Yes, Firefox uses the same sandbox as Chromium. https://wiki.mozilla.org/Security/Sandbox/Specifics

They are optimizing only for code size, so they don't need to run the code: they only count bytes emitted.

This works by changing around the order / interleaving of various LLVM optimization phases, so the learning process does not require knowledge of program timing or correctness.

The parent post is objecting to a statement from Mozilla opposing "the rampant use of the internet to foment violence and hate, and reinforce white supremacy."

https://blog.mozilla.org/blog/2021/01/08/we-need-more-than-d...

Google's interpretation implies their belief that if their PostgreSQL server uses AGPL code, then every service using that PostgreSQL server must also be AGPL.

The article points out that that is not the case.

If you are using AGPL code as a library, however, then your application as a whole must be under an AGPL-compatible license. It's just that connecting to a server does not constitute linking in the GPL, and the AGPL doesn't change that.

JIT engines like this one don't receive much benefit from being rewritten in a memory-safe language. Errors typically occur in the generated machine code, not in the compiler itself. The benefit would be small.

I'm talking about neutral perceptions, not thoughts. An example would be something like the visual perception of a sidewalk. Presumably you don't get an emotional reaction about the sidewalk one way or the other, it's just a sidewalk.

The majority of your sensory experience is neutral perceptions like that. Once you notice them, negativity seems small in terms of proportion of sensory experience. What actually happens is that negativity occupies the majority of attention, meaning that your mind is latching onto things you perceive as negative. Broadening the scope of awareness to include neutrality means that definitionally the mind is not as latched-onto the negative, therefore negative things seem smaller, therefore they are slightly more tractable to deal with.

There are two options I'm familiar with:

1. Without wondering if you sincerely mean it, make a point to say "thank you." Typically if you are depressed you will be alone, and so it is possible to recognize situations where you took an action now to make something easier for yourself later: for example, doing the dishes now instead of waiting for them to pile up. When that happens, verbally thank yourself on behalf of your future self. If you're capable of doing this, it jump-starts gratitude after a while.

2. Instead of feeling gratitude for things you perceive as positive, look for things that you perceive as neutral. The majority of your sensory experience is neutral. If your emotions are very negative, instead of looking for a dichotomy between negative and positive, look for a dichotomy between negative and neutral. You will perceive that neutral is not-negative. Because neutral is not-negative, increased perception of neutral sensations is a positive. If you perceive neutral sensations as positive for long enough, it jump-starts gratitude after a while.

Download batches on initial extension load, and periodically thereafter, and cache them locally?

Here's a simple no-framework points calculator for the sport of Powerlifting: https://www.ipfpointscalculator.com/

The page is 11KB, loads in 96ms, and makes three requests to one network, two of which are favicon-related.

This turns out to actually matter in practice because many of our users are from countries with extremely slow connections.

Mozilla engineers typically accept a salary that is below market rates.

Recently they have been increasing salaries to be more competitive.

I can't visualize every kind of object. The easiest things to visualize are simple geometric shapes with a strong color. By default, if I try to "visualize something" it will be a red triangle.

I cannot visualize faces whatsoever, even if the person is right in front of me and I close my eyes suddenly.

Yes, it's plausible that were Rust to adopt Cranelift as a supported backend, you could use Cranelift as an intermediary to translate Rust MIR (via Cranelift CLIF) into C. Outputting functional-but-horrifying C would not be terribly difficult.

The CLIF format is low level but relatively architecture-independent.

I spoke to Dan to let him know that I'll need to hand off my work, and he didn't mention anything. So I assume he is.

At this point I don't know who was affected.

Oh, thank you! I added it.

I'm one of the 70. There were no signs that this was imminent, although Mozilla has been struggling financially for many years. I expected that it would happen eventually; I'm relatively well-prepared for it; and it's not too shocking. I did however expect that there would be some warning signs in the lead-up, but that was not the case.

I was working on Cranelift, the WebAssembly compiler that is also a plausible future backend for Rust debug mode. Before that, I worked on the SpiderMonkey JITs for 9 years. If anyone has need for a senior compiler engineer with 10 years of experience writing fast, parallel code, please do let me know.

In Firefox, Wasm still uses a tiered JIT. Like JS, there is a single-pass JIT and a JIT that does more aggressive optimizations (mostly: good regalloc).

However the compilers are much simpler than the equivalent JS compilers, because wasm doesn't need on-stack-invalidation.

If this started with BusyBox translated from C to Rust, is this code also under the GPL, as is BusyBox?

I don't see any LICENSE or COPYING files in the repo.

We switched to Zulip because of a bad experience with Slack holding our message history hostage. At the same time we switched to GitLab because we didn't want a similar issue to arise with our issue tracker.

It was non-trivial to get the issues out of GitHub, and we lost metadata in the process. But now we're on a platform that has an "Export Everything" button, and in the worst case we can self-host our own data.

Although that's why we moved, and we didn't know about it at the time, "Service Desk" became a killer feature. That lets users file issues directly into our GitLab issue tracker by sending an email -- no account setup necessary. The majority of our users are non-technical and this has made it much easier for them to communicate with us.

In the beginning, Chrome was bundled with Flash, and Flash was ubiquitous.

When you installed or upgraded Flash, unless you checked a checkbox, Chrome would be installed.

Back when this change to Screenshots was announced, it wasn't known whether Send would be a successful experiment.

It's visible in the tab: https://i.imgur.com/UOvz505.png

DDG has a "retry search in Google" mode if you prefix !g to your search query.

I usually try in DDG first, and then in the small cases where it's not found, I just prefix "!g" and re-execute the query.

Safe from what? Chromium? It's Open Source?

Safe from monopoly control over Web standards.

The Web has been a consensus ecosystem, and Google does not have a track record of proposing reasonable standards. In my mind this is most grossly evident in the case of PNaCl, which was tied to their Pepper API and effectively impossible for non-Blink browsers to implement.

Google pushed for PNaCl to become a Web standard, and it was only through years of difficult effort that Mozilla was able to show AsmJS as a better solution, which eventually gave rise to the reasonable standard of WebAssembly.

Were Google in a monopoly market position back then, they would have pushed PNaCl, and non-Blink browsers would be unable to render the modern Web.

That might sound fine if you believe that Blink is the be-all-and-end-all of Web technology. But we have Servo now, and we already know better.

I don't think it was a toolchain issue, because I did receive line and file information for certain classes of errors. Presentation of that information doesn't appear to be pervasive.

Yesterday, there was news that Facebook was porting Yarn from Flow to TypeScript for ease of new contributors. That ease is a shared goal of one of my projects, and yesterday I tried porting it as well.

I discovered that in contrast to Flow, TypeScript has horrible errors. Often I ran into errors that would not give much more information than "error" -- no line information, no file information, nothing. One of the causes of such opaque errors was empty Flow-style typecasts, so they were pervasive throughout a large project.

In contrast, Flow has beautiful error messages.

I switched back to Thunderbird and have been content ever since. IMAP works fine.