EdiX

> FOSDEM doesn't fit in its venue anymore, which is great in a way. It's been incredibly successful, but now it's time to find a bigger venue.

The ULB campus is pretty big, finding a bigger venue is going to be complicated.

The way they are using to route around the Go 1 compatibility promise is to gate these backwards incompatible changes on the value of the go directive in go.mod. If it says 1.22 or later you get the new library behavior, otherwise you get the old one. We'll see how well this ends up working in practice.

You would still have to memorize 60 different symbols. A base so large is unwieldy either way.

The duodecimal meme needs to die. Base 12 is not that much better than base 10. Yes it has more integer divisors (2, 3, 4, 6) than base 10 (2, 5) but there's only two reasons to care about that.

The first one is to split a batch of something: there's more ways to split 12 of something than 10 of something, but you can use base 10 and still do things in batches of 12.

The second reason is for easy divisibility checks, but for that all that matters is prime divisors. Base 12 and base 10 have the same number of prime divisors 2 and 3 versus 2 and 5. But base 10 has an interesting property here, because 10-1 is 9, which is a power of 3 you get somewhat easy divisibility rules for both 9 and 3. 12-1, on the other hand, is 11 which is prime so you only have a relatively uninteresting divisibility rule for 11.

I think at best you can claim that 12 is about as good as 10. Base 60 would be strictly better than base 10 if it weren't for the fact that we can't easily memorize multiplication tables for base 60.

FWIW Go doesn't do any reference counting, its GC implementation is a concurrent mark and sweep. And also file descriptors are subject to the same mechanism, a finalizer is set on them and they will be closed when the associated object is collected.

It seems to me that what you are describing is usually called software transactional memory. It has its own set of problems (bad performance with high granularity and livelocks, although you can probably avoid livelocks if you only care about using it for abnormal terminations) but it doesn't fully resolve the problem here. Yes, not leaving memory in an invalid state goes a long way but any form of IPC is potentially problematic: consider what happens if the thread is writing to a socket borrowed from a pool, or to a disk file.

Not impossible to deal with but everything you do needs to be designed with cancellation-at-any-point in mind, it doesn't seem worth it to me.

What a strange article. Goroutines definitely do have their downsides, they aren't hard to find either, but nothing he talks about here is actually a downside of goroutines. Also for some reason almost every reference he has is from 2016.

> Further, goroutines' lack of their stack ancestry means they can't natively give out the nice stacktraces found in other languages, though there are a lot of workarounds, to be sure.

I wish he was more speific here, what's "nice" about stacktraces in other languages that is lacked by Go? I really don't get it, it seems to me that they are the same, maybe I'm missing something. There's even a mechanism to record goroutine ancestry [1] but it's from 2018, past this article's knowledge cutoff date maybe?

> Because of this stack disconnection of parents and children, it really becomes impossible to have exceptions

But panics use the exact same mechanism as exceptions? They are not used in the same way as exceptions but it isn't because of any technical limitation of goroutines, it's mostly about what's idiomatic in the language.

His whole example about a panic causing a resource leak, as far as I can tell the difference is that in java an uncaught exception will only close its thread while in go the whole program crashes. You can definitely argue for both behavior as being better (IMO it really depends on the application), but it doesn't have anything to do with how goroutines are implemented.

> This highlights a key difference between cooperative scheduling and OS-level scheduling: OS-level threads can be stopped at any time, while cooperatively scheduled coroutines cannot

Goroutines are actually scheduled preemptively since 2020 [2], again this is probably beyond the knowledge cutoff date of the article. This isn't surfaced to the user however, you still can't stop a goroutine at an arbitrary point. But it doesn't have anything to do with the way goroutines are implemented, it's because it is a design decision to not allow users to do that.

[1] https://github.com/golang/go/issues/22289 [2] https://go.dev/doc/go1.14

To be honest Google scrapping the "don't be evil" mantra was quickly followed by Google beginning to behave substantially less ethically. In retrospect it's hard for me to argue that it didn't work.

People like to say that github is the reason git won the dvcs wars 10 years ago, but I think this is it. I think a lot of people's first impression of git back in the day was making a local mirror of their company's svn using git-svn. Without local branches this was a pointless exercise but with git you still got some benefit even without the remote being a git repository.

That's the idea, yes. However none but OpenAI knows exactly what ChatGPT was trained on. In fact, the dataset that it was trained on is so vast that they probably don't know either if it contains any given question. IIRC last week I saw a study where GPT4 can solve some leetcode problems simply by giving it the number, no description. A clear example of overfitting.

The problem here is not about modules breaking. Even if gitlab went away nothing would break because of vendoring and proxies. The problem is if gitlab goes away and someone buys it and starts pushing malware through it, there is no way to distinguish a malicious update from a legitimate one.

This is also a misconception. The Invention of Science by David Wootton has a long chapter on this. They believed it was impossible because in aristotelian cosmology the planet earth is actually two spheres: a sphere of earth floating in a 10x times larger sphere of water, so that only a small dome emerges from it (both of them are then inside a larger sphere of air which is inside a sphere of fire).

In this model reaching china by sailing west is impossible because the sphere of water is absolutely enormous and all the possible emerged land is already known so there can not be any antipodal land you could find to restock on food.

This whole meme started because people could use DKIM to verify that Hunter Biden really did send his incriminating emails while we were all supposed to think they were russian disinfo.

Some people are literally so politics poisoned that they can't see that it cuts both ways. I can't wait until DKIM is used to prove something bad about Trump so everyone can flip their position on DKIM.

