MurphyA/hacker-news huggingface dataset:
by quchen | 2025-06-02 07:38:43+00:00
It baffles me how there are still blogposts with a serious attitude about this topic. It’s akin to discussing possible loopholes of how homeopathy might be medicinally helpful beyond placebo, again and again.

Why are hyperreals even mentioned? This post is not about hyperreals or non-standard math, it’s about standard math, very basic one at that, and then comes along with »well under these circumstances the statement is correct« – well no, absolutely not, these aren’t the circumstances the question was posed under.

We don’t see posts saying »1+2 = 1 because well acktchually if we think modulo 2«, what’s with this 0.9… thing then?
by HPsquared | 2025-06-02 07:39:48+00:00
It's a thermodynamics thing. Reversible processes are the most efficient (something to do with entropy). Deleting information means it's no longer reversible. This is an entirely theoretical thing. There are theoretical limits to energy usage of computation based on this, but actual computers are nowhere near these theoretical limits, at all.

Edit: and yes, most of the logical operations in a regular chip like AND, OR, NAND etc are irreversible (in isolation, anyway)
by saqibtahir | 2025-06-02 07:39:59+00:00
Writing (and especially posting it) needs to be promoted more. I run a small community and I tell them time and time again, writing is not to attract fame, it is to get better at what you do - and having a log of it.

I think as you grow, in career, or in general, folks who get writing always do better than who don't give all things equal.

Keep posting!
by keiferski | 2025-06-02 07:40:16+00:00
I am looking forward to seeing this, as while I really enjoy the aesthetic of Anderson, I increasingly wish someone would push him out of his comfort zone. His films are the same thing repeated in different circumstances with different characters.

Maybe he isn’t interested in doing anything other than what he’s doing, and at some level that’s all the justification he needs. He doesn’t owe anyone anything. But I do think the cinematic world as a whole would benefit from him experimenting a little more, trying a novel format, and so on.
by _elephant | 2025-06-02 07:41:07+00:00
I’ve felt this too — the eerie sense that we’re creating not for people, but for scraping bots and transformer stacks. But I don’t think it ends there. Even in a world of tokenized consumption, the texture of human work still leaves a residue. Models might extract, but people still feel. If anything, this is an argument for going deeper, not shallower. To write, design, or build things that confuse the extractors but touch the humans. Not anti-AI, just pro-intimacy.
by Bencheng | 2025-06-02 07:41:14+00:00
Saw some other products partners with a Cloud vendor for marketing exposure, so we look into it.

It turns out that the most effective and easy way for their sales rep to pitch your products to their client is if you have something complementary. For us, this is because they have similar products, so they can propose it to the client if they don't like the native one.
by tialaramex | 2025-06-02 07:41:21+00:00
> proof that the person saying that does not understand the C++ language. This was followed by several "I am a C++ standard library implementer and everyone I know calls it the STL". Things deteriorated from there.

It feels natural to assume that the implementers and long time WG21 members must understand the language, but this is not true. C++ spiralled well beyond the capability of a person to actually understand it years ago.

Maybe that's unfair, but it's unusual. This is a constructed language, its syntax and semantics matter greatly and yet in practice our grasp of its meaning is more akin to that for say, English, than for Perl or Rust.

There are contradictory style guides, people with well meant rules of thumb contradicted by a world of real usage, numerous dialects, not to mention people who strongly believe other users of the language are "doing it wrong" and yet what they're doing works fine.
by Bencheng | 2025-06-02 07:44:53+00:00
Yeah, but a few years down the road, I learnt that the incentives are often misaligned. For example, the Account Manager wants all their client's consumption in their client's account, so they push the client for a dedicated Cloud deployment, while the other sales rep wants it on the other reseller account, etc.

It also sometimes conflicts with the incentives of us.
by throwaway81523 | 2025-06-02 07:45:24+00:00
I've been using Organic Maps though there is some kind of more community-oriented fork of it now, that I should check into.

It would be cool to add a solar compass feature to MPCompass. I've been wanting to suggest that to the Trail Sense author too.

