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

If they're the type of tone deaf person who thought that the alternative interview was a good idea, how likely do you think it is that they'll take your advice?


I wouldn't go that far. I recognize that I came out in full swing mostly because job search is still a touchy topic (so many ghostings...), but where else are we to discuss our bad ideas if not here? If anything, the OP brought it up here instead of implementing it in their pipeline. ~~BMW~~ Some companies didn't even think that far.


Spam bot.


If only Claude didn't constantly drop to less capable models whenever it encountered anything vaguely cybersecurity related (despite being part of the Anthropic Cyber Verification Program and having Mythos access, albeit limited).

We're strongly pushing for a move to a mix of Codex and open models at my workplace because of Anthropic's ridiculous nanny-ing.


Yep, gotta really mind the language, sometimes saying something like “when implementing feature you gotta pay attention to to avoid attack” is enough to trigger it, along with a cache miss of 300k tokens in the downgraded request to rub it in. Frustrating.


• Mythos 5.1's safeguards stopped the response above · continuing once with that noted


Also in the CVP and kept tripping cyber a couple days ago due to an MCP server that had the ability to connect to remote devices. Maybe it thought I was trying to make a C&C server. But you literally have to start the MCP first, have it generate a key, give the key to the remote device and then it'll generate its key, then give that key back to the MCP server before they can connect.


These types of flip flop posts are the new security theater. One week Anthropic will post a doom and gloom about how open weight models running a fraction of a token per second on your Grandma's popped Android TV is a national security threat and the next week they'll tell you how awesome their 200+ billion parameter model is at doing something they don't actually allow you to do because they gatekeep all the normies. I really do hope history remembers them correctly, but I'm sure they'll be attributed as being a significant and load bearing linchpin during the new world order of LLMs.


> their 200+ billion parameter model

It's a 10T BTW.


Having a big brother on the frontier models in the cyber verification program defeats the whole purpose of the program. My team has found ourselves leaning the same direction your team is going. I was looking into GLM 5.3 to host in our env and come to find there is an article from anthropic trying to say that model is "dangerous" and/or not good compared to their models.


> Maybe someone should fork xscreensaver as xscreensaver-ng as a community project?

Feel free.


No shortage of fossil fuels though...


The art is credited to yvaneht nioj, another simpsons reference.


Which reminds me of the Ralph Wiggum music video: https://www.youtube.com/watch?v=b403GtvwyEc



SSIs are not widely supported any more, and were never a part of the HTML standard

(but yes- I used these a lot like 25 years ago)


From what I can tell, apache mod_include and nginx SSI are still included by default?


Proofs are much easier when one just lists their axioms, leaving the rest an exercise to the reader.


Floating point is deterministic, what are you talking about?

> You just have to use other data types to handle money or complex mathematical operations like 0.2+0.1

Such as... decimal floating point.


CPUs have many different configuration bits to configure floating point rounding, flushing denormals, etc. which mean that in practice anything that relies on floats being deterministic has the stability of a house of cards.


All of which are well defined and can be configured from user space. That doesn't make them non-deterministic.


> Floating point is deterministic, what are you talking about?

Order of operations can change a result, for example. I suspect you mean that the algorithm never changes. While op means that mathematical operations which most folks would expect to be reliable are not.


They're not associative, sure. But that's a very far cry from claiming they're non-deterministic.


There are enough problems for a 44 page paper titled "What Every Computer Scientist Should Know About Floating-Point Arithmetic"[1] I don't quibble on the language because I know what people mean.

Most folks won't encounter most of the issues, generally. But expose your code to a large enough dataset, or be like me and write a CAD/CAM system with motion control and experience most of them.

That's why I wrote hyperreal[2]

1: https://www.cs.tufts.edu/cs/40/docs/WhatEveryComputerScienti...

2: https://github.com/timschmidt/hyperreal


That (no doubt excellent, but) technical PDF is overselling the problem somewhat, when what every dev needs to know is better represented by a friendlier summary like https://floating-point-gui.de/


