HNHacker News
TopNewBestAskShowJobs

twotwotwo

1,841 karma · joined June 24, 2012

submissionscomments
twotwotwo··on Data modeling guide for real-time analytics with ClickHouse
[Edited to add: looking at comments from saisrirampur and SnooBananas6657, ClickHouse has worked some on joins recently, and there's a very recent a PR around optimizing join order. Cool!]

In playing a little with ClickHouse, issues with joins were one of the biggest things that jumped out at me.

It wouldn't change the join order to try to ensure the smaller side was in RAM. It wouldn't propagate WHERE conditions to the other side of a join, so "WHERE a.customer_id=3 AND b.customer_id=a.customer_id" wouldn't automatically filter the scan of b to blocks where b.customer_id=3. Projections could theoretically be used to speed joins on the projection's ORDER BY columns, but it didn't appear to happen. You'd sometimes need to manually set the join algo for best performance, when I'd rather the optimizer choose it, maybe adaptively based on whether it seemed to make sense to do a join in-RAM.

ClickHouse was also great at certain things, like scanning a ton of rows very efficiently and interfacing with lots of systems (its table functions could pull from lots of sources). It was easy to pick up and start playing with, and seems to have found use in a lot of organizations and at substantial scale. And there are a lot of features that look potentially quite powerful (incremental materialized views, aggregating/deduping merge tree variants, etc.). The best way I could process what I saw experimenting with it was that they'd focused on a providing really efficient low-level execution engine, but sometimes you needed to act as the query optimizer.

twotwotwo··on Use One Big Server (2022)
> [Hetzner] charges a "one time setup" fee to create that VM. That puts a lot of back pressure on infrastructure decisions and removes any scalability you could otherwise enjoy in the cloud.

Hetzner Cloud, then! In the US, $0.53/hr / $333.59/mo for 48 vCPU/192GB RAM/960GB NVMe. Includes 8 TB/mo traffic, when 8 TB egress would cost $720 on EC2; more traffic is $1.20/TB when the first tier of AWS egress is $90/TB. No setup fee. Not that it's EC2 but there's clearly flexibility there.

More generally, if you want AWS, you want AWS; if you want servers you have options.

twotwotwo··on Hacking Diffusion into Qwen3 for the Arc Challenge
It is kind of wild that most coding tasks are editing tasks, and we humans care a lot about code editing tools, but automated tools use code generation for editing where a valid block must be generated top-to-bottom in one go.

Fixing a mistake requires re-generating the file or block of code. Or, if something generated later has implications for earlier code--a new import or function parameter's required, something like that--the only option is to go back and re-generate a big chunk. That'd be inefficient for humans, not implausible it's wrong for other code generators too.

I don't know if diffusion specifically will be the approach. (Maybe there's something to generating edit sequences?) This post's note that diffusion kills KV caching is something I hadn't even considered. It does seem right to experiment with things other than strict start-to-end generation.

twotwotwo··on At a Loss for Words: A flawed idea is teaching kids to be poor readers (2019)
trane_project is selling a $20/mo subscription or $1000 perpetual license to their own reading program and folks should read this and their other comments aware of that context. It's disappointing to tell a personal story, come back, and see it was someone's jumping-off point for just slightly indirect self-promotion.
twotwotwo··on At a Loss for Words: A flawed idea is teaching kids to be poor readers (2019)
For what it's worth, a pivotal moment for keeping reading going after the lessons was when my partner picked up a comic book at a library event. For a few weeks after the end of the lessons, reading time had been traditional early readers and some of the books we'd previously read to them--even with us offering rewards, there had been ups and downs. As soon as kid started that comic, though, they were pushing right through our protests that it was bedtime, and chewing through the whole series. Luckily we managed to find another series to start before running out of the first one. As parents we can nudge or put stuff on the menu but but kid is pretty much in the driver's seat about what to read next.

In retrospect, of course! The kid just hadn't liked reading those books and things took off once we found stuff they liked. Best first readers are whatever your kid actually wants to read!