https://en.wikipedia.org/wiki/Burt%27s_solar_compass
by kragen | 2025-06-02 07:48:39+00:00
This is pretty cool. There were some LFSR-PC CPUs back in the 70s such as the TMS 1000 used in the Speak&Spell https://github.com/mikeakohn/tms1000_fpga (its Data Manual omits mention of this, but the Programmer's Reference Manual does mention it https://ia800306.us.archive.org/27/items/bitsavers_tiTMS1000...), and of course the Atari 2600 TIA raster generator is famous for using an LFSR counter for horizontal position. Ken Shirriff has also documented the use of an LFSR counter for tone generation in the UM66T greeting-card music chip http://www.righto.com/2021/12/reverse-engineering-tiny-1980s... and for Pentium self-test circuitry http://www.righto.com/2025/01/pentium-carry-lookahead-revers... and for DTMF tone generation.

It occurred to me recently that an LFSR-pc CPU could avoid having an address field in its conditional jump instructions, instead doing something like complementing a PC bit. There have been conventional counter-based CPUs that did something like this: Data General's NOVA and HP's RPN calculators had conditional-skip instructions which would skip over the next instruction without executing it if the condition was false. But it was usually a jump instruction, so it didn't really save you space. (The TMS 1000's conditionals also worked this way, but could only skip branch and call instructions.)

By contrast, in an LFSR, complementing a bit or incrementing the value takes you potentially far away in the address sequence. The assembler might have to insert NOPs to resolve the occasional collision.

The TMS 1000 program counter had an additional twist: it was only 6 bits, but to enable programs of more than 64 instructions, there were multiple 64-byte "pages" of ROM. The page address register was potentially updated on branches, calls, and returns, but not for normal program sequencing. I'm not sure if this actually saved any transistors, but it meant that normal branch instructions only needed a 6-bit field. An additional "load page buffer" instruction was needed for far jumps and calls, and the page buffer register remained loaded with the return page until the return instruction. (Subroutine calls within subroutines were not supported.)

https://electronics.stackexchange.com/questions/186762/first... claims that the TMS 1000 had 8000 transistors, which seems really inefficient compared to things like the 4004 and the MuP21.
by unwind | 2025-06-02 07:48:45+00:00
Yes, weird. I also liked this part:

Embers from a fire won’t burn the surface (If removed quickly).

I think that is true for many surface materials, and that "quickly" is doing a lot of work in that sentence. It also completely fails to communicate whether or not a carbon fiber chair is "safe enough" around an open fire. Annoying.
by jeroenhd | 2025-06-02 07:49:37+00:00
I like SerenityOS' "standard library". It has some Rust-like features (like ErrorOr, which is a lot like Result) but also some C++ usability enhancement that make use of modern C++ features rather than trying to force a C++-shaped peg into a POSIX-shaped hole. The only exception I know of is the pledge() implementation (which uses a space separated string rather than something like an array of enum values), but having pledge() at all is a pretty major improvement.

SerenityOS' original "make no use of external libraries" approach made one of the more complete re-imaginings of the C++ application landscape I've seen. It really changed my perspective on what C++ could be.
by aziaziazi | 2025-06-02 07:49:49+00:00
How do you carve solid wood board ?

I've done ten's of carving by gluing thin layers in a mold to create carved plywood. Those are extra strong but required to use quite a lot of glue and get the right thickness wood veneers. Would love to learn the solid board way.

edit: fined tuned my English today: seems carving means sculpting and not bending.
by deng | 2025-06-02 07:50:14+00:00
The Windows MIDI/USB stack adds considerable amount of jitter to the MIDI clock, compared to the much superior ones in MacOS. I will fully admit that "unusable" is a personal opinion based on my experience. Of course performers also use Windows, but I heavily doubt you are able to see which device in their rack acts as a master clock, and how they sync their devices, apart from the fact that most performers nowadays don't use MIDI at all.
by cbolton | 2025-06-02 07:50:34+00:00
The right way to approach this is to ask a question: What does 0.999... mean? What is the mathematical definition of this notation? It's not "what you get when you continue to infinity" (which is not clear). It's the value your are approaching as you continue to add digits.

