kangalioo

Can be pretty fast if you know your tools well :)

Just tried in VSCode; 2:38min using its fabulous multiline editing. 1:34min on second try due to practice

Yeah, that's definitely fair. What I'm annoyed about is the "checkmate, computers" stance, pretending like the problems computers cannot solve could be solved by other means

I will never understand how people think like that. Sure, there are things computers cannot compute, but that's because those things are _uncomputable_ in general

I don't believe only turing machines are capable of executing other turing machines... Surely lambda calculus can do the same? I was under the impression, lambda calculus can indeed execute itself with even less code than turing machines

There's several very dubious claims that are stated way too confidently like this in the article, like "Yep, virus scanners are almost completely useless"

WebAssembly is not without tradeoffs either. I'm not an expert, but it's often heavier due to bundling the native language's stdlib; it's annoying to interop with the browser environment because that's still JavaScript-tailored; it's also just hard to write code that can be compiled into WASM (e.g. in Rust, it needs to be `#[no_std]`)

Good point. When I'm going back and forth writing code and checking its assembly, I also reason about the compiler almost like an intelligent being:

"oh, it doesn't see this condition, so if I help it a little bit, then... Ah now it unrolled, and inlined, but accidentally trashed instruction cache, how will I convince it not to..."

In the linked answer, there's a two-word full answer phrase:

> So I would cut this down to something like nimium valedīxit or totiēns valedīxit: "she bade farewell too much before" or "she bade farewell so many times before".

Roughly 2x slower in my experience. The main annoyance are the many changes. Every change carries risk of missing the connecting train

s/frequently/likely

(Large language models are not plain Markov chains, contrary to popular belief)

To be fair this is a problem of the Rust web ecosystem. Include a few de-facto standard Rust web crates and you're up to 200 transitive dependencies

This story brought me to tears within two paragraphs, wow

I thought it's to transmit good reputation to Meta

E.g. when people trust WhatsApp, and then see it's from Meta, they may trust Meta more too

Interesting

> You can launch a single X11 app from the console, and the resulting window will be your entire graphical display/instance, returning you to the console after the program terminates execution.

Is this not possible with GUI apps using e.g. Qt or Electron?

I see, thanks for explaining

In what way are these "X11 apps"? Aren't those just "GUI apps that support X11"? Which is not a particularly special trait, because it applies to every Linux compatible Desktop app?

Exactly, and the reason 293k boots were needed anyways is because the bug was hard to reproduce and needed thousands of boots to potentially trigger

Is the purpose of this site to list which places you can reach at all with the 49€-Ticket? If so, that seems a bit useless: you can travel from anywhere to anywhere in Germany with local trains - it just takes long.

In practice, you just enter start and destination into DB Navigator app, select regional-only, and choose your pick.

As per Rust reference, even a capture-less closure is a closure and distinct from an anonymous functions.

Also, your arguments only partly apply in Rust. Rust doesn't heap-allocate closures. And you also often don't have to deal with lifetimes - a closure that captures variables by move or copy is perfectly self-contained

The difference between a closure that captures and a closure that doesn't is like the difference between `(T)` and `()` - same kind of thing, so it adheres to the same terms and behaviors

Other comments are saying non-capturing closures are not closures. If we want to have this pedantic argument of definitions: proto_lambda is actually right, with Rust's definition of closures.

According to the Rust reference:

> Closure types > > A closure expression produces a closure value with a unique, anonymous type that cannot be written out.

https://doc.rust-lang.org/reference/types/closure.html

Even a non-capturing closure is written using a closure expression and produces a unique, anonymous type.

People keep trying to use those LLMs as if it were a search engine but it's not. The value in ChatGPT is its faithful recreation of human common sense.

Use it to hold a conversation, to ask feedback on a text you wrote, to come up with ideas for something. Don't use it as Google and be dismissive when it's not the universal information retrieval tool it's not meant to be

Where do you get Android phones for cheaper than a Raspberry Pi (e.g. $35 for a Pi 4)?

Which UI code specifically are you referring to and why would the borrow checker prevent you from factoring it out?

What's the difference to just installing a different desktop environment?

The author tries to explain this by portraying installing a new desktop environment as impractical:

> First, I tried KDE Plasma but was quickly reminded why I didn't much care for that desktop environment (it's too much like Windows). Then I tried Enlightenment, but that environment didn't much care for Wayland, so it was a no-go. I was going to install standard GNOME, but that would break Pop!_OS. Pantheon? Nope.

But it seems unconvincing. Universal Blue is neither going to fix the author's distaste for KDE, nor that Enlightenment doesn't support Wayland. And the fact that GNOME and Pantheon cannot be installed on Pop!_OS doesn't mean we need yet another whole new distro - just choose an existing distro that _can_ install new desktop environments! I know Arch can, and probably its derivatives and many other popular distros too.

> The Pile is a 825 GiB diverse, open source language modelling data set that consists of 22 smaller, high-quality datasets combined together.

https://pile.eleuther.ai/

There's also https://lottiefiles.com/

> A Lottie is a JSON-based animation file format that allows you to ship animations on any platform as easily as shipping static assets. They are small files that work on any device and can scale up or down without pixelation. LottieFiles lets you create, edit, test, collaborate on and ship a Lottie in the easiest way possible.

In my experience, the patterns Rust makes explicit are usually worth reconsidering and replacing. Further, it makes other common patterns more compact than in other languages: e.g. `std::fs::read()` vs the abomination with ByteInputStream and IOReader or whatever from Java, and I believe C++ makes it non-trivial either

How do you remember the unique identifier?

Which has been done, and I'm really sad how that effort has been overshadowed hard by GCCRS, when the latter is much more niche in its use case

The point of GCCRS over rustc_codegen_gcc is to make Rust easier integrateable into other projects and build systems. If you use Cargo anyways, you're much better off using rustc_codegen_gcc

I've wondered about this for ages and now know: the people who work on GCCRS wouldn't work on rustc_codegen_gcc for one reason or another (familiarity, culture, personal ideals...?). So GCCRS is not "eating away" at available bandwidth and there's no reason not to let GCCRS developers do their thing, even if rustc_codegen_gcc is a more straightforward way of achieving most goals