It isn't going to change anything, politics poisoned brains won't see the irony. But it's always funny to see anyway.

I think nushell makes a pretty good case against itself.

Take ls: like the article says gnu ls has tons of options to configure how its output is displayed. But that's because ls is a user interface for displaying lists of files. I'm not sure how the proponents of all these new shell keep missing this point. If you just want a list of files in a POSIX shell you use a glob expression.

But whatever, nushell has its own builtin ls that is for getting lists of files. And then you pipe it into other commands to configure the output. Great. Can I get the output to be like 'ls -C'? Nope. Can I turn off colors? No. Can I add the indicator character like 'ls -F'? Not a chance.

Well, at least I don't have to pass '-l' just to see the file mode... actually I do, otherwise it would be too slow.

Many of the options that clutter gnu ls are generic options that apply to all tables, and it would be nice to abstract them. But many aren't, many are specific to what ls is doing and it's hard to me to see how this all could be generalized in a way that applies both to ls and to grep.

For now nushell sidesteps the problem by not having its own reimplementation of grep, unlike ls if you type grep you get real grep and you can't pipe the output into anything meaningful.

The best I could do to replicate grep inside nushell was this:

     cat haystack | split row -r '\n' | enumerate | where item =~ needle

asides from the shocking verbosity, I can't see any way to replicate the --color option of grep, or -A and -B.

The cop-out solution to this is to have builtins return objects (as in OOP objects, with methods), but then everything needs to be written in the same language.

AFAIC all of those have degraded.

The GUI builder of VB6 fell apart the moment you wanted to do a resizable window. Here "more complex applications" = "window that you can resize or maximize".

All threads have a system stack available at all times.

> the abstract concept behind XML is just to provide a metalanguage for the representation of hierarchical data

What you are describing here is s-expressions, XML represents a far more specific type of data structure: a tree of nodes where each node is either a text node or a tag node. Text nodes are always terminal, tag nodes can either be terminal or not. Tag nodes also have a list of attributes, while text nodes do not. Each attribute is a key value pair where both the key and the value are text, but the key can only contain certain characters, whereas the value is unrestricted.

This is all fairly complicated and it doesn't really map well to almost anything.

Even the description is longwinded. You say:

> JSON got closer to the representation of list and hashmaps, but I see this as a mere convenience

I say that calling it "mere" convenience is underselling it. The data model of XML is of so little use that no programming langauge, besides XSLT, offers it as part of the language.

Vice versa hashmaps and list are nearly universal.

> I think it's incorrect to part from the assumption that nobody's gonna need a schema language, a query language, a mapping language or whatever

I didn't say that. I said that with XML the need for those tools is especially pressing because XML is such a poor fit for any programming language.

> you see many people creating their own version of a json schema because it's really needed

Sure, but you also see very low adoption for json schema, because it isn't needed as much as xml schema was.

Because HTML is a markup language. XML is also a markup language but people somehow insist on using it for things where a markup language is not appropriate (which is almost everything).

XML was a bad fit for almost everything people did with it. The natural data model of XML is alien to all programming languages people use: it is alien to scripting languages because you want hashmaps and lists and it is alien to static languages because you want structs and lists. So you usually ended up having to have a two stage parser, with the first stage turning XML into some kind of DOM and then your handrolled DOM-to-internal-representation thing. That's also most of the justification for XML's ecosystem:

- You need XSD to make sure that your DOM-to-internal-representation code doesn't have to deal with garbage

- You need XPath to query XML directly if you don't want to convert it to something usable

- You need XSLT as a scripting language where the DOM isn't alien and awkward to manipulate

This is why there is no xslt equivalent (although you could argue that jq is that) and the various json schema solutions don't see much adoption, despite json being almost as old as XML at this point.

A lot of people did. To what others have said, I'm going to add this: https://www.youtube.com/watch?v=5V1ynVyud4M Which is an interesting talk about how these approaches fail in practice.

Does it even apply to something like Twitter? If it applies to Twitter then surely that means it also applies to Youtube? Does that mean youtube-dl must be officially supported? I thought it only applied to digital markets (stuff like amazon, google's advertising platform, etc)

> If the API is down for 3rd parties, but not for twitters own client, that will be considered a breach.

A breach of what?

1. Git was faster than mercurial and bazar, eventually mercurial became fast but at that point it was too late 2. Git had a better svn backend, you could try git and get benefits from it even if your company used svn 3. Git did a lot of things that other dvcs didn't do (rebases, partial commits, history edits, local branches)

A lot of the UI simplicity of other tools rests on not doing (3). For example, OP awards negative points for rebase but as far as I am concerned I won't even consider using a UI that doesn't support rebase.

The OS network stack is crashing and this is Go's fault? Is Go holding the network stack wrong?

> That's not going to be an issue. There are zero such beings known so far

Maybe the reason there are zero openly non-terran (or, preferrably, differently planeted) folks is attutides like yours. Think about it.

If you are referring to the change from 461 MB to 293 MB that's because he didn't call runtime.GC right after the insertion loop.

PS. ^Z sends SIGTSTP not SIGSTOP.

SIGSTOP can not be blocked.

Do you think CNN should be driven off the internet? Back in 2017 they threatened and harassed an anonymous reddit user into apologizing for making a harmless gif [1]. How is CNN better than kiwifarms?

[1] https://edition.cnn.com/2017/07/04/politics/kfile-reddit-use...