- p1neconeI'm holding out for someone to ship a gpu with dimm slots on it.
- The difference from 2015 to 2025 is enormous.
Gaming on linux in 2015 was a giant pita and most recent games didn't work properly or didn't work at all through wine.
In 2025 I just buy games on steam blindly because I know they'll work, except for a handful of multiplayer titles that use unsupported kernel level anticheat.
- Now: AI generates incorrect code.
Future: AI generates incorrect code, and formal verification that proves that the code performs that incorrect behaviour.
- A receiver has always been a pretty standard part of even really simple AV setups - you can get half decent ones pretty cheap, and then you just run either the HDMI ARC port or the optical/coax digital audio out from your tv to the receiver so that everything you plug into your tv has it's audio go out to the speakers.
- I doubt many real world use cases would run out of incrementing 64 bit ids - collisions if they were random sure, but i64 max is 9,223,372,036,854,775,807 - if each row took only 1 bit of space, that would be slightly more than an exabyte of data.
- Being able to create something and know the id of it before waiting for an http round trip simplifies enough code that I think UUIDs are worth it for me. I hadn't really considered the potential perf optimization from orderable ids before though - I will consider UUID v7 in future.
- I think the writers classification of this being a Chinese vs English distinction is a bit presumptuous - the portion of the USA OP is familiar with maybe, but I'll jump on the bandwagon to say this kind of negated negative language is very very common in New Zealand.
Not bad, not wrong, no problem etc etc are all very common, and we have the following too:
Nah yeah = yes
Yeah nah = no
Yeah nah yeah = yes
Nah yeah nah = no
...extend outward to your hearts desire
(yes people commonly say all of the above)
- I think besides the mechanics, the other thing that makes the grandia/grandia 2 battle system so fun is how snappy all the animations and interactions are. You never really feel like you're waiting for things to happen even though it is semi turn based.
- I've used llms to help me write large sets of test cases, but it requires a lot of iteration and the mistakes it makes are both very common and insidious.
Stuff like reimplementing large amounts of the code inside the tests because testing the actual code is "too hard", spending inordinate amounts of time covering every single edge case on some tiny bit of input processing unrelated to the main business logic, mocking out the code under test, changing failing tests to match obviously incorrect behavior... basically all the mistakes you expect to see totally green devs who don't understand the purpose of tests making.
It saves a shitload of time setting up all the scaffolding and whatnot, but unless they very carefully reviewed and either manually edited or iterated a lot with the LLM I would be almost certain the tests were garbage given my experiences.
(This is with fairly current models too btw - mostly sonnet 4 and 4.5, also in fairness to the LLM a shocking proportion of tests written by real people that I've read are also unhelpful garbage, I can't imagine the training data is of great quality)
- This is true of basically everything people complain about having gotten worse over time.
Whiteware and kitchen appliances are the same - you can absolutely buy a fridge, or a stand mixer or whatever that will work well and last forever. It's just the value proposition compared to cheap crap that will still likely last for a few years but at a 1/5th of the price is not great unless you're going to use it really heavily.
- Every so often I try out a GPT model for coding again, and manage to get tricked by the very sparse conversation style into thinking it's great for a couple of days (when it says nothing and then finishes producing code with a 'I did x, y and z' with no stupid 'you're absolutely' right sucking up and it works, it feels very good).
But I always realize it's just smoke and mirrors - the actual quality of the code and the failure modes and stuff are just so much worse than claude and gemini.
- I like goldilocks services, as big or as small as actually makes sense for your domain/resource considerations, usually no single http endpoint services in sight.
- In my defense - the paragraph under the 'Storage' header reads like what I said to me, whereas the 'Bulk Storage Hard Disk Drives' header says something kind of contradictory to that. ('Collection of brand new parts' vs 'my own decommissioned hard drives')
- Looks like they built a new NAS, but kept using the same drives. Which given the number of drive bays in the NAS probably make up a large majority of the overall cost in something like this.
Edit: reading comprehension fail - they bought drives earlier, at an unspecified price, but they weren't from the old NAS - I agree, when lifetimes of drives are measures in decades and huge amounts of tbw it seems pretty silly to buy new ones every time.
- It's absolutely possible to use an LLM to generate code, carefully review, iterate and test it and produce something that works and is maintainable.
The vast majority of of LLM generated code that gets submitted in PRs on public GitHub projects is not that - see the examples they gave.
Reviewing all of that code on its merits alone in order to dismiss it would take an inordinate amount of time and effort that would be much better spent improving the project. The alternative is a blanket LLM generated code ban, which is a lot less effort to enforce because it doesn't involve needing to read piles and piles of nonsense.
- I'm in a committed long term relationship. I absolutely do not want to shit in front of my partner (nor do they have any desire to watch).
- Implementing all of those things is an order of magnitude more complex than any other first class primitive datatype in most languages, and there's no obvious "one right way" to do it that would fit everyones use cases - seems like libraries and standalone databases are the way to do it, and that's what we do now.
- I feel like I'm going insane reading how people talk about "vulnerabilities" like this.
If you give an llm access to sensitive data, user input and the ability to make arbitrary http calls it should be blindingly obvious that it's insecure. I wouldn't even call this a vulnerability, this is just intentionally exposing things.
If I had to pinpoint the "real" vulnerability here, it would be this bit, but the way it's just added as a sidenote seems to be downplaying it: "Note: Gemini is not supposed to have access to .env files in this scenario (with the default setting ‘Allow Gitignore Access > Off’). However, we show that Gemini bypasses its own setting to get access and subsequently exfiltrate that data."
- Yeah I tried that once following some advice I saw on another hn thread and the results were hilarious, but not at all useful. It aggressively nitpicked every detail of everything I told it to do, and never made any progress. And it worded all of these nitpicks like a combination of the guy from the ackchyually meme (https://knowyourmeme.com/memes/ackchyually-actually-guy) and a badly written Sherlock Holmes.