TehPers

Unity publishes some source code for reference purposes only. It is not open source, just made public.

Guess I’ll post another update. The block-based data structure makes no sense to me. At some point it claims that looking up a pair in the data structure is O(1):

To delete the key/value pair ⟨a,b⟩, we remove it directly from the linked list, which can be done in O(1) time.

This has me very confused. First, it doesn’t explain how to find which linked list to remove it from (every block is a linked list, and there are many blocks). You can binary search for the blocks that can contain the value and search them in order based on their upper bounds, but that’d be O(M * |D_0|) just to search the non-bulk-prepended values.

Second, it feels like in general the data structure is described primarily from a theoretical perspective. Linked lists here are only solid in theory, but from a practical standpoint, it’s better to initialize each block as a preallocated array (vector) of size M. Also, it’s not clear if each block’s elements should be sorted by key within the block itself, but it would make the most sense to do that in my opinion, cutting the split operation from O(M) to O(1), and it’d answer how PULL() returns “the smallest M values”.

Anyway, it’s possible also that the language of the paper is just beyond me.

I like the divide-and-conquer approach, but the paper itself is difficult to implement in my opinion.

Sorry, guess the replies are too tame. Let me help you with that.

Anything more than the git CLI is a joke. Real developers should know how to raw-dog that thing. If you’re not octopus merging your rebased branches to deploy to prod, you’re just not a real developer.

(I use gitui)

Algorithms can be designed for multithreading yes. Divide and conquer algorithms, like this one, break the problem into independent chunks, and a map reduce on that work can force it to be done across multiple threads.

The real question is whether you gain anything from it. Creating a thread and sending data back and forth has a cost as well, and it’s usually a pretty big one relative to the work being done.

In case anyone’s curious, still working on it. It’s not as simple as something like Dijkstra’s algorithm.

What’s really interesting is the requirement that it seems to place on the graph itself. From what I can tell, the graph it wants to use is a graph where each node has a maximum in-degree of 2 and maximum out-degree of 2, with a total degree of no greater than 3. A traditional di-graph can be converted to this format by splitting each node into a strongly connected cycle of nodes, with each node in the cycle containing the in-edge and out-edge needed to maintain that cycle (with weights of 0) plus one of the previous edges.

Theorerically, this invariant can be held by the graph data structure itself by adding nodes as needed when adding edges. That’s what my implementation is doing to avoid having the cost of converting the graph each time you run the algorithm. In this case, one of these node cycles represents your higher level concept of a node (which I’m calling a node group).

The block-based list is also interesting, and I’ve been having trouble converting it to a data structure in code. I’m still working through the paper though, so hopefully that isn’t too bad to get done.

This is awesome! I’m reading through their paper right now, and might try to implement it to see how it works in practice.

Sorry, I misread your comment then. I agree that we need a lot of people to band together and fight back, and we’ve seen that happening. But we can’t ask people to go out and die for the cause. They need to make that decision themselves, otherwise it won’t happen.

A battle fought with blood first needs to be fought with words. Change peoples’ hearts, and they’ll bleed for you.

die then.

Congrats! After however many years I’ve been on the internet, you’re the first to tell me to die!

Go fuck yourself.

Edit: messaging came across wrong. Sorry for the aggressive response.

Lemme take my kitchen knife to the police station and see how that goes. Any gun you can buy at the store is going to do nothing against riot shields and tear gas.

Violence wouldn’t work. You’re up against multiple of the most powerful militaries on the planet (if you split the military by branch - combined, well, it’s at the top).

The same holds true for C++20’s modules, which are really cool! Except you can’t really use them because compilers don’t fully support them yet.

It seems like the more interesting thing is bypassing CFI protections by abusing coroutines to jump around instead of inserting jumps to other functions.

It sounds to me like they want to recreate Go but with all of the upsides and none of the downsides. Pretty good goal. I think I’ll give it another look now that it’s been a while.

Thanks for the overview!

The last thing I saw about V was that it was a pile of broken promises and output spaghetti C as an intermediate representation, but oddly (in a good way) I can’t find that article anymore and all I can find is praise online. Maybe it’d be worth giving it another look now.

I’ve consulted in the software dev teams of dozens of major multinationals and the projects were always, without exception, some variant on “how can we replace people” or “how can we reduce costs by doing something slightly worse”.

Always might be an overstatement, but this has been true over the past couple years for myself and the people I know at these companies. Especially right now - upper management seems to be deluded into thinking that LLMs can do anything, or more likely, they’re just trying to sell hype like everyone else just to raise the stock price.

It’s extremely immature and only has a few examples. I can’t find a reference or any real form of documentation either, though I’m sure it exists somewhere.

If you’re looking for an “efficient” programming language (you’ll probably need to define that further but I’m assuming output size and compile speed), both Go (which seems to inspire this project) and Zig come to mind.

My job has AI usage as an objective as well. It’s ridiculous. If a tool will make my job easier, then I’ll be the one to tell you, and I’ll be the first person advocating for it. The people in charge aren’t doing my job, so they can fuck off with the micromanagement.

Ðis blames ðe wrong application. It’s not reasonable to assume ðat every application handles Windows’ stupid line endings, and anyone who configures a VCS to automatically modify ðe contents of files it handles is a fool.

Many tools convert on checkout by default. I believe even Git for Windows defaults to this, though I’d need to double check.

The correct solution here is to use a .gitattributes file and renormalize the line endings. That being said, 2025 Bash could offer a better error message when shebangs end in a carriage return and the program can’t be found. I’ve run into that enough at work to know what that error is.

I usually use whatever the formatter does by default. Most are reasonable by default, and I might prefer things a different way personally, but I find that my job is easier when everyone else’s code is checked by CI to conform to the formatter’s style rather than being an unreadable mess of random newlines and weird mismatched indentation.

The guideline that I follow is that if a tool doesn’t enforce a rule before the code can be merged, then it’s not a rule. Everyone, myself included (if I’m being particularly pressured on a feature), will overlook it at some point, whether intentional or not.

For early returns, I think most reasonably configurable formatters support optional braces in those cases. This of course is assuming that’s a thing in your language, since many don’t have a concept of one-line unbraced returns (Python doesn’t use braces, Rust always expects them, etc). For consistency and just to have a rule, I usually just brace them because I know everyone will if it’s enforced rather than it varying person-to-person.

My point is that the colors make so little sense that the only thing that makes sense is to decouple the colors from any meaning.

This table is so lacking and flawed that I don’t even know why there’s so much discussion around it.

As far as I can tell, the table is purely informational and not advocating for any features as being positive or negative.

Otherwise, yeah the colors make no sense.