Tobu

Please let Apple's shader language die an early death.

Maybe they're on some ego trip to leave their mark in a more visible way than through shaping the shared effort in various places and want to have a big thing to call their own. Or maybe they just want to get some vendor lock-in.

But it's yet another slightly-incompatible, slightly-better slightly-worse alternative to the existing shader languages, and nobody wants to deal with that, just like nobody really wanted to care about Metal. Apple's tight control over their devices will probably force some people to build some kind of compatibility layer into their pipelines, but it won't have to be good, and it won't be the primary target.

kvark is developping the wgpu implementation for Mozilla

https://news.ycombinator.com/item?id=20954885

https://gfx-rs.github.io/2019/03/06/wgpu.html

There's an example of using stdout.write at the top of this page: https://doc.rust-lang.org/std/io/fn.stdout.html

    use std::io::{self, Write};

    fn main() -> io::Result<()> {
        io::stdout().write(b"hello world")?;

        Ok(())
    }

This list has been updated more recently: https://github.com/flosse/rust-web-framework-comparison

But they're still on the previous, non-Tokio release.

Personally I'm more tempted by something like Susanoo: https://github.com/ubnt-intrepid/susanoo/

jbuilder is really nice and the ecosystem is picking it up quickly.

Any word on the "single codebase" aspect of supporting both major Python versions? I remember suggesting it years ago at a time when the team wanted to do Mercurial backporting instead. What changed their mind?

That looks like it could fix the lag on CPython releases, so it's a big feature.

Containers provide resource limits but not necessarily safety. The ABI surface is too large. You kind of need the code inside them to be secure.

WhatsApp: https://www.wired.com/2015/09/whatsapp-serves-900-million-us...

They mention exactly two third-party apps installed:

https://news.samsung.com/us/2017+ces+Samsung+Chromebook+Plus...

Yes. LWN has the details: https://lwn.net/Articles/701964/

I'd like to get started using Rust for bare metal development.

Mutable strings are on the way out though. 4.02 introduced -safe-string and 4.04 lets you build compilers and OPAM switches that mandate it.

The blog author doesn't understand Git that well:

    git add foo.rb
    // continue working in foo.rb
    git commit foo.rb

will commit the latest version of foo.rb.

That's because git commit handles its arguments by add-ing them to the index (staging area) before doing the actual committing.

I'm not so sure about the conceptual graph from the paper, either. The stash is a commit, it doesn't have anything to do with file states.

Cool visualisation, but it doesn't have links to the subreddits?

The video was taken down, TechCrunch now embeds this one: https://www.youtube.com/watch?v=bl5vLC3Xlgc

`PermitRootLogin = without-password` in /etc/ssh/sshd_config

Same thing for non-root: `AuthenticationMethods = publickey`

And when buying a router, buy something that will get regular security updates, or where you can put OpenWRT.

Éric Dumazet (author of the patch) is this highly productive guy working on network latency issues. He helped get CoDel into the kernel, and worked on TCP small queues (https://lwn.net/Articles/507065/) and the fair queue scheduler (https://lwn.net/Articles/564978/). Looking at the email addresses he used, I think he started working on the network stack on his spare time, while employed at SFR, a French telco. He implemented an in-kernel JIT for BPF (https://lwn.net/Articles/437981/), speeding up packet filtering; now that BPF is fast it is also used for performance profiling (filtering and aggregating in kernel) and syscall filtering.

There are of course others working in these areas, but I think Google has been going after them: Van Jacobson is a high-profile example. Dave Taht is still subsiding on ramen though (https://www.patreon.com/dtaht).

If you're referring to SQLa Core, it's still SQL. The AST is the same, but by building the SQL AST explicitly you prevent injection and get a degree of composability (with subqueries). IMHO it's the more maintainable way of writing SQL.

It didn't render on my mobile.

A direct link might work better: https://github.com/isocpp/CppCoreGuidelines/raw/master/talks...

You need to know which objects are reachable before you can delta compress them (or reuse a packed delta chain). I guess you could restrict compression antecedents to graph ancestors in your pack, but at the cost of not compressing similar siblings (and blobs are leaves).

Because CF becomes a tempting kill switch.

In practice, about half the extensions I use (the complex ones, like Lazarus) need a serious overhaul to work with e10s. It can't hit a stable release, there would be major breakage.

At the moment there are more gaps than API and the debugging experience is such that you have to go back and forth between Chrome (debugging any changes you made) and Firefox (looking at the global console, checking that you're within the small supported subset).

Recommending gulp is ridiculous overkill. Chrome loads files from disk directly, Firefox plans to.

Eight bits are enough for me … https://www.youtube.com/watch?v=GoGpLl-SUfk

Ah yes, the see no evil, hear no evil, speak no evil approach to security. Certainly blaming the messenger will make the problem go away.

This rules-based framework is way too rigid for “reading comprehension”. It would fail to recognize much from naturally written sentences.

256MiB RSS when active, hahaha. Chrome isn't memory efficient, but this takes the cake.

Did you consider making a simple Chrome app of this?