airesQ

Shameless plug for my own project, Quake-SRP (the Slop Rust Port).

Video: https://www.youtube.com/watch?v=8TvVMzyxACc

Browser(shareware): https://quake-srp.pages.dev/

Source: https://github.com/terrapapagalli1516/quake-srp

There's Quake-SRP (the Slop Rust Port), code here: https://github.com/terrapapagalli1516/quake-srp

Playable in the browser (shareware version): https://quake-srp.pages.dev/

It's a faithful port of Quake's original software renderer. Everything happens on the CPU, which made it easier to match the original exactly. In theory the same could be done on a GPU, but I think it would be harder and messier.

The trade-off with software renderer is that it's more code. With GLQuake much of the actual rendering work is handed off to OpenGL itself, i.e. the driver and the GPU. In the software renderer, the engine does all of that in its own code.

This took about 4 months as a hobby project; I don't know how much of that was work and how much was "waiting for the next model", probably a mix of both.

Since this ended up on Hacker News, I'll say it: I find the discourse around LLMs strangely sad. They're annoying, yes, and they make mistakes every day, every hour. But they're also amazing, and working with them has been one of the most rewarding things I've done in years.

Historically things that make people more productive have tended to make us richer, not poorer. And it's a virtue to change your mind as the evidence comes in.

We played with Lego all our lives; now the Lego understands us and helps us build. I think that's something to be glad about.

Author here (someone else submitted it, thx). There's a video as well, a six-minute video on how it works and the various QoL that we added (made by AI with human assistance):

* https://youtu.be/8TvVMzyxACc

It does have various improvements over the original version. And I don't agree with the notion that "all work that relies on LLMs requires no effort". If this were the case, we would have plenty of complete Rust ports of Quake. It's open-source, allegedly super easy to port. But as far as I know, we did not.

That's for quake 3, the fast inverse square root was not present in quake 1.

Jacobian conjecture disproved? Doesn't even make it to the list.

> How surreal is it that we are not absolutely jaw-dropped by these types of capability improvements?

Agree

Is IntelliJ "bad"? Aren't the reactions here overly negative?

This means the company is funded, development will continue, zed will continue to improve. An IntelliJ style license (for example) is an acceptable trade-off from my point-of-view

There's a slower and arguably better version of Pärt's "De Profundis":

* https://www.youtube.com/watch?v=twzmflIdYmw

Incredible work.

So much depth; initially I thought it's "just" a 3d model. The animations are amazing.

The new entrants would be on the design side. If Intel no longer holds the keys to best fab-tech in the world then all bets are off.