That's a great resource as well. Targeted at developers, rather than computer scientists. Same observations, different target audiences and expectations. You're probably right that the more practical reference targeted at developers is more useful here. My references are full of the academic papers because of my CAD work.


> Targeted at developers

Sorry, yes, I probably should have worded that in a way that made the distinction more obvious.


You don’t quibble about what words mean when the words you choose have very specific meanings in exactly the subject area you are talking about?

You make it really hard to take you seriously.


No. It's been quite some time since I realized that all language is a pidgin used to translate between individuals' unique lived experiences and points of reference. And find communication much more fluid and less confrontational when the focus is on shared meaning rather than perfect word choice. Especially when working with non-native speakers, but also just people in general. Stephen Fry captures the feeling: https://www.youtube.com/watch?v=Ovi7uQbtKas

When TZubiri made their original comment, I understood they were speaking about some or all of the issues outlined in the paper I linked. If you didn't, that's ok. If you think the referenced paper missed something, it's OK to add that.

> You make it really hard to take you seriously.

Same, bud.


These kinds of comments tend to happen when you are assuming a shared meaning that isn't so shared. Especially in this context, it's a good idea to be precise in your terminology when there is a commonly used vocabulary for talking about it. Especially when it comes to misconceptions about floating point, which is often treated as 'random' when it generally isn't.


Sometimes specificity matters. Usually when looking directly at some specific piece of code. In this conversation, the intended meaning was clear. Folks just love being the pedant and the brinksmanship which comes with it. There's a propensity to derail otherwise useful conversations into discussions like this rather than dig deeper into what people meant, and were trying to communicate.


> In this conversation, the intended meaning was clear

Apparently it wasn't, as the commenter who originally used the term has now clarified that they did indeed mean non-deterministic. You misunderstood them.

So maybe being specific about terminology here isn't just pointless pedantry?


Regardless of his choice of words, he's specified that he's speaking about IEEE754 and the sort of issues which arise systemically from the compromises inherent in it's design.

He can't attest to them being the same ones in the paper I linked, but I can. Everything he's said is in line with the situation detailed within.

He and I seem to understand each other. I get what he's saying. How the issues with IEEE754 give rise to the nondeterminism he's talking about. I should, I wrote a whole system of libraries to deal with them. Do you understand the conversation? Because it seems like you think we're talking about two unrelated things and you're still arguing over terminology.


Thanks for following the thread. I'll clarify on my intended meaning was indeed a strict actual definition of determinism, but a broader definition of floating point, to include its actual usage. But fwiw, it was indeed possible that I was someone who confuses determinism for precision, but no.

When I said that floating points are not deterministic, I wasn't very precise, but I do think that broadly speaking, floating point arithmetic, as used today, foregoes determinism, and this results from the very ethos of the foundational IEEE754 data type, the goal is to have a data type for approximate answers, turns out that when exact answers are sacrificed in the name of speed, so is determinism. And this has huge effects on modern day, Floating Point is used on separate hardware with parallel operations, and there's race conditions that make most Machine Learning and AI computing irreproducible, and that indeed seems to be a consequence, as you mention, of the lack of associativity of FP.

So, that said, I would make two clarifications:

>-- Floating Points

>++ Floating Point computing

where by Floating Point computing would mean the actual application computing that we build, as opposed to "Floating points" referring to the ideal ancient standardized hardware layer abstractions.

And if necessary:

> -- is

> ++ tends to be

In order to be perfectly correct, which after all, is what we are going after.

So if pressed, I wouldn't say "Floating points are not deterministic" but "Floating Point computing tends to be non-deterministic", but I would feel very comfortable shorthanding it to "Floating Points are non-deterministic" anyways.

The paper cited is a bit hard for me, so I can't verify if it matches what I'm saying. But I imagine by the date, it wouldn't be able to address the issues that we can empirically from the advent of ML systems, but maybe it did foresee from a theoretical standpoint some of their limitations.

