ainar-g

Why not just use GitLab?

Interesting! The OS doesn't seem to be based on Debian, Arch, or RHEL, but instead seems to be its own new thing, with Flatpak as its dependency manager. Seriously considering playing with it in a VM.

> Was github always this shoddy or has something changed to cause this many outages?

The data speaks clearly: https://damrnelson.github.io/github-historical-uptime/

Saudi-Supported, for 7S.

It's in decent company in the Redmonk graphs[1], in the vicinity of Smalltalk, Mathematica, D, and Haxe.

[1]: https://redmonk.com/sogrady/2026/04/14/language-rankings-1-2...

> This constant slide in quality over the past few years has me looking to Linux as an option.

Just out of curiosity, what's holding you back? I'm not trying to evangelize or something, it's more of a personal collection of reasons various people have provided that I have.

Re unions:

https://github.com/golang/go/issues/76920

You might want to follow this proposal, if you aren't already. It's the most recent one, and it's supported by quite a few “core members” of the Go Team. I don't think it'll land in 1.28, but I like the fact that it's still a feature that's being actively discussed.

Have you ever learned a language? Because that's what it is for a very large percentage of people.

Which is why the Soviet government used “ultraviolet baths” to make sure that children up North get their vitamin D.

https://www.nationalgeographic.com/photo-of-the-day/photo/ul...

There's always ReactOS[1], a project for a bug-for-bug compatible Windows clone. It used to mostly aim at Windows 9x compatibility the last time I'd checked, though, but that could probably change. And if anyone wants to create a Win7 clone, at least some of the groundwork has already been made.

[1]: https://reactos.org/

Thank you, rsc, for all your work. Development in Go has become much more enjoyable in these 12 years: race detector, standardized error wrapping, modules, generics, toolchain updates, and so on. And while there are still things to be desired (sum types, better enum/range types, immutability, and non-nilness in my personal wishlist), Go is still the most enjoyable ecosystem I've ever developed in.

Source on the reasons, from the editor: https://pony.social/@thephd/112791335889843647.

If I recall correctly, ProtoBuf has a reflection layer, and it's probably using that.

Re. bad tooling. grpcurl[1] is irreplaceable when working with gRPC APIs. It allows you to make requests even if you don't have the .proto around.

[1]: https://github.com/fullstorydev/grpcurl

> While the compiled programs stayed the same, we no longer get a warning (even with -Wall), even though both compilers can easily work out statically (e.g. via constant folding) that a division by zero occurs [4].

Are there any reasons why that is so? Do compilers not reuse the information they gather during compilation for diagnostics? Or is it a deliberate decision?

Ah, so extremely localized uses of pointers, got it, thanks.

That could be true, but I've done a few optimizations of allocations in Go code, and I don't recall pointers to stack values ever being optimized (unless the entire branch is removed, of course). If anyone could provide an example of the code that does pointer operations yet doesn't cause allocations, I'd appreciate it!

Whenever you do:

  v := interfaceType(concreteTypeValue)

in Go, what you're actually doing on a lower level is:

  dataPtr := &concreteTypeValue
  typePtr := typeData[concreteType]()
  v := interfaceData{
          data: dataPtr,
          typ: typePtr,
  }

The first line here is the allocation, since (at least, the way I recall the rule) in Go pointers never point to values on the stack, so concreteTypeValue must be allocated on the heap. The rule about pointers not pointing to the stack is there to make it easier for goroutine stacks to grow dynamically.

See https://go.dev/doc/faq#stack_or_heap.

To be fair, if that's what you need ProtoBuf isn't the only option. Cap'n Proto[1], JSON Schema[2], or any other well supported message-definition language could probably achieve that as well, each with their own positives and negatives.

[1]: https://capnproto.org/

[2]: https://json-schema.org/

There is a proposal to get this using the "defer" keyword into either the next C revision or the one after that[1].

[1]: https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3199.htm.

Privilege separation[1], most likely. If your system needs to do three things, it could either just do all of them using a single executable requiring all three permissions (thus also theoretically allowing an attacker to use it to do all three things as well) or split your system into three executables, each only having the permission to do one thing (thus reducing the amount of potential damage).

[1]: https://en.wikipedia.org/wiki/Privilege_separation

This makes me thing of the stories I've heard stories from those who lived in communal apartments back in the U.S.S.R. days. Couples who had a creaking bed and wanted to go at it at night would just do it on the floor instead of on the bed. Which in turn makes me think if those beds are just some kind of kickback scheme, because I can't be the only one who thinks of suck obvious solution, can I?

Edit: Seems to be fake news: https://www.snopes.com/fact-check/anti-sex-beds-2020-olympic....

Why the quotation marks? If I recall correctly, Vala compiles (by way of C) into native code.

IPv6, too. (Unless you also need interface IDs for link-local addresses.)

On a related note, have there ever been extensions for PosgreSQL/SQLite/any other FOSS DBMS that would allow using Tutorial D[1] (the Third-Manifesto one, not to be confused with Walter Bright's D language) to define and query data? In particular, I feel like PostgreSQL's CREATE TYPE[2] feature would allow for easier bridging between SQL and Tutorial D.

Unfortunately, searches for “PostgreSQL Tutorial D” don't issue useful results for obvious reasons.

[1]: https://www.dcs.warwick.ac.uk/~hugh/TTM/index.html

[2]: https://www.postgresql.org/docs/current/sql-createtype.html

A feature that combines well with range and enum types are typed indexes of arrays:

  TYPE
   TWeekday = (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday,
    Sunday);
  VAR
   WeekdayNameIndex : ARRAY [TWeekday] OF ShortString = ('Mon', 'Tue',
    'Wed', 'Thu', 'Fri', 'Sat', 'Sun');

Now `WeekdayNameIndex` is a properly type- and range-checked look-up table.

It's really sad that these simple joys of Pascal are still lacking from a lot of mainstream languages.