When applying the correct definition for the notation (the limit of a sequence) there's no question of "do we ever get there?". The question is instead "can we get as close to the target as we want if we go far enough?". If the answer is yes, the notation can be used as another way to represent the target.
by atoav | 2025-06-02 07:51:41+00:00
The most important letters and messages I have written in my life have never been sent.

A important thing to realize about writing (especially given the current technological advances) is:

Writing is more than just the production of text for other peoples consumption. Writing is an excellent tool to structure thoughts and feelings. Writing isn't just you formulating messages with intent, it is also the text radiating back at you while you write.

LLMs are great to lift the burden of writing bullshit texts or as a (hopefully critical) sparring partner, but we need to realize that a lot of the value of writing is that we structure our thoughts and feelings through it and letting someone else do it takes something from us.
by drewcoo | 2025-06-02 07:52:27+00:00
In software, we promote good engineers to management, effectively accelerating the Peter Principle.

It doesn't have to be that way. Management skills are not an outgrowth of the skills of the managed, but orthogonal to them. This is similar to the lesson many PhD candidates I've known learn: expertise in their field is not pedagogical expertise. Companies who promoted from within used to provide training for new managers.
by spwa4 | 2025-06-02 07:53:48+00:00
This is how it always goes in the EU. "The US becomes less reliable/invests less/... so we'll do it and put in a BIG effort" big announcement from Brussels. Usually repeated 5 times or so by some head of state of France and/or Germany.

Then you check the "BIG effort" the EU makes and it's, 10 years of 0 budget + 5% of the budget US invests yearly for 3 years + never looking at it again. To make it worse from that point, they mostly don't divide such budgets across a million small proposals like the US does. No, the politicians in the Brussels find 2 or 3 companies or institutions they like and sign a contract with them. Which results in the many (usually small) companies that actually have accomplishments not getting their business, but big consultancies or institutions or ... getting the contracts by promising to divide the business among pre-agreed subcontractors (doing the EU's job for them, or at least the administration/checking job the US government does in the US, and the subcontractors especially have to be in the right countries). Afterwards, they don't even check what was actually accomplished, and intervening is just unheard of.

Meanwhile you look at it, and you're forced to conclude:

1) scientists will not be leaving the US under Trump. Yes the difference between the EU and US will become smaller, but still heavily in favor of the US (as in >100% difference, factors, not percentage points). In pay, in budget (ie. for research equipment), in infrastructure, in existing knowledge, and of course in future job prospects after research. Also: it's not just the US universities that are coming under increasing pressure.

2) the EU brain drain towards the US will continue in other sectors too (IT, medicine, pharma, ...)