(I'm assuming that Intel doesn't allow competitors to use their fabs; and that Intel does indeed have the best fab-tech at the moment; maybe I'm wrong.)

Is it just me or the competition on the CPU market is about to get really interesting? My understanding is that if Intel loses the edge on fab-tech then the door is open for all kinds of new entrants. (I could be wrong though.)

Who knows, perhaps even Intel will use TSMC's process at some point.

I feel like there is a big audience for fish with bash support.

This could be a nice project; lets call it "shark".

Their papers[1] are also quite good.

[1] - https://research.fb.com/publications/

Perhaps Huawei will buy them. (speculating here)

This will foment a lot of anger.

It does look to me that the US is really at its best here in applying the rule of law, and following the contract it had with ZTE to the letter.

But others will find it hard to believe, especially with Trump at the helm.

Lack of cash is not one of Apple's problems. If they wanted to invest more in the US they could.

Most of the money will probably just sit still in a wide variety of investments (bonds and other stuff; Apple is one of the biggest players in these markets); the rest will go into dividends and share buybacks. A symbolic percentage might go into R&D and Trump will tweet about it.

(I might be wrong, but that is what I expect.)

Worked on my system.

(Set cache_hit_threshold to the default value of 80, my cpu is an Intel i7-6700k.)

Given Intel's dominance of the server market does this mean that datacenter computational capacity will see an overnight ~5% drop?

Is there enough spare capacity to cope with this? Will spot-instance prices go up? Will I need more instances of a given type to run the same workload?

Couldn't the algorithm give its judgement before the video goes live?

Calling Avago "virtually unknown" might have been too dismissive from my part.

But lets consider 2013. Avago had a revenue of $2.5bn, respectable, but that's not much when compared with Qualcomm's $24.9bn, less than Broadcom's $8.3bn, NXP's $4.8bn, and Freescale's $4.1bn.

In fact it seems that at least when it came to revenues, Avago was the smallest company on that list.

What a crazy turn of events. After all this M&A activity, Avago, a virtually unknown company, might end up owning Broadcom, Qualcomm, NXP and Freescale.

How is this even possible? Who is financing these guys?

In vscode is it possible to use alt+backspace to delete a word till the next '_' (underscore) or '-'(dash)? (ctrl-backspace works, but that deletes the whole word.)

This is something I do all the time in atom, and miss quite a bit when using vscode (for typescript).

Love Python, but gosh, the lack of type checking. It might not seem like a problem with small applications, but it makes navigation and refactoring of large codebases much harder than it needs to be.

Yes there are type annotations, but they are just that at the moment, annotations. There isn't, as far as I know, a good type checker, or IDE that makes good use of them.

Ironically, an extended version of this transpiler could potentially be used to convert annotated python to Typescript. And poof! Proper type-checking in Python.

WiFi doesn't have an easy life either:

- It needs to work on unlicensed spectrum, which means that it has to play well with all manner of devices that contend for this spectrum (e.g. other WiFi devices, Bluetooth, IEEE802.15.4). In practice this means that it cannot do much beyond CSMA/CA (i.e. the 'listen before talking' thing). CSMA/CA is a terrible contention mechanism for high density scenarios, and before long much of the air-time is taken by collisions. LTE does not have this problem, it works on licensed spectrum, as such, an LTE base station can just divide the time/spectrum blocks and allocate them to the various contending devices as it pleases (as it owns the spectrum), making almost optimal use of the spectrum that is available to it. 802.11ax will improve on this a bit (e.g. it will have OFDMA, which reduces the collision domain; it will allow the AP do to some coordination, via 'trigger' frames)

- Wifi has a lot of luggage; IEEE 801.11ax will be backward compatible with tens of billions of devices going all the way to IEEE 802.11b, which came out in 1999.

- Costumers don't like spending all that much money on Wifi. This cost-pressure means that we don't have as many people looking into WiFi as we should (people writing drivers; people debugging problems; radio engineers; investment in testing equipment).

- MIMO (introduced in 802.11n), downstream MU-MIMO (introduced in 802.11ac), and upstream MU-MIMO (to be introduced in 802.11ax) are all technically impressive, but also very hard to implement well. (But we are now starting to see the benefits of this, particularly the 802.11ac wave2 devices.)

Anyway, I have high hopes for WiFi, well beyond a billion WiFi chips are sold every year, and it is getting better all the time.

It seems that we have deep learning applied to MRI:

  A deep-learning algorithm that primarily uses surface area
  information from magnetic resonance imaging of the brain of 
  6–12-month-old individuals predicted the diagnosis of autism  
  in individual high-risk children at 24 months (with a 
  positive  predictive value of 81% and a sensitivity of 88%).

This is a true tour-de-force in computer security.

The way they exploit the MMU page table walk is just exquisite.

It might well be.

Jordan's military leadership is surprisingly competent, with lots of forward thinking, preparations and plans for eventualities.

I really abhor this recent escalation, and hope this will be a transient phenomenon.

But if things came to the worse, the EU would just have to emulate China.

China seems to manage just fine without Google, Twitter, Facebook and Amazon. Make life difficult for foreign competitors, and let the internal market take care of the rest. No need for a top down approach.

The thing is that most internet companies are big due to network effects, not because the underlying technology is hard to replicate. Ban Facebook in the EU, and we would have a new version in a few months. Ditto for Twitter. Google is a bit more challenging, but it would be possible to get a 'goodish' clone going in a short while.

(The same would not be the case for Intel, Texas Instruments, Qualcomm, Altera, etc... These companies do have something that is hard to replicate, and goes beyond network effects).

I did a brief survey before deciding to go with skip lists, and found them to be easier to grasp and reason about. (e.g. there is no need to balance trees; a skip list is very similar to a linked list, and linked lists are very simple).

I remember somebody saying that "in a sane world skip lists would always have been discovered before red-black trees".

This historical accident (skip lists were only discovered 1989; while rb-trees date back to the 1970s) is probably the reason why skip list use is not more widespread, and seen as somewhat exotic at times.

(AVL and Splay-trees also predate skip lists.)