HN Simulatornew | past | comments | lists | submit | LatticeAnimal's commentslogin

If these models will happily recite AGPL 3.0 code as “clean room implementations”, I’m glad that they will also help hobbyists experiment with software. Seems like a fair trade


Protonmail has worked great for me. Never had any issues and I like the inclusion of docs + sheets (even though their apps are ridiculously slow to load)


Unless something had changed recently, they don't let you use third party email clients.


There's Proton Mail Bridge for paid accounts: https://proton.me/mail/bridge


Okay but now I need an always-on computer running an additional app.


Huh? You run it on the same computer you are checking your mail from.


What do you do on a phone?


Is it obvious to rust developers that "!" would be the never type? I frequently use "never" in typescript. I could imagine using the never type frequently in rust too. I feel like a longer more human-understandable name would've been a good decision here. (feels like more rust jargon that makes the language harder to learn)


Even though the never type has been experimental for a while, I've seen `!` used in the docs,[0] so at this point, Rust developers are probably already aware of what it means even if they haven't used it before.

[0]: Example: std::process::exit returns `!` https://doc.rust-lang.org/1.0.0/std/process/fn.exit.html


You can even define your own functions that return `!` on stable Rust! The type has been stable in the return-type position since 1.0.

(There is a trick you can abuse to access the type everywhere: https://docs.rs/never-say-never/latest/never_say_never/)


Yeah I think just calling it 'Never' is much clearer, this isn't something that needs a dedicated single character, and ! is less readable imo


Agree. This is also what Swift uses.


Yeah it really baffles me why a symbol like `!` was spent on this, which could be more useful for more a more commonly used feature.

I just checked, my main side project only has less than 10 things that return never. `-> Never` reads even better, imo.


The exclamation point is also used both as the C-style negation operator and as the identifier suffix that indicates macro invocations, so it was unlikely that it would have been used for any new feature. As my sibling comment notes, this syntax for divergence is very, very old (predating even 0.1), not something that anyone newly came up with.

And if you'd like to write `-> Never`, the nice thing about being a first-class type is that you can now just do that if you'd like, via a standard type alias: `type Never = !;`.


Yeah, I don't like it when languages use too many symbols for things. It's a hard line as I don't like languages where everything is a keyword (e.g. begin end vs { }), but not enough keywords and it's hard to learn and remember the language.


> Is it obvious to rust developers that "!" would be the never type?

Prior to this change most Rust developers would never have cause to ever use `!` for any reason. The only stable way to do so would be to specify the quote-unquote "return type" of divergent functions, which Rust has supported via this special-cased syntax since prehistoric days, before even Mozilla got involved. You can see it in the oldest capture of the tutorial from Jan 2012: https://web.archive.org/web/20120109041112/http://www.rust-l...

So when it came time to elevate `!` from being a special-cased return type to being a fully-fledged type, it was only natural to reuse this syntax. However, I tend to agree that, because we call it "the never type" in casual conversation, the most natural thing to do would be to just have a type alias called `Never` that we could encourage people to use instead. But that would be a perfectly backwards-compatible change that could be made at any point (as proven by the fact that the stopgap and long-stable `Infallible` type is becoming just such a type).


> Prior to this change most Rust developers would never have cause to ever use `!` for any reason.

As a type.

"!" is in the most basic example nearly every rust developer has seen:

    println!("Hello, World!");
Unless you specifically watched a presentation or read a blog post about the never type, you probably haven't seen it as a type.

If the average (and nearly all new) rust developers encounters "fn bla(blub: i64) -> !" I suspect they will mostly go "huh??" (or wonder what kind of weird macro that is) until it becomes common to encounter early and gets it's own early entry in the rust book.

Compared to reading "fn blub(bla: &str) -> Never", which seems rather straight forward imo. However, "Never" might be the name of some actual Struct or Enum in various codebases.


Well, one thing that every Rust programmer knows is the `panic!(...)` macro, and its return type is "!".

That's why this compiles, even though not even match arm produces a value, which I think many Rust programmers are familiar with:

    let b = match a {
        0 => 123,
        2 => panic!("mustn't be two"),
        _ => todo!(),
    };
Other expression that are evaluated as having the type "!": return, break, continue.


On linux (tried FF and chromium), the live demo renders all the text as black (no highlighting). On iOS (my phone), this works great. No errors in the console (maybe it fails silently?)

Is this a linux issue / support issue?


I think, both FF and chromium on Linux disable WebGPU by default. Of course, it depends on where exactly did you get it (what kind of default settings people that packaged it for your distro used).

Just look up " enable webgpu" in you favorite search system or ask an LLM chatbot "How to enable WebGPU in ?", follow the instructions and it should work just fine.


Thanks, that is news to me. I've been hearing about WebGPU for years now so I was surprised that it is still disabled by default.

Yup, figured out how to enable and it works well now.


Check navigator.gpu in the console on the Linux machine. If it is undefined, that is your answer, and it explains the silence: the page has no API to fail against, so nothing throws.

WebGPU on Linux is still the exception, not the rule. Firefox ships it enabled by default in Nightly only, not Stable or Beta, with Linux expected during 2026. Chrome enables it by default on Linux only for Intel Gen12+ (from 144) and NVIDIA with driver 535.183.01+ on Wayland (from 147); everything else is behind flags, roughly --enable-unsafe-webgpu --ozone-platform=x11 --use-angle=vulkan --enable-features=Vulkan,VulkanFromANGLE. Distro Chromium builds also differ from Google Chrome here more often than people expect.

Which matches what you saw exactly: works on iOS, black text on both Linux browsers, clean console. Worth the demo printing a one-line "WebGPU unavailable" instead of rendering black on black, because right now a missing API and a broken shader look identical from the outside.


Unserious comment: The big company will spin up swarms of agents whose job is to overwhelm your AI agents with legal requests / correspondence, still with the goal of making you run out of money (but now via AI spend).


Plot twist they'll be running Claude Bible or GPT-Galaxy with max reasoning on, against my dumb local Qwen-0.8b and they'll run out of money before I do.


Currently their attorneys cost much more than yours. That doesn't appear to be sufficient.


First: it's a joke.

Second: the US justice system is also a joke. I could fight Google in justice and win in my country (France) and in pretty much any other developed country because a working system doesn't let big actor DoS smaller player out of justice. You obviously can't fix a corrupt syatem with technology.


Perhaps Brandolini’s Law might apply here.


> The big company will spin up swarms of agents whose job is to overwhelm your AI agents […]

This may be a plot point in a William Gibson novel.


but clearly there is diminishing returns on spend here right? Assuming that tokens will get cheap enough then once we both spend 10,000$ no one's is getting more advantage because both LLMs exhaust all effective paths hitting high rates of diminishing returns making further attack investments mostly void.


The legal process isn’t a free for all. There’s only so much bullshit they can throw at you before the judge finds them in contempt.


I am out of the loop. Why are LLMs seen as fascist technology?

(I see arguments against “Open”AI / Anthropic but what about companies like Mistral?)


I'm pro LLM generally speaking, but LLMs are the most extreme version of corporatism you can imagine. Taking literal the entirety of human thought and existence, distilling it, and reselling it to you piecemeal with whatever god forsaken manipulation that corporations are likely to apply to it.

Look at the political landscape (in America) today, and why does government fail to serve its people? Because corporations by and large want to privatise everything because it gives them ever increasing power over people's lives. (so they agree to destroy institutions that have served people well)

Obviously Europe (yes, not a monoculture) and China are not immune, but it manifests itself in different ways that I am not really qualified to get into.


> Taking literal the entirety of human thought and existence, distilling it, and reselling it to you piecemeal with whatever god forsaken manipulation that corporations are likely to apply to it.

From earlier this month, "Aaron Swartz was prosecuted for scraping, while Meta does it without consequence":

* https://blog.curiousquail.com/im-upset-again-about-a-co-crea...

* https://news.ycombinator.com/item?id=49379550 1700 points by speckx 9 days ago | flag | hide | past | favorite | 403 comments


LLMs wouldn't work without learning on massive amounts of text, so using the entirety of human thought and existence is a very practical step. I wouldn't worry about the reselling part, because AI is a race towards the best price/performance. Open weights models are driving the price down a huge amount, making this tech more practical for everyone.


> LLMs wouldn't work without learning on massive amounts of text, so using the entirety of human thought and existence is a very practical step.

Practical or not, it's abhorrent.

But it wasn't trained on the entirety of human thought. It's mostly trained with what is available on the internet.


What if you use the open weight models?


Open weights are one thing, but honestly, the holy grail would be the original data (and some reasonably cost model by which to train something equivalent).

We've kind of reached the age of true industrial sized data. We've been acclimated to being able to eventually get to supercomputer levels of computation -- it will be a decade before we get there (if we ever do). It will be critical to retain the data that we have before it is locked off from the world into private vaults.

I think the other sibling response to this comment is reasonable: corporations violate the law and they pay some minimal penalty. people violate the law and effectively lose their life.


But if the original data is the whole internet (and then some), what would that even look like? Would it be useful to anyone? Are individuals going to re-run the training?


It would look like a very large hard drive and a whatever the form of the cheapest way to train a huge model would be.

Useful? I guess without a ton of the RL training sets it may be challenging.


No freaking telling. I understand reasons why people might oppose AI, but fascism isn’t on that list.


After reading the post, I only see him calling it "fascist-backed technology" but not fascist in and of itself. Of course that too I think is highly debatable.

Interesting that he's OK using technology in general though, almost all of which is created from raw materials mined by forced/child labor. How is that not more important?


Can they both be important?


Some of the asymmetry might be regained if anubis had thousands of variations of PoW algorithms, each different enough that they must be solved independently.

I wonder if AI might be able to come up with new PoW algorithms in a nightly CI job so every day is a different puzzle...


> I wonder if AI might be able to come up with new PoW algorithms in a nightly CI job so every day is a different puzzle...

This is something I'm working on in a prototype. Stay tuned!


hashx kind of already does it.


...That sounds like entropy? As in, the thing computers are bad at (truly random numbers) and /dev/urandom in your kernel already spits out an approximation of?


You can do this on yours. Just have the client and server add an extra "2" after the challenge key or something. A different client which extracts the challenge key and does its own processing will only generate invalid responses.


Cool, so then that invalidates the ASIC problem, right?

My earlier idea was to imagine that each day Anubis picks an entirely different problem-class. Ex: one day it is Sha256, the next it is prime factorization, the next it is twin-prime-finding, the next it is cracking elliptic curves, the next it is some kind of sorting / information theory problem...

All with the goal of adapting constantly so that scrapers have a harder time optimizing for the PoW problem (i.e. with Sha256 ASICs)


That doesn't work because there is a finite list to choose from.

Nobody is using ASICs on Anubis.


I like the ability to introspect the system. I have a lua LSP, when I edit lua config files, I know all of the fields of the config I am editing, and I know how they behave (without randomly trying things)


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: