foundry27

Bigger discussion from two days ago: https://news.ycombinator.com/item?id=42259184

My understanding was that the metric for LMArena is that one answer is “better” than another, for a deliberately 100% subjective definition of better.

My experience has been that typical LLMs will have more “preamble” to what they say, easing the reader (and priming themselves autoregressively) into answers with some relevant introduction of the subject, sometimes justifying the rationale and implications behind things. But for o1, that transient period and the underlying reasoning behind things is part of OpenAI’s special sauce, and they deliberately and aggressively take steps to hide it from users.

o1 will get correct answers to hard problems more often than other models (look at the math/coding/hard subsections on the leaderboard, where anecdotal experiences aside, it is #1), and there’s a strong correlation between correctness and a high score in those domains because getting code or math “right” matters more than the justification or explanation. But in more general domains where there isn’t necessarily an objective right or wrong, I know the vibe matters a lot more to me, and that’s something o1 struggles with.

This is straight out of The Heechee Saga! The idea of synthesizing human-edible food from asteroid hydrocarbons is literally what Pohl described with CHON food. Breaking down carbon, hydrogen, oxygen, and nitrogen to create sustenance for ships, stations, even whole planets.

Judging by the study’s data, converting the organic compounds in an asteroid like Bennu could feed thousands of astronauts for decades. Even the lower estimate of 600 astronaut life-years is staggering when you consider how much food we’d otherwise have to launch from Earth (even with SpaceX’s cost reductions, Elon). If we can refine these processes to work efficiently and reliably, which is a very big if, we’re looking at a future where asteroid mining could fuel spaceships AND feed the crew without being tethered to Earth

It’s great satire, but it really does mirror a larger societal shift where the burden of safeguarding personal autonomy has shifted from institutions/regulators to individual users. Do-Not-Stab, Do-Not-Track, whatever it might be, any sort of “voluntary compliance” is a non-starter in the face of financial pressures

IMO we need to start normalizing being militant about this stuff again, to aggressively and adversarially defend the freedom to use your computer the way you choose to use it

The big-picture view is here: https://gitlab.com/owl-lisp/owl/-/blob/master/doc/manual.md

Key points include:

- 100% immutable datastructures

- Immutability is leveraged to make a lot of core operations concurrent

- Continuation-based threading model and Actor-based concurrency

- Fun little VM implemented behind the scenes

That being said, the documentation strongly contradicts the title!

> The goal has not at any point been to become an ultimate Lisp and take over the world

For anyone who hasn’t seen this before, mechanistic interpretability solves a very common problem with LLMs: when you ask a model to explain itself, you’re playing a game of rhetoric where the model tries to “convince” you of a reason for what it did by generating a plausible-sounding answer based on patterns in its training data. But unlike most trends of benchmark numbers getting better as models improve, more powerful models often score worse on tests designed to self-detect “untruthfulness” because they have stronger rhetoric, and are therefore more compelling at justifying lies after the fact. The objective is coherence, not truth.

Rhetoric isn’t reasoning. True explainability, like what overfitted Sparse Autoencoders claim they offer, basically results in the causal sequence of “thoughts” the model went through as it produces an answer. It’s the same way you may have a bunch of ephemeral thoughts in different directions while you think about anything.

I’d guess the easiest explanation (which admittedly erases all nuance) is that folks just misinterpreted the question and reflexively dismissed it as soon as they saw “Z-Library” and “Helpful”.

I’d also be inclined to discard theoretical “in the long run it’ll be unhelpful” concerns, since that opens up an infinitely-deep can of hypothetical contrived scenarios of arbitrary complexity that can’t be disproven. I’m sure there are very real concerns, but it’s impossible to reason about which concerns specifically people would care about.

IMO that leaves the purely practical concerns:

- Students in poverty might not have reliable internet, devices or digital literacy. If zlib isn’t available to them, it isn’t helpful

- Books available might not cater to the local language/culture, or the real world curriculum needs of those students. If zlib doesn’t help them succeed, it isn’t helpful

- The interface sucks and is confusing, which makes students struggle to find what‘s useful. If zlib isn’t useable for them, it isn’t helpful

Yeaaah. TCP hole punching is goofy and unreliable, last I checked. You have to do some arcane ritual of having both peers start a three-way handshake to each others’s public endpoints simultaneously, relying on NATs to accept inbound SYN packets if they match the outgoing SYN. And nobody’s NAT devices implement simultaneous-open the same way, so all your connections just fail.

Naturally this leads to slapping even more arcane fixes on top of that, like NAT port assignment oracles to adversarial interoperate with different port allocation strategies (random, sequential, single, etc.) by analyzing patterns in previous port assignments. Networking sucks.

The first thing I tried to find on their website and their GitHub was a protocol specification, to be able to implement it independently from the reference implementation. I thought this would be straightforward since it’s advertised as a scheme/protocol, but such a spec isn’t referenced anywhere! Digging on my own I eventually found [1] on a side-branch of one of their other GitHub projects.

Kudos to the author: I think it actually covers a lot of what you’d need to know: crypto identities, message formats, wire protocols, peering and stream semantics, spanning tree updates and root selection, the DHT, forwarding logic, sessions, etc. A couple things are TODOs like how to verify and sign root updates, and there’s some ambiguity in the tiebreaker algorithm for next-hop selection.

It seems to be very tightly coupled to TCP as the transport layer though, since all packets need to be delivered reliably and in the order they were sent, and need to be capable of being fragmented into smaller packets for varying MTU sizes.

[1] https://github.com/yggdrasil-network/yggdrasil-specs/blob/ys...

It actually would! There are a handful of base-10 arbitrary precision arithmetic implementations in the preprocessor[1], and modern continuation-passing style macro metaprogramming[2] makes it straightforward to write a function like factorial once you get the syntax and semantics down.

Libraries like Boost.Preprocessor can’t be taken as an example of “cutting edge” preprocessor metaprogramming. It set a very low bar, and IMO has stifled a lot of developer creativity.

[1] https://github.com/rofl0r/chaos-pp/tree/master/chaos/preproc... [2] https://github.com/rofl0r/order-pp/blob/master/example/fibon...

The prompting strategies in this post made me remember a funny anecdote from this Thanksgiving. My older family members had been desperately trying to get ChatGPT to write a good poem about spume (the white foam you see in waves), and no matter how many ways they explicitly prompted it to not write in rhyming couplets, it dutifully produced a rhyming couplet poem every time. There’s clearly an enormous volume of poems in the training data written in this form, and it was practically impossible to escape that local minimum within the latent space of the model, like the half-full wine glass imagery. They only succeeded at generating a poem written the way they wanted when they first prompted ChatGPT to reason through the elements of good poetry writing regardless of style, and then generate a prompt to write a poem following those guidelines. Naturally, that produced a lovely poem on the first attempt with that prompt!

It’s pretty well known at this point, but it seems like when it comes to prompting these models, telling them what to do or not do is less effective than telling them how to go through the process of achieving the outcome. You need to get them to follow steps to reach a conclusion, or they’ll just follow the statistical path of least resistance.

Edit: the poem: https://paste.ee/d/rIbLa/0

I like this article. Randomness in system design is one of the most practical ways to handle the messiness of real world inputs, and I think random forests nail this by using randomness to produce useful outputs to various inputs without overfitting and adapt to the unexpected. Yeah, you can always engineer a system that explicitly handles every possible situation, but the important question is “how long/costly will that process be?”. Deterministic systems aren’t good on that front, and when edge cases hit, sometimes those rigid models crack. Controlled randomness (load balancing, feature selection, etc.) makes systems more flexible and resilient. You don’t get stuck in the same predictable ruts, and that’s exactly why randomness works where pure determinism fails

I’ll propose that most Rust projects that do useful work (in the potential energy sense?) depend on unsafe code, and it’s likely going to be found in the codebases of their dependencies and transitive dependencies. But I agree with almost all of what you’re saying about C and Rust; I work on a C operating system professionally, and I know those same pain points intimately. I program in Rust for fun, and it’s great to use.

At the end of the day this isn’t a technical argument I’m trying to make, it’s a philosophical one. I think that the more we normalize eroding the core benefits the language safety features provide, one enhancement proposal at a time, one escape hatch added each year for special interfaces, the less implicit trust you can have in rust projects without reviewing them and their dependencies for correctness.

I think that trust has enormous value, and I think it would suck to lose it. (reflect: what does seeing “written in rust” as a suffix make you think about a project’s qualities before you ever read the code)

Rust’s whole premise of guaranteed memory safety through compiletime checks has always been undermined when confronted with the reality that certain foundational operations must still be implemented using unsafe. Inevitably folks concede that lower level libraries will have these unsafe blocks and still expect higher level code to trust them, and at that point we’ve essentially recreated the core paradigm of C: trust in the programmer’s diligence. Yeah Rust makes this trust visible, but it doesn’t actually eliminate it in “hard” code.

The punchline here, so to speak, is that for all Rust’s claims to revolutionize safety, it simply(!) formalizes the same unwritten social contract C developers have been meandering along with for decades. The uniqueness boils down to “we still trust the devs, but at least now we’ve made them swear on it in writing”.

It never even occurred to me that they could be talking about something other than the virtual memory manager. I was hyped to see if there was some new architecture being applied for cross-OS compatibility, novel memory objects, techniques to reduce fragmentation, stuff like that. Now I’m just sad.

I think it’s really interesting to see the similarities between what Wolfram is saying and the work of Julian Barbour on time being an emergent property. Both suggest a similar underlying ontology for the universe: a timeless, all-encompassing realm containing all possible states / configurations of everything. But what’s really fascinating is that they reach this conclusion through different implementations of that same interface. Barbour talks about a static geometric landscape where time emerges objectively from the relational (I won’t say causal) structures between configurations, independent of any observer. On the other hand, Wolfram’s idea of the Ruliad is that there’s a timeless computational structure, but time emerges due to our computational limitations as observers navigating this space.

They’ve both converged on a timeless “foundation” for reality, but they’re completely opposite in how they explain the emergence of time: objective geometry, vs. subjective computational experience

“Open-Source Utility Mod for Enhancing Minecraft Gameplay (on Anarchy Servers)” is one seriously dysphemistic euphemism for cheats. What’s the point in couching terms that’ve been around for decades like “hack client” or “game cheats” in this kind of terminology? Is it someone’s clever way of trying to work around EULA terms that ask people to please not cheat in their video games? It’s hardly going to fool anyone or do anything at all to stop someone at Microsoft from sending a DMCA or suing if they wanted to.

Just own it if you’re going to put all the work into developing it!

This looks really interesting and I love how well put-together it feels! I wish your offline desktop software version had a one-time payment option though. Forcing SaaS subscriptions for non-SaaS is a big turn-off IMO.

It's easy to downvote and move on, but I don’t think that does justice to the valid underlying concerns this parent comment raises. I don’t agree with the idea that there’s “no reason” to question the guy’s actions - because his methods do raise serious ethical and safety concerns - but I think it’s right to caution against kneejerk reactions that might lead to government overreach. We should be wary of how power can be used to silence people, even if those people did shitty things in the past or are controversial figures.

Ignoring the underlying point being made won't make it go away, and won’t help educate any of our peers who might take some of this stuff at face value.

It’s concerning to me that this has been downvoted so heavily.

Obviously as a private group DEF CON’s organizers have every right to contract with whatever companies they want to. In the same way, obviously the private individuals paying DEF CON’s organizers have every right to criticize them when they treat their contractors so poorly. However , I think it’s short-sighted and self-defeating to suggest that they shouldn’t ALSO have the right to criticize their choice of companies they work with when it impacts the quality of what they’re paying for.

This is not a sexist, anti-POC, or anti-trans criticism. Deciding on contractors for the reasons they claimed they did would be illegal in the public sector under France’s anti-discrimination laws, under Germany’s Grundgesetz, under Japan’s GPA, under the UK’s Equality Act in many cases, etc.

What kind of tooling modernization would even make a difference?

At least SDP 8.0 overhauled the kernel to not be locked to a single thread anymore, which is nice IMO

The site is ~3000 words (half of Attention Is All You Need, as a measuring stick) of Eye-Catching Summary Statement\nShort Explanatory Paragraph statements like the ones GPT-4 is so fond of generating, and has no formal design model to reason about, no justification on why the design is right, no information on training, no evaluation results, and no code.

I can’t help but feel it’s a shame to have published this draft (I hesitate to call it a preprint) before any of the factual content of the article was suitable for publication, since if these improvements are as effective and profound as the summary suggests, you’re doing yourself and your work a disservice by advertising it in a shallow way.

Using localized versions of your services to comply with regional laws and enhance user experiences (i.e. make money) is SOP for practically every international $bigco. Online gambling is regulated and legal in ~50%-70% of the world; without actual evidence to the contrary, it’s completely reasonable to assume that this is a legitimate business. I’m really struggling to agree with the “two sides to every story” replies being left here about how there’s likely shady activity going on behind the scenes, when to me the post read as candid and transparent about the nature of the nature of the business, the admitted legitimacy of CF’s TOS violation claims against them, and the content of the communications with CF.

My 2c: It’s scummy that CF did this. It looks like they were disingenuous about the severity of the violations and used it as an excuse to get more $$$ from an already paying customer to make the manufactured problem go away.

The conversation is K = C + 273.15.

At high temperatures, it’s essentially a rounding error.

Also involved with some of these industries, no academia/government though, so my perspective may be incomplete. Anecdotally I can’t remember hearing this term used.

After reading the Wikipedia page and a couple corporate pages about cyberphysical, I think it looks like it’s more about rebranding existing systems that contain interacting heterogenous elements with different RT needs, rather than introducing fundamentally new systems methodologies or technologies. It kinda reminds me of Agile, where a shift in mindset and terminology was hyped way more than any legitimate improvement in the underlying systems being built, and engineering “Agile products” became so important for some businesses.

This looks really cool. I’d have loved to give it a try as someone interested in improving my French, but I wasn’t able to download the app since it’s pinned to the latest version of iOS only.

Are you using APIs that are unavailable on iOS 16 and under, or is it a matter of testing? My understanding was that about 25% of iPhone users aren’t on iOS 17 (myself included!) so it’s a fairly large demographic

You’re right, they do have lots of OSes. But most of them are for lower-ASIL elements where the functional safety and SOTIF requirements are less strict. I’d be very surprised if there was quite as much diversity at ASIL D.

Edit: Usually good form to point out your affiliation when you're commenting on your own company's announcements. Unless I'm very much mistaken, RadVl sounds a lot like a portmanteau of Vlad Radulescu, FSM at OxidOS. It's a great looking product, don't get me wrong!

I understand why this transcription may have been downvoted, and why devaluing the creator’s effort & intent in their choice of medium, dismissing diverse learning preferences/accessibility needs, etc. are Bad Things, and I appreciated this transcription being left here. But seriously: others very well might feel the same, but packaging this up with bashing the creator really wasn’t necessary IMO.

(Grumpy old man edit: __VA_OPT__ has been implemented in macro libraries by users for decades without language support. Making it a keyword made no more sense to me than if vector was made a language primitive in C++)

Tree-based expansion machines are the usual way to do preprocessor recursion for non-trivial applications (see: order-pp, chaos-pp). They have that desirable property of letting you process an exponential number of tokens using a linear number of macros, while letting you “bail out” at any time and avoid needing to resolve all of those deeply-nested macro expansions when there isn’t more work to be done.

Getting the linear->exponential property is actually the easy part, since you just need two parallel hierarchies of macros (shamelessly plugging https:.//github.com/notfoundry/pp2/blob/master/include/pp2/machine/vm.h as the most readable implementation). It’s how you stop expanding before the heat death of the universe once you have an effectively unlimited number of recursive expansions available that’s really interesting: if you design all of your recursive macros to return their output wrapped in parentheses, you can write your recursion machine in such a way that at the end of every recursion step, those parentheses are used to complete a function-like macro expansion to get to each next recursion step downstream. When you want to stop computation, you make your recursive macro stop expanding to something parenthesized, and the system naturally stops making progress. In a sense, each recursive macro provide its own potential energy to power the whole recursion system!

I think the C preprocessor is an interesting example of (2), because the metaprogramming community has converged on an extremely clever paradigm to circumvent the lack of recursion: continuation machines. By defining a linear number of “continuation evaluation” macros, you can generate an exponential number of “recursive” macro expansions, which trivially scales to the point that it could take until the heat death of a universe for an arbitrary program to terminate, but a program can choose to terminate at any time. The Chaos-pp and Order-pp projects are good implementations of this!