twotwotwo··on At a Loss for Words: A flawed idea is teaching kids to be poor readers (2019)
For any parents of small kids here, I have to mention the book Teach Your Child to Read in 100 Easy Lessons. We went through it while my kid was in kindergarten, and after that, I absolutely believe what I've heard from parents who did it successfully a bit earlier. And it didn't prevent my kid from figuring out how to use context or recognize full words. Reading English is a lot, and kids are resourceful; if we teach the 'slow' but reliable way to read, they'll be happy to feel out shortcuts.

The toughest thing was getting a reliable bit of time each day to sit down and do it. Routine, cajoling, and rewards were all involved. So was keeping it lighthearted; the kid has to be on board! Each lesson has straightforward exercises then a brief story, very short at first, longer later in the book. We'd do the exercises and one read of the story, then kid would read the story to my partner. We started in September, and I remember by Halloween the kid was reading candy wrappers. After finishing it, the next big thing was finding stories the kid genuinely liked to keep it going. Continuing to read together after the lessons ended helped: for a while, kids will keep running into lots of new exceptions to the usual rules, etc.

English spelling and pronunciation are a lot, and the book is also, implicitly, a catalog of the tricks English plays on kids and other learners. Part of the book uses a semi-phonetic alphabet where e.g. ee and sh/ch/th have distinct glyphs, but it all still looks enough like English that the jump to regular writing later in the book is doable for the kid. Even with that alphabet, the book has to teach common words like "is" and "was" as exceptions (with s sounding like z). Decades later one can forget little kids deal with all this and eventually handle it like second nature.

The book's originator thought that you could teach math with a broadly similar approach--breaking things down into very small steps and practicing them in isolation then in larger tasks--and doing that was part of his career, but I haven't found similar teach-your-kid book for arithmetic/basic math. If such a book did exist I'd've given it a try!

twotwotwo··on Developing our position on AI
It was insightful of him and there absolutely are similar strains of hype today!

He also both points out the silliness of the pitch for the hype-y tech of the day and calls that same tech a tool some might use with good reason.

That doesn't read to me like "tech hyped as inevitable is never okay" but more like "ignore sales pitches and evaluate the hyped tech for yourself." Your own judgment of today's hyped tech might be "kill it with fire." Still, it seems fully in sync with the spirit of that passage for Recurse to ask for a bunch of smart people's varied opinions on it and share them with the world.

twotwotwo··on Local LLMs versus offline Wikipedia
The "they do different things" bullet is worth expanding.

Wikipedia, arXiv dumps, open-source code you download, etc. have code that runs and information that, whatever its flaws, is usually not guessed. It's also cheap to search, and often ready-made for something--FOSS apps are runnable, wiki will introduce or survey a topic, and so on.

LLMs, smaller ones especially, will make stuff up, but can try to take questions that aren't clean keyword searches, and theoretically make some tasks qualitatively easier: one could read through a mountain of raw info for the response to a question, say.

The scenario in the original quote is too ambitious for me to really think about now, but just thinking about coding offline for a spell, I imagine having a better time calling into existing libraries for whatever I can rather than trying to rebuild them, even assuming a good coding assistant. Maybe there's an analogy with non-coding tasks?

A blind spot: I have no real experience with local models; I don't have any hardware that can run 'em well. Just going by public benchmarks like Aider's it appears ones like Qwen3 32B can handle some coding, so figure I should assume there's some use there.

twotwotwo··on The Capacity, Performance, and Reliability of MicroSD Cards
Flash endurance gets a sort of odd amount of discussion on the Internet, and this adds to the small amount of public data from running lots of Flash devices to exhaustion. (MicroSD != SSD, of course, but it's something.)

Seems possible that by charting it, you could find a "bathtub curve" (early failures/steady state/failures due to use) of failures, probably more than one curve breaking up by category--tiny "industrial" cards made for endurance are unsurprisingly surviving the longest, and counterfeits and (some but not all!) unknown brands are at the bottom. It would be interesting to also see the data on cards that haven't failed yet, i.e. how many write cycles they've survived so far.

(You can sort the table at https://www.bahjeez.com/the-great-microsd-card-survey/all-mi... by cycles until first error to see what I mean. Love the Bart Simpson card coming in at #8.)

One thing the reported averages already show, which is more about reliability stats in general than about Flash, is that the average write cycles survived is way higher than, say, the cycle count after which you'd see 5% of devices fail. The lower "n% will fail" number might be what informs the TBW spec on the box. So if you're able to handle failures gracefully and run drives 'til they drop, that probably adds substantially to how long you can run each device.

twotwotwo··on What 'Project Hail Mary' teaches us about the PlanetScale vs. Neon debate
I give credit to Andy Weir for knowing what The Martian did well--setting up a bunch of technical problems as load-bearing elements of a plot--and going and executing that same general plan, but with new particulars and bigger and with fun new ideas. The made-up sciencey stuff feels infused with principled ideas about how new things we haven't discovered might work, rather than designed for their role in the story alone. And he's willing to write an ending!

There are things he does not stand out at, but those don't take you out of the story. As people work through things on Earth a lot of the nontechnical parts are, I guess, simplified, but I can't care that much; I didn't pick this up wanting a bureaucratic or psychological thriller. And he (or he + early readers and editors) usually make sure to quickly and efficiently get you through all of that to the next fun part.

twotwotwo··on Why JPEGs still rule the web (2024)
I recognize it as beating a dead horse now, but JPEG XL did what was needed to be actually adopted. AVIF has not been widely adopted given the difficulty of a leap to a new format in general and the computational cost of encoding AVIF specifically.

One of JPEG XL's best ideas was incorporating Brunsli, lossless recompression for existing JPEGs (like Dropbox's Lepton which I think might've been talked about earlier). It's not as much of a space win as a whole new format, but it's computationally cheap and much easier to just roll out today. There was even an idea of supporting it as a Content-Encoding, so a right-click and save would get you an OG .jpg avoiding the whole "what the heck is a WebP?" problem. (You might still be able to do something like this in a ServiceWorker, but capped at wasm speeds of course.) Combine it with improved JPEG encoders like mozjpeg and you're not in a terrible place. There's also work that could potentially be done with deblocking/debanding/deringing in decoders to stretch the old approach even further.

And JXL's other modes also had their advantages. VarDCT was still faster than libaom AVIF, and was reasonable in its own way (AVIFs look smoother, JXL tended more to preserve traces of low-contrast detail). There was a progressive mode, which made less sense in AVIF because it was a format for video keyframes first. The lossless mode was the evolution of FUIF and put up good numbers.

At this point I have no particular predictions. JPEG never stopped being usable despite a series of more technically sophisticated successors. (MP3 too, though its successors seemed to get better adoption.) Perhaps it means things continue not to change for a while, or at least that I needn't rush to move to $other_format or get left behind. Doesn't mean I don't complain about the situation in comments on the Internet, though.

twotwotwo··on Clinical knowledge in LLMs does not translate to human interactions
At work, one of the prompt nudges that didn't work was asking it to ask for clarifications or missing info rather than charge forward with a guess. "Sometimes do X" instructions don't do well generally when the trigger conditions are fuzzy. (Or complex but stated in few words like "ask for missing info.") I can believe part of the miss here would be not asking the right questions--that seems to come up in some of their sample transcripts.

In general at work nudging them towards finding the information they need--first search for the library to be called, etc.--has been spotty. I think tool makers are putting effort into this from their end: newer versions of IDEs seemed to do better than older ones and model makers have added things like mid-reasoning tool use that could help. The raw Internet is not full of folks transparently walking through info-gathering or introspecting about what they know or don't, so it probably falls on post-training to explicitly focus on these kinds of capabilities.

I don't know what you really do. You can lean on instruction-following and give a lot of examples and descriptions of specific times to ask specific kinds of questions. You could use prompt distillation to try to turn that into better model tendencies. You could train on lots of transcripts (these days they'd probably include synthetic). You could do some kind of RL for skill at navigating situations where more info may be needed. You could treat "what info is needed and what behavior gets it?" as a type of problem to train on like math problems.

twotwotwo··on Why DeepSeek is cheap at scale but expensive to run locally
The latest V3 strikes me as a really practical go-to among open-weights models. Lots of tasks don't need the reasoning tokens, and not having to wait for them is nice. (If something does need it you can always switch.) If you're not running it yourself a couple providers have it with full context, 80tps, and a promise not to use your data.

9004 home server is awesome!

twotwotwo··on Devstral
Any company in this space outside of the top few should be contributing to the open-source tools (Aider, OpenHands, etc.); that is a better bet than making your own tools from scratch to compete with ones from much bigger teams. A couple folks making harnesses work better with your model might yield improvements faster than a lot of model-tuning work, and might also come out of the process with practical observations about what to work on in the next spin of the model.

Separately, deploying more autonomous agents that just look at an issue or such just seems premature now. We've only just gotten assisted flows kind-of working, and they still get lost--get stuck on not-hard-for-a-human debugging tasks, implement Potemkin 'fixes', forget their tools, make unrelated changes that sometimes break stuff, etc.--in ways that imply that flow isn't fully-baked yet.

Maybe the main appeal is asynchrony/potential parallelism? You could tackle that different ways, though. And SWEBench might be a good benchmark still (focus on where you want to be, even if you aren't there yet), but that doesn't mean it represents the most practical way to use these tools day-to-day currently.

twotwotwo··on Mercury: Commercial-scale diffusion language model
It's kind of weird to think that in a coding assistant, an LLM is regularly asked to produce a valid block of code top to bottom, or repeat a section of code with changes, when that's not what we do. (There are other intuitively odd things about this, like the amount of compute spent generating 'easy' tokens, e.g. repeating unchanged code.) Some of that might be that models are just weird and intuition doesn't apply. But maybe the way we do it--jumping around, correcting as we go, etc.--is legitimately an efficient use of effort, and a model could do its job better, with less effort, or both if it too used some approach other than generating the whole sequence start-to-finish.

There's already stuff in the wild moving that direction without completely rethinking how models work. Cursor and now other tools seem to have models for 'next edit' not just 'next word typed'. Agents can edit a thing and then edit again (in response to lints or whatever else); approaches based on tools and prompting like that can be iterated on without the level of resources needed to train a model. You could also imagine post-training a model specifically to be good at producing edit sequences, so it can actually 'hit backspace' or replace part of what it's written if it becomes clear it wasn't right, or if two parts of the output 'disagree' and need to be reconciled.

From a quick search it looks like https://arxiv.org/abs/2306.05426 in 2023 discussed backtracking LLMs and https://arxiv.org/html/2410.02749v3 / https://github.com/upiterbarg/lintseq trained models on synthetic edit sequences. There is probably more out there with some digging. (Not the same topic, but the search also turned up https://arxiv.org/html/2504.20196 from this Monday(!) about automatic prompt improvement for an internal code-editing tool at Google.)

twotwotwo··on AI agents: Less capability, more reliability, please
FWIW, work has pushed use of Cursor and I quickly came around to a related conclusion: given a reliability vs. anything tradeoff, you more or less always have to prefer reliability. For example, even ignoring subtle head-scratcher type bugs, a faster model's output on average needs more revision before it basically works, and on average you end up spending more energy on that than you save by reducing time to first response. Up-front work that decreases the chance of trouble--detailing how you want something done, explicitly pulling into context specific libraries--also tends to be worth it on net, even if the agent might have gotten there by searching (or you could get it there through follow-up requests).

That's my experience working with a largeish mature codebase (all on non-prod code) where you can't get far if you can't use various internal libraries correctly. With standalone (or small greenfield) projects, where results can lean more on public info from pre-training and there's not as much project specific info to pull in, you might see different outcomes.

Maybe the tech and surrounding practice will change over time, but in my short experience it's mostly been about trying to just get to 'acceptable' for this kind of task.

twotwotwo··on Optimistic Locking in B-Trees
> in-memory and disk-backed, in-memory KV stores, which haven't really gone away even with the introduction of NVMe storage

If we're talking caches and Redis, one thought about why they haven't gone away--

In practice I think sharing is part of what keeps them network services, not only access to a cluster's RAM. As a dev you reach for something shared and 'shaped' like a cache, and the in-RAM aspect may be vestigial but still comes with the package.

We use Redis when e.g. tracking stats on active client IPs to see which are up to shenanigans, a maybe common use where you want cluster-wide stats. When caching, we may still want one DB query per expiry period app-wide, not one per webserver.

We would probably be fine 'caching' some stuff in the DB; Django's cache package has supported it for a while! I'm sure one of the disk-using successors of an in-RAM store could hit perf targets (DragonflyDB looks cool!). Just not a priority to change stuff that's working. (Corollary: I bet some folks unhappy with their Redis RAM needs are more than happy to try Dragonfly.)

twotwotwo··on Bzip3: A spiritual successor to BZip2
A random thought that Might Work, Who Knows(tm): first compress long-ish repetitions in the input and store the copies separately from the literals (like zstd). Then run just blocks of literals through the BWT before entropy coding.

The idea is that the BWT can help take advantage of however much context remains after the copies are snipped out, whether that's one byte or a few, and shrinking the input with the LZ-ish step may make it faster. It might be strictly worse than using PPM or basic context modeling like Brotli's; either of those can be "aware" of the preceding bytes even when they come from copies rather than literals.

It's implied in "successor to bzip2" and a lot of the comments, but it's worth highlighting that high-compression algorithms, especially those that are also slow to decompress, are a pretty specialized niche now. Using zstd or brotli at low to medium settings sometimes speeds things up by reducing network or storage transfers more than their CPU use slows you down. (Especially when your storage transfers are network transfers.) Even when compressing isn't a net speedup, you pay fairly little time for the saved space. Even lowish levels of zstd and brotli often eke out decent compression ratios for big inputs since, with modern quantities of RAM, their MBs-long history windows let them take advantage of long-range matches.

twotwotwo··on The Zombocom Problem
I remember, when I was just starting, the founder of the company saying that if you tell him you're offering an 'engine' that's mostly saying you don't have an app. Of course, some successfully sell 'engines', but I think there's a basic truth that you need users to make your business work and make what you're building better and battle-hardened, and to get those users you usually have to be providing just what someone's looking for, and that often means making an app.

Some 'frameworks' or 'engines' budded off from work on a concrete problem, e.g. Django first for a specific CMS, Rails from Basecamp, Unreal Engine from Unreal the game. Work's not as much of an 'engine' as those are, but it's definitely turned out a big focus is on how customers can build their own stuff (both in the frontend and the data side) and integration. But for anyone to care about all that it has to be an app first!

twotwotwo··on Why we use our own hardware
> I've been doing some planning over the last couple of years on teaching a course on how to do all this

Yes! It's surprisingly common to hear it can't work, or can't scale or run reliably, when all that is done. Talking about how you've done it is great from that perspective.

Also, it's worth talking about what you gain, qualitatively! As this post mentions, your high-performance storage options are far better outside the cloud. People often mention egress, too. The appealing idea to me is using your extra flexibility to deploy better stuff, not saving a bit of cost.

twotwotwo··on I Stayed
I don't like what Automattic's doing, but I don't think that means we have to throw out the whole idea of obligations that aren't legal obligations.
twotwotwo··on Compression efficiency with shared dictionaries in Chrome
It's interesting this is mentioned specifically about the metadata used by this feature: fingerprinting using this feature has similarities with other cache fingerprinting (wrote a sibling comment about that).

It's not actively bad to have defense-in-depth measures at the level of the dictionary feature. But if your implementation of dictionaries using your browser's existing cache policies is a privacy problem, I'd consider changing the cache, not just the shared-dictionary implementation.

twotwotwo··on Compression efficiency with shared dictionaries in Chrome
I think fingerprinting using this is mostly like the more direct ways to fingerprint with the cache, and the defenses against one are the defenses against the other.

For the cross-site thing, cache partitioning is the defense. If the cache of facebook.com/file is independent for a.com and b.com, Facebook can't link the visits.

An attacker using the hash of a cached resource as a pseudo-cookie could previously use the content of the resource as the pseudo-cookie. The Use-As-Dictionary wildcard allows cleverer implementations, but it seems like you can fingerprint for the same time period/in the same circumstances as before. In both cases you might do your tracking by ignoring how you're supposed to be using the feature; as you note, no one's stopping you.

Before and after the compression feature, it is true anti-tracking laws, etc. should address tracking with persistent storage in general not only cookies, much as they need to handle localStorage or other hiding places for data. Also true that for a browser to robustly defend against linking two visits to the same domain (or limit the possibility of tracking to a certain time period, session, origin, etc.), caching is one of the things it has to limit.

I think if they get the expiry, partitioning, etc. right (or wrong) for stopping cache fingerprinting, they also get it right (or wrong) for this.

I was admittedly a fan of the original SDCH that didn't take off, figuring that inter-resource redundancy is a thing. It's a neat spin on it to use the compression algo history windows instead of purpose-built diff tools, and use the existing cache of instead of a dictionary store to the side. Seems easier to implement on both ends compared to the previous try. I could see this being helpful for quickly kicking off page load, maybe especially for non-SPAs and imperfectly optimized sites that repeat a not-tiny header across loads.

twotwotwo··on AMD's Mild Hybrid Strategy: Ryzen Z1 in Asus's ROG Ally
Right, more bandwidth would really help mobile iGPUs, maybe more than it'd help many-core CPUs. I'm not sure if they want to sell super-beefy consumer iGPUs, or if AM5 is physically capable of having more channels. But it would be shiny, and seems like it's worked out in the large Apple SoCs.
twotwotwo··on AMD's Mild Hybrid Strategy: Ryzen Z1 in Asus's ROG Ally
Like the post says near the end, this seems like at least partly the result of AMD not being the size of Intel or Apple, so not being able to have the staffing to create, validate, etc. two radically different large and small designs. So instead they tweak the synthesis of one design to lower max freq in exchange for area. There's less perf downside to using these cores, but less area/power upside.

The perf impact of this or any hybrid design is also blunted by the power/cooling limits on non-hybrid designs: you can't afford to blast all the full-size cores on the chip at the max theoretical frequency at once anyway. Then, at the other end, lightly-threaded workloads can run mostly or only on the larger cores, so they're not heavily impacted either.

If there's a way this ends up fun for consumer folks that follow this stuff, it'd probably be by allowing products w/more cores. In server chips using Zen 4c (Bergamo), more cores is explicitly the focus. On their desktop platform, one CCD of full-sized cores and one of smaller cores would allow a 24C two-CCD package. That would add another "flavor" of CPU, the way X3D is another "flavor", but I suspect there are applications where the extra throughput could help. No particular hints that this is part of their plans, to be clear.

twotwotwo··on Multi-database support in DuckDB
Other replies are also right--this is in a family of analytics databases that are unusable for single-row transactions but great at reporting over large amounts of data.

The other tool with a similar focus on querying data where/how it is Trino. (Trino is the engine underlying Amazon Athena. Trino was initially released as Presto, which is now the less-active side of a fork; most of the project founders work on Trino.) ClickHouse, Redshift, and Snowflake are slightly different analytics tools more focused on querying data stored their own way.

Common themes across the whole family include storing each column of data separately, compressed in large (>=1MB) blocks, often using 'min-max' indices or other types of index that just allow skipping whole irrelevant blocks, not finding individual entries. Even data not in a columnar format is still compressed, minimally 'indexed' (maybe just partitioned by month), and more compact than it typically is in an OLTP DB.

Also, while something like MySQL wants a server to serve many concurrent transactions so would rather avoid a single query using lots of cores and RAM, these analytics DBs are happy to use lots of resources for a short burst.

Combining all the above, I've seen this family of database chew through reporting tasks in seconds that take minutes on a well-provisioned MySQL node.

Compared to the others, DuckDB lives in a host process you provide and does not itself do multi-node deployments. However, nodes get pretty big, and the columnar tricks pack data down tight, so (as much as in OLTP-land or, likely, more) you shouldn't underestimate what one node is capable of doing!

twotwotwo··on AMD Reveals Next-Gen Desktop Processors for Extreme PC Gaming
I do not really expect that, but it's possible to have higher-performance iGPUs than PCs have now; the bandwidth of two memory channels is a big constraint here. Apple's M3 Pro and Max appear to use 3 to 8(!) channels (and of course a lot of die area) to achieve good GPU performance.

More channels may not even be physically possible in AM5. And economically any big change to build a super-iGPU has to compete with just not taping a bigger APU out and letting folks who want lots of oomph go discrete.

The other thing that can maybe help is cache. AMD uses cache dies in their datacenter APUs (very unlike laptop APUs) and of course their dGPUs. Way back, Intel also made a product with eDRAM to boost effective memory bandwidth (Crystalwell). For an integrated chip, that could also act as an "L4" for the CPU and help with its bandwidth needs, though the impact there will be lower than for the GPU.

twotwotwo··on AMD Reveals Next-Gen Desktop Processors for Extreme PC Gaming
Oh, thank you! Looks like they did keep the DeskMini very much like the A300/X300, including keeping SATA.

Some other stories like https://videocardz.com/newz/asrock-announces-deskmeet-deskmi... suggest the DeskMini and DeskMeet can take a non-G 7000 CPU up to 65W; the 12-core 7900 would fit, though there's some substantial tradeoffs to doing that.

twotwotwo··on AMD Reveals Next-Gen Desktop Processors for Extreme PC Gaming
Not a great headline when the distinguishing feature of these chips is building a complete system without a dGPU. You can make an all-around solid computer with these, like the well-regarded new 13" Framework laptops but in a desktop, but they're not "extreme" or "gaming" devices the way buyers see those things.

Perhaps there just isn't enough of a market, but ASRock made a series of nice little machines they called DeskMinis with 5x5in motherboards that were a bit larger than NUCs, but in the extra space could fit a socketed 65W chip and quiet low-profile cooler (NUCs I've used were noisy under load), two full-length NVMe M.2 disks, and two 2.5" SATA drives.

An updated AM5 version could potentially ditch SATA to be smaller, since there isn't a huge premium on NVMe capacity now. I wonder if they could also handle some non-G chips, since those now have very basic iGPUs (though power and/or chipset requirements could still limit that).

One issue is that AM5 is still the relatively expensive option; AMD is still adding new AM4 5xxx SKUs because there's still seemingly a market for them. The DeskMini systems could be economical, and if a similar AM5 system couldn't be, due to the mobo itself needing to be pricy or the 8xxxG + DDR5 SODIMM cost, maybe it's hard to sell enough of them to get it to make sense. Still, it's a fun idea, and if you're listening, ASRock, I can promise you'd sell at least one.

twotwotwo··on Databases and why their complexity is now unnecessary
Yeah--as a user I've even seen apps where e.g. my own post immediately appears in the feed and thought "I see what you did there!"

Not as disagreement, but to help map the problem space out more, I think faking it is relatively easy for apps built around a few fundamental flows that are done a lot (like Mastodon) and trickiest when the app has many flows built to capture the many little wrinkles of some task/business/organization. If you're using an app to do the work of a school registrar or HR department or something you both probably expect your action to show up right when you hit Submit and also have lots of distinct actions you might do. It's then that it seems especially tricky to give users a reasonable-feeling view of things while building on an eventually-consistent foundation.

← PreviousPage 3 of 19Next →