vocx2tx

Also: user guide still mentions supporting private repositories [0]

FAQ still says that "Radicle supports private repositories [...] completely invisible to the rest of the network" [1]

[0] https://radicle.dev/guides/user#initializing-a-private-repos...

[1] https://radicle.dev/faq

For some context on why this release is notable: Jemalloc Postmortem [0]

[0] https://news.ycombinator.com/item?id=44264958

He's in the MAINTAINERS file[0], and the person with the most commits in 2016-2026 period, so no.

[0] https://github.com/emacs-mirror/emacs/blob/master/admin/MAIN...

These fake-time environments let you set the time, so you can test how the code will behave in 2039 without waiting for 13 years. For Go's synctest, 1-1-2000 is just the default initial value for now().

But still a kludge. Better: use something equivalent to Go's testing/synctest[0] package, which lets you write tests that run in a bubble where time is fixed and deterministic.

[0] https://pkg.go.dev/testing/synctest

The reason is simple: they'd like to reap all the benefits of a permissive licence (many people and companies won't or can't touch GPL code), without any of the downsides; but these downsides are the very reason behind the rules in more 'restrictive' licenses like the GPL.

This usually doesn't work, and in the end all they can do is complain about behaviours that their license choice explicitly allowed.

Go did exactly that, where Maven's 'Project group identifier' is an URL you control, e.g. github.com/<your-account> but also <your-website>/go-pkg or whatever you want. Other languages did this too. Flat namespaces are more of a Rust issue (among newer languages).

The real issue here is Rust's flat namespace. In Go, for example, there's no ffmpeg crate, there's github.com/someone/ffmpeg and gitlab.com/someone-else/ffmpeg, and so on. There's no blessed, unique 'ffmpeg' package, you can't squat names, and if the first package gets abandoned, you can fork it under a new path while keeping the 'ffmpeg' name. Only the import path changes.

Looking at the issue their builders seem to be Opterons G3 (K10?)[0]

[0] https://en.wikipedia.org/wiki/AMD_10h

64 bit mod is much slower than 32 bit mod. Your C program uses int32_t everywhere, while your Go program uses int (which is probably 64 bit on you machine); so this is not a fair comparison. Changing the Go program to use int32 everywhere makes it 35% faster on my machine.

Agree. And of course it's always something "surface level and uncontroversial", anything else gets you downvoted. Most subreddits (with a few exceptions) are huge echo-chambers.

It uses yt-dlp as the download backend, so it works with anything that yt-dlp handles.

> The worst GUI (none) out of the box.

That's funny, for me that's exactly the best GUI out of the box. I actually did some tinkering to reduce the GUI parts even more, and added more keyboard shortcuts.

Of course everything in the "Generic Programming" section is now outdated.

> and who was “she”?

The structure, probably. In gendered languages objects have a grammatical gender, and "structure" is feminine in at least French, Italian, and Spanish (they all derived from Latin "structura", which is feminine). Non-native English speakers will sometime carry over a noun's gender when writing in English.

Unrelated to the plugin but wow the is_prime function in the video demonstration is awful. Even if the input is not divisible by 2, it'll still check it modulo 4, 6, 8, ... which is completely useless. It could be made literally 2x faster by adding a single line of code (a parity check), and then making the loop over odd numbers only. I hope you people using these LLMs are reviewing the code you get before pushing to prod.

> The setting is opt-out, requiring manual intervention.

No. If a module's go.mod files declares go1.21, the compiler will use go1.21 semantics when building it, even if 1.22 has already been published and the module is being used from a 1.22-enabled program. This is explicitly mentioned in the blog post.

> I feel like Go already went through a whole saga of this where the community started with "LLVM and SSA are bad and slow"

I've been a contributor since the Go compiler was a tree-based C program and I've never heard anyone say that. What they said (and it's in the Go FAQ page) is: "At the beginning of the project we considered using LLVM for gc but decided it was too large and slow to meet our performance goals." [1]

If you're building a language with the explicit goal to make it compile fast, it's objectively true that starting out with LLVM is not the best approach. You'll get incredible runtime performance of the generated code since the early days, but NOT fast compilation. The Go makers choose a different tradeoff.

> and they end up building their own SSA IR

They switched to a SSA IR because it was a good idea to begin with, after an initial phase with the tree-base prototype. I've also never heard anyone argue that "SSA is bad", despite what you claim. The first compiler was tree-based because they reused a simple tree-based C compiler from plan9.

> building their own SSA IR and spending a bunch of time trying to bring compilation time closer to what it was before as it made everything much slower

The new compiler was ported to Go (machine-rewritten from C) and that's the main reason it was ~2x slower than the old compiler. It's not due to the switch to a SSA-IR.

[1] https://go.dev/doc/faq#Implementation

> a bump allocator freeing its tip is an optimisation

That's kinda my point? free is there and does something, but also silently does nothing if you violate a fairly subtle invariant. Kinda the definition of "error-prone", and the whole blog post seems to prove it, as the leak was essentially caused by the author not realizing that free was silently doing nothing. I understand why bump-allocators exist, I'm just saying this particular one's API has quite the footgun.

An allocator that silently does nothing on free if you violate one if its invariants (freeing an allocation that wasn't the latest) seems an incredibly error-prone design? It should probably return an error or panic (if free's API allows it, I guess).

Neat. I'd have liked to hear more about their custom programming language and its toolchain's implementation.

He probably ran ls on /usr/local/go (it's 477MB on my machine). But that's the size of the entire Go download after unarchiving, which includes the runtime's and all the standard library's 1) source code and 2) precompiled object files, both in normal and race-mode.

So no, that's not the actual size of "the Go runtime" for any meaningful definition of "the Go runtime".