MurphyA/hacker-news huggingface dataset:
by mikeyg | 2025-05-08 09:28:22+00:00
at least in the original implementation of this protocol (cjdns) there was already a tiny bit of proof of work happening in address generation. forgive me as this knowledge is over a decade old but it involved finding a curvecp private key that scalmults into a public key that (maybe whose hash?) begins with some specific number. this number is what's actually used as the ipv6 address. and that specific number is the routable ipv6 prefix.

the process would be run again and again during configuration generation until a key that fit this criteria was found. one could up the difficulty of this process considerably.. though not in a protocol backwards-compatible way.

you also needed to find a peer.

but yeah that's a gnarly hole.
by prmoustache | 2025-05-08 09:28:30+00:00
I think distraction and lack of experience is the main issue regardless of the vehicle.

Also there is a big difference I think with proper motorcyclists who actually get teached how to ride a bike, anticipate drivers behavior and act as if you were invisible at all time, with people riding <125cc motorcycles and moped with a car driving license who just don't take proper safety measures. I see so many 125cc riders overtaking on the right side, splitting lanes at excessive speed without anticipating a driver deciding to switch lanes, etc. Whenever I see a motorcycle rider down in an urban area it is usually on a 125cc or lower scooter.

Exception being the Yamaha T-Max users. They are supposed to have a motorcycle license but they all ride like complete retards with no exception. I think there is something in the nature of that bike, noise combined to instant throttle response and userfriendlyness of the clutchless/gear variator system that attract only the most stupid people of this planet. Yamaha should be ashamed of this.
by jeroenhd | 2025-05-08 09:28:52+00:00
There's an annoyingly persistent group of motorcycle enthusiasts that enjoys making as much noise as possible. They actively dislike electric motorcycles because they're not obnoxiously loud.

Then there are also the people that think they need to be loud to be noticed. That has been debunked, but that doesn't stop people from feeling a false sense of safety and sabotaging their vehicle's sound deadening regardless.

There are plenty of rules regarding the noise these things are allowed to make, but until law enforcement actually enforces those laws, nothing will change. That's with the unreasonably high legal noise limit.
by INTPenis | 2025-05-08 09:29:24+00:00
This is a good example of where AI will not take over.

Wikipedia rabbitholes do not follow any pattern. To truly create an AI that guides you through Wikipedia rabbithole you'd have to study thousands of humans going into actual rabbitholes, their clicks, and their reading patterns.

Otherwise it's just "let this AI take you on a journey you're not at all interested in".
by throwaway2037 | 2025-05-08 09:29:29+00:00
What about ID.me that irs.gov uses for tax-related matters? When I tried to get it once, it is pretty hard to get authenticated -- required 2+ gov't IDs, plus pic of yourself holding them. That should be pretty safe. Not good enough? (Overall: I agree. There is no concept of a national ID in the US, except a passport which huge numbers of people do not have.)
by austin-cheney | 2025-05-08 09:29:32+00:00
I always thought this was common knowledge. I guess it isn’t.

The only reason inheritance continues to be around is social convention. It’s how programmers are taught to program in school and there is an entire generation of people who cannot imagine programming without it.

Aside from common social practice inheritance is now largely a net negative that has long outlived its usefulness. Yes, I understand people will always argue that without their favorite abstraction everything will be a mess, but we shouldn’t let the most ignorant among us baselessly dictate our success criteria only to satisfy their own inability to exercise a tiny level of organizational capacity.
by pjc50 | 2025-05-08 09:29:46+00:00
> An API call, reading a file, calling less well-behaved libraries or making some system calls can all result in objects that pass compile-time checks but will cause a runtime exception or unexpected behavior.

Yeah, that is a design flaw that makes this kind of solution less useful than it might be. C# has this problem with "nullable": just because you've marked a type as not nullable doesn't mean some part of the program can't sneak a null in there. Haskell people wouldn't stand for that kind of nonsense.
by jajko | 2025-05-08 09:30:15+00:00
What about stepping back a bit and realizing that proper life success has almost nothing to do with school you go to? I am not saying not going to school per se, but this hard focus on career as soon as possible... where is focus on quality of life for example?