There's a between-the-lines thesis here that there's two main schools of computing nowadays, one that seeks perfection, and another that seeks approximations, the CPU/GPU dichotomy is roughly analogous to the Mathematics/Physics vs Engineering/Industrial dichotomy.rroot@t14:/mnt/c/Users/TomZubiri/Desktop# cat fixed.txt Thanks for following the thread. I'll clarify on my intended meaning was indeed a strict actual definition of determinism, but a broader definition of floating point, to include its actual usage. But fwiw, it was indeed possible that I was someone who confuses determinism for precision, but no.

When I said that floating points are not deterministic, I wasn't very precise, but I do think that broadly speaking, floating point arithmetic, as used today, foregoes determinism, and this results from the very ethos of the foundational IEEE754 data type, the goal is to have a data type for approximate answers, turns out that when exact answers are sacrificed in the name of speed, so is determinism. And this has huge effects on modern day, Floating Point is used on separate hardware with parallel operations, and there's race conditions that make most Machine Learning and AI computing irreproducible, and that indeed seems to be a consequence, as you mention, of the lack of associativity of FP.

So, that said, I would make two clarifications:

>-- Floating Points

>++ Floating Point computing

where by Floating Point computing would mean the actual application computing that we build, as opposed to "Floating points" referring to the ideal ancient standardized hardware layer abstractions.

And if necessary:

> -- is

> ++ tends to be

In order to be perfectly correct, which after all, is what we are going after.

So if pressed, I wouldn't say "Floating points are not deterministic" but "Floating Point computing tends to be non-deterministic", but I would feel very comfortable shorthanding it to "Floating Points are non-deterministic" anyways.

The paper cited is a bit hard for me, so I can't verify if it matches what I'm saying. But I imagine by the date, it wouldn't be able to address the issues that we can empirically from the advent of ML systems, but maybe it did foresee from a theoretical standpoint some of their limitations.

There's a between-the-lines thesis here that there's two main schools of computing nowadays, one that seeks perfection, and another that seeks approximations, the CPU/GPU dichotomy is roughly analogous to the Mathematics/Physics vs Engineering/Industrial dichotomy.


> when exact answers are sacrificed in the name of speed

I have found in https://github.com/timschmidt/hyperreal and the geometry layers built atop it, that exactness and speed are not fundamentally opposed. Hyperreal retains exact mathematical structure at the scalar level, and at each level higher up through vertices, vectors, matrices, triangles, curves, etc. And uses it to choose optimal datatypes, dispatch against the fastest algorithms, and eliminate large chunks of needless calculation where simpler proofs are sufficient.

The downside is a bit of additional code and API complexity. But the slightly more complex API accurately represents issues like uncertainty in decidable equality of arbitrary computables in bounded time, which is a limitation of math itself, so representing it accurately in the API permits the algorithms to be more robust.

> Floating Point is used on separate hardware with parallel operations, and there's race conditions that make most Machine Learning and AI computing irreproducible

Deterministic reproducibility is, I think, one of the most awesome superpowers of a system like hyperreal. It makes simulation much more interesting and useful. As well as cross-platform use.


    floating point arithmetic, as used today, foregoes determinism, and this results from the very ethos of the foundational IEEE754 data type
This was somewhat true in the past, but the situation has been improving dramatically in recent years to the point where FP determinism is completely feasible. The remaining hurdles are primarily on the toolchains/kernel side. I have a library called rfloat that you can drop into most C/C++ code for practical determinism without thought (subject to documented caveats), for example. You can do the same thing manually with some more careful attention.

I'm in a very remote corner of the world on bad Wi-Fi though, so you'll have to forgive omitted links.


>in recent years to the point where FP determinism is completely feasible.

Ok, sure, it is feasible, but is that how it's actually used? Or is it used in GPUs with thousands of processors running in parallel, and batching different operations, (and with temperature settings that add even more pseudo-indeterminism purposefully).

It's funny that the customs actually go in the opposite direction of fabricating even more indeterminism, whether it is for being an accountability sink, or for fudging data to claim IP over the new mungled data, the FP/GPU/ML folk want magic, not determinism.


> I gonna be generous and guess this was upvoted as top post for being maybe possibly midwit-correct, hoho you are so right good sire, reddit-fedora-tip herpdy-derp.

You may want to look in a mirror. Your snide tone does not add anything here.


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

Search: