hexomancer

Here are some objective issues with this page that I don't think is really up to taste (honestly these are so obvious that I assume you viewed the website on mobile which is fair, I never used the mobile version. Because I don't think anyone in good conscience would argue with the terribleness of the desktop version of the website). Note that I will not include many taste-based issues with the website (like the god-awful mouse cursor) because they could be attributed to taste. The following issues are objective issues though:

- Low performance. Because the website steals cursor rendering, moving the cursor feels bad and laggy. - The icon for the "menu" looks exactly like the mouse cursor. I don't think this constitutes good design.

- Also the icon for the menu doesn't look like the extremely established menu icon (even though it changes to that when you hover over it). Initially I th ought maybe it is a dark/light mode toggle.

- Speaking of the dark mode, the page flashbangs you halfway through scrolling the page for absolutely no reason.

- The link texts are borderline unreadable in the "light" section of the page when you hover over them.

It's funny that the people who designed this monstrosity of a web page feel qualified enough to advice other people about design.

This is false. The const of producing a single token is linear but the cost of producing an entire sequence of length N is O(N^2) still (which is always what we meant when we talked about quadratic cost not the cost of a single token).

When I read the title I thought maybe they implemented a typescript to binary (instead of javascript) code compiler that speeds up the program by 10x, it would also have the added benefit of speeding up the compiler by 10x!

I don't think that is too far fetched either since typescript already has most of the type information.

Do you not see how your argument could be applied to steam engines putting human laborers out of work? Or computers putting (human) calculators out of work? Do you think inventing the steam machine or computers was a mistake too?

Isn't the fact the P40 has horrible fp16 performance a deal breaker for local setups?

Here is how I make sense of it (I have no expertise in this subject, please feel free to correct me if I am wrong): I think when the model is pretrained on the internet, it does gain most of the skills required to do mathematical reasoning, however, since its task is to predict the next word distribution on the entire internet, it does not normally use this ability, since most of the text on the internet is not this type of reasoning text (think of generative image models a few years ago, where appending "unreal engine" to a prompt would significantly improve the quality of the output, the reason was that the model was trained to generate the distribution of the images on the internet, most of them are not particularly impressive, however, since images containing "unreal engine" were usually high-quality screenshots of images, it would also move the distribution of generated images towards higher quality generations). So I think the model already has most of the ability, it just needs to adjust a few connections to actually utilize this latent skill, so it makes sense that a few training examples are enough to adjust the connections to increase mathematical reasoning skills.

That's beside the point but you are probably referring to harry potter and the chamber of secrets not the half-blood prince.

Page 31 is interesting, where apparently in the task of creating PRs for an internal repository the o3-mini models by far have the lowest performance (even worse than gpt-4o). What is up with that?

If I publish some c++ code that has some hard-coded magic values in it, can the code not be considered open source until I also publish how I came up with those magic values?

A- Who cares?

B- The latex source of the book is available on the ArXiv page.

I wouldn't call the case with two sequence "some narrow version". It is by far the most common instance of the problem and honestly the first thing that pops into my mind when I hear LCS, that's why I was very surprised to hear it was NP-hard but it does make sense for an arbitrary number of sequences.

This works the same in vscode as it does in vim as far as I am aware. e.g. `:vs` to split the window and moving between windows uses the same shortcuts as it does in vim.

All of those are available in the vscode plugin.

Can you give example of vim features that you miss in the vscode plugin? Mainly because I likely don't know about them and I would like to add them to my toolkit (the surround thing is not a vim feature, it is a plugin, although the vscode plugin has that too)

Nope, with reverse-debugging enabled it will be insanely slow, not something that you can miss.

I am curious does your project have large external dependencies or is it self-contained.

Have you actually compared the debug performance of a large cross-platform application on windows vs linux?

I am not saying that you haven't just trying to make sure that your argument is backed by data rather than heresay.

How large is your code base? I am talking about 100K+ LOC with many complex dependencies (mainly Qt modules).

Slightly off topic but I think it is a good place to ask: One of the few things from windows that I miss when using linux is the debugging experience with visual studio (not code). When debugging a medium-sized C++ project on windows, the launch of the debug build is pretty fast and stepping over lines is almost instantaneous. On linux launching the executable using gdb takes like 10 seconds loading modules and stepping over each line takes like half a second which I think is intolerable (lldb is even worse). Yet I don't see people complaining about this online very much. Am I missing something? E.g. is there a compiler flag that speeds up debug launch time and step speed that I am not using?

Not the recent denuvo versions, and not in the past ~1 year.

That's not even the point though, I am not saying it is literally impossible to circumvent this, but as long as it is hard enough that it is not financially reasonable for the cheat makers, that's good enough.

Well I assume there are ways to prevent that (or make it extremely difficult at least)? E.g. look at denuvo, nobody has been able to "open a hex editor" and disable denuvo.

By the same argument we should prevents the users from running any program at all because it might be malware.

It's not the cheat that has to be accepted, it is the game. The option prevents the cheats (or any other program) from being able to examine the game's memory.

It's not the cheat that has to be accepted, it is the game. The option prevents the cheats (or any other program) from being able to examine the game's memory.

That's why I said the user has to explicitly accept that.

One thing I don't understand and I would really appreciate if someone could explain this to me.

Why do we need separate anti-cheat programs? Can't the operating systems simply have an option when creating a process that prevents all operations looking at the memory of the process (and maybe if such a process is about to be launched the user has to explicitly accept that by clicking a button)? Wouldn't that stop almost all the cheats without needing separate anti cheat programs, since I assume those programs have to use OS facilities to mess with the game anyway.

You are looking for this: https://github.com/igrigorik/vimgolf

Not only is this not a valid proof, I don't think the author even knows the definition of P vs NP problem.

This is not "leaked", this is on official stanford youtube channel.

I am ok with desktop environment exploring new ideas and it is very cool that linux allows them to do so (e.g. I myself am a big fan of tiling window managers and it is one of the main things I miss when I am not using linux).

What I am not okay with is myriad of linux window managers which are 99% the same generic window manager. How much effort is being split between KDE/Gnome despite them being essentially the same thing? How much effort was wasted in unity?