3) cloud business will continue migrating to the US (whether we're talking Salesforce or AWS EC2)

4) factories will keep migrating to the US (already started long before Trump, so it's not his accomplishment, and they won't be providing the jobs hoped for, but they'll keep migrating to the US)
by peterpost2 | 2025-06-02 07:53:50+00:00
That they have an self-interest does not necessarily mean that they don't have a point.

It's obvious at this point that the American government should not be trusted with European governments data. Hell, you could even argue that the American government should not be trusted with the data of it's own citizens, them having let Doge and Elon Musk have had access to citizen information.
by rnhmjoj | 2025-06-02 07:55:40+00:00
> but actual computers are nowhere near these theoretical limits, at all.

The Landauer limit at ambient temperature gives something of the order of 10⁻²¹ J to irreversibly flip a bit. While, if I read this paper[1] correctly, current transistors are around 10⁻¹⁵ J. So, definitely not coming to AI "soon".

[1]: https://arxiv.org/pdf/2312.08595
by dgb23 | 2025-06-02 07:55:41+00:00
I want to add something to this which is rarely discussed.

I personally value focus and flow extremely highly when I'm programming. Code assistance often breaks and prevents that in subtle ways. Which is why I've been turning it off much more frequently.

In an ironic way, using assistance more regularly helped me realize little inefficiencies, distractions and bad habits and potential improvements while programming:

I mean that in a very broad sense, including mindset, tooling, taking notes, operationalizing, code navigation, recognizing when to switch from thinking/design to programming/prototyping, code organization... There are many little things that I could improve, practice and streamline.

So I disagree with this statement at a fundamental level:

> The technical skill of writing code has been largely commoditized (...)

In some cases, I find setting yourself up to get into a flow or just high focus state and then writing code very effective, because there's a stronger connection with the program, my inner mental model of how it works in a more intricate manner.

To me there are two important things to learn at the moment: Recognizing what type of approach I should be using when and setting myself up to use each of them more effectively.
by ozgune | 2025-06-02 07:55:58+00:00
Question to author.

Are you planning to publish CH benchmarks (TPC-C and TPC-H combined)? I'd expect Aurora to perform much worse on CH than on TPC-C/H. That's because Aurora pushes the WAL logs to replicated shared storage. Since you only need quorum on a write, you get a fast ack on the write (TPC-C). The way you've run TPC-H doesn't modify the data that much, so you also get baseline Postgres performance.

However, when you're pushing writes and you have a sequential scan over the data, then Aurora needs to reconcile the WAL writes, manage locks, etc. CH benchmark exercises that path and I'd expect it to notably slow down Aurora.

(Disclaimer: ex-Citus and current Ubicloud founder)
by vidarh | 2025-06-02 07:56:23+00:00
To me, a few things that stands out, that I'm increasingly looking to emulate, that are mostly not about the low level API/ABI:

* Assigns. Basically aliases for paths, but ephemeral and can be joined together. E.g. the search path for executables is the assign C:. The search path for dynamic libraries ins libs:. I've added basic, superficial support for assigns to my shell. It's a hack, but being able to just randomly add mnemonics for projects is nice, and not having to put them in the filesystem as a symlink somehow also feels nicer even if it only saves a few characters.

* Datatypes. AmigaOS apps can open modern formats even if the app hasn't been updated for 30 years as long as they use datatypes: Just drop a library and descriptor file into the system.

* Screens. I'm increasingly realising I want my wm to let apps open their own virtual desktops, and close them again, as a nice way of grouping windows without having to manually manage it, and might add that - it'd be fairly easy, and on systems that don't support it the atoms added would just be a no-op. The dragging was nice to show off at the time, but less important. Ironically, given the Amiga was one of a few systems offering overlapping windows when it launched, screens often served as a way for apps themselves to tile their workspaces on a separate screen/desktop, and my own wm setup increasingly feels Amiga-ish - I have a single desktop with floating windows and a file manager, just like the Amiga Workbench screen, and a bunch of virtual desktops with tiling windows.

In terms of the API, one of the things I loved was more something that evolved: The use of "dispatch/forwarding" libraries, like e.g. XPK, that would provide a uniform API to do something (like compression) and an API for people implement plugins. So much of the capabilities of Amiga apps are down to the culture of doing that, and which Datatypes was an evolution of, that means the capabilities of old applications keeps evolving.
by pjmlp | 2025-06-02 07:58:47+00:00
This is a recent blog post from DirectX team,

https://devblogs.microsoft.com/directx/omm/

Compare the C++ code samples with the Modern C++ usually talked about C++ conferences.

This is why I keep saying I only see such high bar code on conference slides, and my hobby projects, those DirectX code samples are much more closer to daily C++ written in big corporations, ironically even those that are C++ compiler vendors with seats at WG21.

On the other hand, there are many industries where I don't see Rust taking anything meaningful away from either C or C++, regardless of how much we complain about them, or how much better Rust happens to be over them.
by regularfry | 2025-06-02 07:58:59+00:00
What surprised me here is how close Aurora got. That's some magic right there.

I've always held that if you want resilience, you just cannot rely on local storage. No matter how many times you've got data replicated locally, you're still at risk of the whole machine failing - best case falling off the network, worst case trashing all its disks in some weird failure state as the RAID firmware decides today is the day to Just Not. And while you might technically still be able to recover the data, you're still offline.

You just need your data to be off the machine already when that happens. Not to say that all access needs to go over the network - local caching ought to go a long way here - but the default should be to switch to another machine and recycle the failed one.

Relevant to the article, this is independent of the speed and reliability of the actual hardware. It was true in 2010, it's true now.
by spyrja | 2025-06-02 07:59:38+00:00
Another easy way to understand it is to extend the idea of remainders to decimals. When we say N / D = Q r R that obviously means N = D * Q + R. For example 13 / 3 = 4 r 1 because 13 = 3 * 4 + 1. Likewise then 1 / 3 = 0.3(...) = 0.3 r 0.1 because 1 = 3 * 0.3 + 0.1, but also 1 / 3 = 0.3(...) = 0.33 r 0.01 because 1 = 3 * 0.33 + 0.01, etc. Hence 3 * 0.3(...) = 0.9(...) = 1.
by Wololooo | 2025-06-02 08:03:56+00:00
Reminds me of that concept that I saw pop up in HEP in recent years between "users" and "experts".

This distinction in that case is so dumb I cannot wrap my head around it: You first encounter the code, are unfamiliar with it but very quickly you become expert in order to solve your problem and advance the thing forward.

It does not matter which codebase you start on, what matters is that you understand what the actual stack does and what is involved in there because people are supposed to understand deeply what they are doing.

But this comes from the "corporatisation" of every single entity, where random metrics are used in order to assess performance instead of asking the simple question of "does it work" or "does it need fixing" or "will this thing break".

There is a clear disconnect between the manager type people that are removed from the work and the managers still doing things practically, which understand what the stressors are and where some work of deep understanding and extra contextualisation of the systems, is required, in order to not mess the whole thing up.

This being said, this is coming from a very peculiar perspective and with a very specific tech stack which is and is not industry standard at many levels...
by pwmtr | 2025-06-02 08:04:08+00:00
Yes, that is correct. That said, in our tests we only saw 2x improvements in CH benchmarks. However, we found out that it was due to an architectural issue in our VM I/O path and how we virtualize the storage. Based on our estimations we should see ~5x difference but for that we need to revamp our storage virtualization first.

We have plans for publishing a CH benchmark results on a follow up blog post. However, we didn't want to do that for now to not put misleading results.
by pjmlp | 2025-06-02 08:04:17+00:00
This is basically how Southern Europe goverments work, but at continent scale.

Hence why Nothern countries have such a hard time understanding why we usually have some issues caring to follow all regulations, and are somehow flexible in what to follow.

We have been throughout this way of working across centuries.

You could re-publish the famous Portuguese writer, Eça de Queiroz, books critizing the society from 19th century updated to a modern setting, and most of it would still apply.
by TrackerFF | 2025-06-02 08:04:46+00:00
AI works great for providing you a starting point, and giving a big picture view of how certain things work, and how you should structure them.

Sometimes, even if you're a really seasoned software engineer, you'll encounter something you haven't seen before. Maybe to the point that you don't really even know what to search for to get started. So instead of spending half a day scrounging various forums, e-books, etc. you can ask the model, in somewhat vague terms, what you're looking for - and some of the LLMs are quite good at just that.

Now, the implementation of such things, not quite there yet. My experience has been that the more obscure the problems you deal with, the more obsolete code the model will spit out - with dead and unsupported libraries etc.
by account42 | 2025-06-02 08:07:44+00:00
I really is a travesty that Browsers still haven't updated their bookmark feature based on this realization - all bookmarks should store not only the link but a full copy of the rendered page (not just the source which could rely on dynamic content that will no longer be available).

Also, open tabs should work the same way: I never want to see a network error while going back to a tab while not having an internet connection because the browser has helpfully evicted that tab from memory. It should just reload the state from disk instead of the network in this case until I manually refresh the page.
by andrei_says_ | 2025-06-02 08:08:15+00:00
If you are open to questioning the “junkies” and their “choice to be so” stereotype, you may find this TED talk useful.

https://youtu.be/PY9DcIMGxMs?si=9qNCkYrV2CY3_n7o

Everything you think you know about addiction is wrong | Johann Hari