Optimizing hard for some rat race for some soulless (or soul crushing) office jobs among high functioning sociopaths that management inevitably always is. Most of those folks are not properly happy by any measure, thats not a win in life to end up there nor something to respect.

We are in rather unique period of time, especially folks here, that life fulfillment and happiness can be achieved for almost everybody and not just some top 0.1% if correct direction is taken. How about we realized that and focused more on actually long term important aspects of life?

(here is another guy who went the proverbial rags-to-modest-riches on my own but I would never had such mindset, when talking about successes of my life its about countries I've travelled, people I've met and intense experiences that shaped me more than career paths taken)
by badmintonbaseba | 2025-05-08 09:30:51+00:00
If you can generate a sequence of independent fair coin flips of indefinite length (this is a big if, but hold that though), then you can effectively generate a true real number uniformly from the unit interval. What you can't do is to access all of its digits all at once. But to correctly round it to a value representable in a given floating-point representation you don't need all the digits, you only need enough digits to decide whether the number falls into an interval where all reals round to the same value.

As for generating independent fair coin flips of indefinite length, none of the PRNGs qualify.
by majke | 2025-05-08 09:31:43+00:00
In this project I wrote quite some eBPF. I was constantly hitting verifier limits, and like everyone, I was initially just reordering variables and sprinkling "inline" or "noinline" everywhere. That wasn't sustainable.

It turns out - there is now some reasonable tooling to understand verifier!

For stack problems, clang accepts `-s` which prints stack requirement per function, like so:

** stack usage by function ** ebpf/ebpf_aes128.c:180 AES_ECB_encrypt 32 static ebpf/ebpf_sha256.c:34 sha256_calc_chunk 64 static ebpf/ebpf_sha256.c:123 sha256_hmac 40 static ebpf/ebpf_quic.c:86 compute_hp_mask 24 static ebpf/ebpf_quic.c:242 decrypt_quic 16 static ebpf/ebpf_quic.c:193 _do_decrypt_quic_loop 16 static

And for instruction count, I was able to feed the logs from verbose verifier (during loading) into code-coverage tooling, and count stuff up. The reuseorg prog takes 100k verifier instruction count/paths:

** verifier instruction count ** udpgrm_reuseport_prog processed 103486 insns udpgrm_setsockopt processed 9260 insns udpgrm_getsockopt processed 4215 insns udpgrm_bpf_bind6 processed 75 insns

While 100k is lower than 1m instr count limit, it's still a lot. And reordering some loop or introducing some "if" often makes that count baloon. Remember that verifier instructions is not real instructions during run. Rather it's a pessimistic interpretation of how many instr max under pessimistic conditions could possibly be run. I don't think having an actual run of that max is even practically possible. Think about it as upper bound of static analysis.

Anyway - with stack and instr statistics it's way easier to make sense of verifier problems.
by ManlyBread | 2025-05-08 09:33:14+00:00
I am playing in 1080p and so far 4060 Ti with 16 GB of VRAM seems like a good enough purchase. Very few games out there provide graphics good enough to warrant a higher priced card and 16GB means I should be fine running many of the generative AI models out there, even if it is a bit slow. I actually wanted to grab a 4070 but at the time I was buying the card there were no 16GB models available.

I would love to support AMD but I am not paying for a decade of total negligence of GPGPU.
by Closi | 2025-05-08 09:34:25+00:00
It depends what you count as learning - you told it something, and it then applied that new knowledge, and if you come back to that conversation in 10 years, it will still have that new knowledge and be able to use it.

Then when OpenAI does another training run it can also internalise that knowledge into the weights.

This is much like humans - we have short term memory (where it doesn't get into the internal model) and then things get baked into long term memory during sleep. AI's have context-level memory, and then that learning gets baked into the model during additional training.

Although whether or not it changed the weights IMO is not a prerequisite for whether something can learn something or not. I think we should be able to evaluate if something can learn by looking at it as a black-box, and we could make a black-box which would meet this definition if you spoke to a LLM and limited it to it's max context length each day, and then ran an overnight training run to incorporate learned knowledge into weights.
by prmoustache | 2025-05-08 09:34:26+00:00
My experience in south of Spain is that nobody invite people at home but the migrants. Spanish just like to meet outside.

But maybe that is a particularity of my area where houses / appartments are small, food is relatively inexpensive outside and weather is almost always good enough to go out.

Also preparing dinner doesn't mean you can't spend time with friends. As a French if I am invited to dinner and someone is cooking, I usually offer my help in the preparation. It is a nice occupation alongside a beer or a glass of wine and a great way to share an activity while having a chat with your host. Actually there are some other cultures where preparing the food is an integral part of the whole "spending time together thing". For example in latin america women would chat for hours preparing stuff in the kitchen while men would typically doing the same around the BBQ.
by sibellavia | 2025-05-08 09:34:26+00:00
that's correct. libp2p is designed as an agnostic library that could be used in projects similar to Mycoria. it offers the building blocks to build a p2p network. as a side-note, I've tried to use libp2p in the past, but ended up writing transports, NAT traversal, and fundamental structs for my p2p network from scratch, ditching libp2p.
by phiresky | 2025-05-08 09:34:36+00:00
TypeScript does supports all of these - `C implements I` is not necessary but gives compile errors if not fulfilled.

You can use `o satisfies T` wherever you want to ensure that any object/instance o implements T structurally.

To verify a type implements/extends another type from any third-party context (as your third point), you could use `(null! as T1) satisfies T2;`, though usually you'd find a more idiomatic way depending on the context.

Of course it's all type-level - if you are getting untrusted data you'll need a library for verification. And the immutable story in TS (readonly modifier) is not amazing.
by lucideer | 2025-05-08 09:36:33+00:00
> JS tooling has been a mess since its inception

Broadly, you're not wrong. But I see this sort of exceptionalism quite a lot: "<ecosystem> tooling is terrible". Terrible relative to what? I work with tooling across a wide range of languages - some do it better than others but I wouldn't say JS is exceptionally bad relative to others.

E.g. Python tooling has been some of the worst for a long time. Recently Astral have been making positive changes to this (& I note the cross-pollination of Astral & BiomeJS devs) but across the ecosystem things are broadly still terrible on average, especially in fragmentation terms. C/C++ has less of a fragmentation issue & more of a non-adoption-of-anything-standard-at-all issue (Make doesn't count when every Makefile is custom). Java tooling isn't too fragmented as long as you're an IDE user - but it's so locked into UIs & the cli tooling is horrific.

There's problems all over. JS is honestly one of the least worst I've seen.
by cma | 2025-05-08 09:37:09+00:00
I just read between the lines in the article that he must have gotten something like that since he said in the article that when he dropped out to be a poet he knew he would not have to attend college in two years.

Looking into it, I think they actually translate their version of it as GED too:

https://www.ice.go.kr/en/cm/cntnts/cntntsView.do?mi=10019&cn...
by josephg | 2025-05-08 09:37:54+00:00
I have a slightly different take:

I think every new technology or idea is created because it solves some problems, but in the long run, we'll discover that it creates other problems. For example, transpiling javascript, C++ OO, actors, coroutines, docker, microkernels, and so on.

When a new idea appears, we're much more aware of the benefits it brings. But we don't know the flaws yet. So we naively hope there are no flaws - and the new idea is universally good.

But its rare to change something and not have that cause problems. It just always takes awhile for the problems to really show up and spoil the party. I guess you could think of it as the hype cycle - first hype, then disillusionment, then steady state.

Sometimes I play this game with new technology. "In 10 years, people will be complaining about this on hackernews. What do I guess they'll be saying about it?". For rails, people complain about its deep magic. For rust, I think it'll be how hard it is to learn. For docker, that it increases the size of deployments for no reason. And that its basically static linking with more steps.

Calling everything a fad is too cynical for me, because it implies that progress is impossible. But plenty of tools have made my life as a software developer better. I prefer typescript over javascript. I prefer cargo over makefile / autotools / cmake / crying. Preemptive schedulers are better than your whole computer freezing. High level languages beat programming in assembly.

Its just hard to say for sure how history will look back on any particular piece of tech in 20 years time. Fortran lost to C, even though its better in some ways. I think C++ / Java style OO will die a slow death, in favour of data oriented design and interfaces / traits (Go / Rust style). I could be wrong, but thats my bet.

> I think it’s obvious that anyone passing around structs that contain data and functions that act on that data is the same concept as passing around objects.

I hear what you're saying - but there's some important differences about the philosophy of how we conceptualise our programs. OO encourages us to think of nouns that "do" some verb. Using structs and functions (like C and Rust) feels much more freeform to me. Yegge said it better: https://steve-yegge.blogspot.com/2006/03/execution-in-kingdo...

But lets see in 20 years. Maybe OO will be back, but I doubt it. I think if we can learn anything from the history of CS, its that functional programming had basically all the right ideas 40 years ago. Its just taking the rest of us decades to notice.
by patrakov | 2025-05-08 09:38:37+00:00
Contrary to the popular myth, Bitcoin is not fully decentralized. Those who write the code and convince others to run it have the absolute power. For example, they can enforce US sanctions by including the GeoIP database and making each node refuse transactions from IP addresses of the "wrong" countries, if they can convince others that this code is the code to run.

Likewise, they have successfully enforced a number of protocol changes and hard forks in the past.
by jeroenhd | 2025-05-08 09:38:41+00:00
You can install alternative app stores on iOS (within the EU). AltStore, Epic Games Store, and even a corporate-targeting store from Mobivention.

Apple is pulling some shit that will probably be declared illegal the moment it hits the courts with installation fees when distributing apps outside of Apple's ecosystem, but AFAIK Epic is taking care of that for AltStore and Mobivention probably factors it into its corporate pricing structure.

There's a lack of apps on these stores, though.
by ab5tract | 2025-05-08 09:39:35+00:00
The real major issue with multiple inheritance is that only a few languages (Eiffel, for one) seem to require declaring invariants for each class.

Then multiple inheritance is much cleaner because you can test constructor arguments against the union of these invariants before even hitting a constructor.

Note that I’ve never used it, but it did strike me that this was “the” way to include multiple inheritance in a language. But for some reason (run time performance maybe?) no one else seems to have done it this way.
by Klaster_1 | 2025-05-08 09:40:12+00:00
> An API call, reading a file, calling less well-behaved libraries or making some system calls can all result in objects that pass compile-time checks but will cause a runtime exception or unexpected behavior.

These all boil down to implicit `as` type casting parsed boundary data into expected types. What you suggest is replacing casts with to type narrowing guards, libraries like Zod help with some of that. I think TS needs a special flag where `JSON.parse` and alike default to `unknown` and force you to type guard in runtime.
by lazide | 2025-05-08 09:40:30+00:00
Also slower reaction times (and less testicular fortitude!) in someone older, along with the lack of practice.

There are some situations you can get yourself out of (and many more you can get into!) as a 20 something that will just outright result in death when you’re older.

Source: rode a 1400cc bike for almost a decade, awhile ago. Never went above 140mph on it though.
by 9dev | 2025-05-08 09:40:45+00:00
Python code feels like back in the day when JavaScript was typed using JSDoc comments, and libraries would use all kinds of fantastical object shapes for their option parameters, so users could pass "just about anything" and it would work. You would never know how to configure an Express app without digging through the documentation, for example.

I loathe the Python convention of just using kwargs instead of clearly annotated parameters; most libraries don't even have doc comments in the code, so you're really required to look up the documentation, hope that it actually describes the method you're interested in and contains more than stuff like "foo: the foo to use"—or fall back to rummaging in the library intestines to figure out how it works.

It's pathetic.
by vlovich123 | 2025-05-08 09:40:57+00:00
Even if you call a pure virtual function of an abstract base class, the compiler can devirtualize if it can determine the type anyway due to data flow analysis. There are limitations but with LTO you’d be surprised at how effective the compiler is here. Also in Rust you’re never going through the vtable unless it’s a &dyn Trait and the compiler fails to devirtualize.
by mschuster91 | 2025-05-08 09:41:09+00:00
> "Identity theft" is a term coined by banks to try to make it sound like random people should have to deal with the fallout of the banks' bad identity verification practices.

The problem isn't the banks, the problem is that unlike Europe where in most countries it's commonplace for everyone to have a government-issued ID document, the US does not have that requirement and so companies of all sorts abuse documents not meant for that purpose like SSNs or driver licenses that can be trivially forged.

Banks can't invent security out of thin air when a significant part of the US population believes that mandating possession of one is a surefire way into a dictatorship or whatnot.
by divan | 2025-05-08 09:42:24+00:00
Convention-wise Go is even better. On the one hand, there is zero magic in error handling ("Errors are values" and interface type 'error' is nothing special), on the other hand it's kind of a convention (slightly enforced by linters) that functions that return errors use this type and it's the last return parameter.

Nothing prevents people from doing their own way (error int codes, bool handling, Result types, etc, panic), but it's just an easiest way that handles well 99% of the error handling cases, so it sticks and gives a nice feeling of predictability of error handling patterns in Go codebases.
by hiq | 2025-05-08 09:43:13+00:00
> The problem is swift network/correspondent/intermediary banking. When you want to send money abroad to badly connected banks of badly connected countries, you might have a big route chain (multiple times intermediaries), fees can be huge , and settlement can take a long time.

But why is this complicated? Isn't it mostly about regulations / KYC / AML, rather than anything technical?

Stablecoins are much simpler because they don't do anything with respect to regulations, they're just a dumb ledger. For those who don't want to bypass regulations and the legal system, stablecoins bring as much as yet another database / ledger, which are not the problem in the first place.
by wvh | 2025-05-08 09:43:35+00:00
I'm a trail runner. When I look at the ultra runner community, there definitely is a sense that some people have gamified their ancient brains and mastered the skill of short-term inconvenience to obtain long-term success, and it translates to many areas of life. I don't think it's unlikely that somebody is successful in multiple areas; surely you need some natural ability to reach the top in any specific discipline, but if you learn to apply yourself and persist, clearly that can help you in many areas, regardless of innate talent.

My point being that maybe it's not unique sleeper inborn talent, but just learning grit, persistence and well, not being stupid, that will lead to success in life. If one thing doesn't hit, try another. So maybe you don't become a poet, but a math genius, or a soccer player, or a dancer; something else than a TV consumer.
by em500 | 2025-05-08 09:44:14+00:00
AFAIK using the analytic solution for linear regression (via lm in R, statsmodels in python or any other classical statistical package) is still the norm in traditional disciplines such as social (economics, psychology, sociology) and physical (bio/chemistry) sciences.

I think that as a field, Machine Learning is the exception rather than the norm, where people people start off or proceed rapidly to non-linear models, huge datasets and (stochastic) gradient based solvers.

Gaussianity of errors is more of a post-hoc justification (which is often not even tested) for fitting with OLS.
by vasco | 2025-05-08 09:44:50+00:00
Choosing berries (ie not progressing to "protect jobs" - no jobs are protected, we have close to full employment worldwide) is choosing avoidable deaths. Child mortality rate in a "choose berries" world is just one example that makes me triggered by those that have that position.

And you get nothing in return for protecting those jobs, as I said, the world is "employed" and we've killed many industries already over the centuries. You're protecting nothing.