MurphyA/hacker-news huggingface dataset:
by rlmark | 2025-11-25 22:06:56+00:00
Thank you! (And thanks for following along for all the years!)

I'll speak a bit to the language audience, and others might weigh in as they see fit. The target is pretty broad: Unison is a general-purpose functional language for devs or teams who want to build applications with a minimal amount of ceremony around writing and shipping applications.

Part of the challenge of talking about that (the above might sound specious and bland) is that the difference isn't necessarily a one-shot answer: everything from diffing branches to deploying code is built atop a different foundation. For example, in the small: I upgraded our standard lib in some of my projects and because it is a relatively stable library; it was a single command. In the large: right now we're working on a workflow orchestration engine; it uses our own Cloud (typed, provisioned in Unison code, tested locally, etc) and works by serializing, storing, and later resuming the continuation of a program. That kind of framework would be more onerous to build, deploy, and maintain in many other languages.
by lelandbatey | 2025-11-25 22:07:06+00:00
Cause the server in your house is a lot cheaper to upgrade with more RAM/storage than a VPS. By using a VPS as just a way to make traffic available, you can choose an extremely cheap VPS. It's pretty easy to find places that'll charge you $2 USD/month for a tiny VPS with 1TB monthly data transfer allowances; for $5 you can get unlimited data transfer. There's tons of good deals.
by scotty79 | 2025-11-25 22:07:15+00:00
Translation: Free lunch of getting results just by throwing money at the problem is over. Now for the first time in years we actually need to think what we are doing and firgure out why things that work, do work.

Somehow, despite being vastly overpaid I think AI researchers will turn out to be deeply inadequate for the task. As they have been during the last few AI winters.
by keeeba | 2025-11-25 22:07:23+00:00
As a fairly extensive user of both Python and R, I net out similarly.

If I want to wrangle, explore, or visualise data I’ll always reach for R.

If I want to build ML/DL models or work with LLM’s I will usually reach for Python.

Often in the same document - nowadays this is very easy with Quarto.
by Molitor5901 | 2025-11-25 22:07:47+00:00
Agreed, and I am reminded that Putin once called Russia a "managed democracy." I may not always agree, but I am very glad America has the first, fifth, sixth, and seventh amendments, among others. This tactic by the British government is absurd and offensive to freedom. What I find more baffling, but perhaps I am narrowly thinking about it, is how much the British people are letting it happen. I am not political, but if anyone tried to take our rights under the Bill of Rights, or declared an emergency to cancel elections, I will be in the streets with, I hope, literally every one else.

Some things are just too critical to a free and fair nation, and jury trials are right up there.
by hxtk | 2025-11-25 22:08:08+00:00
JPEGXL doesn't refer to the same standard as JPEG. JPEGXL competes with AVIF in as a next-generation image format. It also has some properties that make it very nice for the web, such as the fact that a truncated (e.g., because the download hasn't completed yet) JPEGXL image is also a reduced-fidelity version of the same image, which with large images gets you much faster LCP compared to AVIF where the image remains unusable until fully downloaded.
by aorist | 2025-11-25 22:08:10+00:00
> Examples include converting boxplots into violins or vice versa, turning a line plot into a heatmap, plotting a density estimate instead of a histogram, performing a computation on ranked data values instead of raw data values, and so on.

Most of this is not about Python, it’s about matplotlib. If you want the admittedly very thoughtful design of ggplot in Python, use plotnine

> I would consider the R code to be slightly easier to read (notice how many quotes and brackets the Python code needs)

This isn’t about Python, it’s about the tidyverse. The reason you can use this simpler syntax in R is because it’s non-standard-evaluation allows packages to extend the syntax in a way Python does not expose: http://adv-r.had.co.nz/Computing-on-the-language.html
by black_knight | 2025-11-25 22:08:26+00:00
There are several ways of enjoying Minecraft. I play it a lot with my kids (5 and 10) at the moment. They love creative mode, spawning mobs and just building strange houses. When I played with my friends, sibling snd parents, it was all about survival mode everyone would create their own huge buildings and connect up via railway, visit each other and make fun stuff. Then there was the whole red stone rabbit hole…
by constantcrying | 2025-11-25 22:08:27+00:00
The EU is notoriously, and by design, unresponsive to democratic pressures.

>to try and try and try ... against all odds. Doesn't make any sense to discuss that on a bi-yearly basis.

This is quite naive. These people know what they are doing and it isn't too uncommon to consider certain packages of law multiple times.
by Capricorn2481 | 2025-11-25 22:08:28+00:00
> The actual use case for std::slice::from_raw_parts is for when you control the pointer and length and thus can guarantee that they're valid (specifically, by encapsulating them and making sure no safe functions can get them into an invalid state)

Right...so you fix it from the safe code, because the safe code is in charge of using from_raw_parts correctly.

> Either way, the memory safety bug is not in safe rust

This might just be a difference of semantics between us, but I really don't see how you can arrive at that conclusion. Just remove the function entirely and let's use from_raw_parts directly. The bug is literally not in unsafe, it's when we drop the vec after making a slice from it. To fix this, we would not change anything in unsafe.

let vec: Vec<i32> = vec![1, 2, 3, 4, 5]; let ptr = vec.as_ptr(); let len = vec.len(); let slice_ref = unsafe {slice::from_raw_parts(ptr, len)}; drop(vec); println!("{:?}", slice_ref);
by alyxya | 2025-11-25 22:09:02+00:00
The impactful innovations in AI these days aren't really from scaling models to be larger. It's more concrete to show higher benchmark scores, and this implies higher intelligence, but this higher intelligence doesn't necessarily translate to all users feeling like the model has significantly improved for their use case. Models sometimes still struggle with simple questions like counting letters in a word, and most people don't have a use case of a model needing phd level research ability.

Research now matters more than scaling when research can fix limitations that scaling alone can't. I'd also argue that we're in the age of product where the integration of product and models play a major role in what they can do combined.
by miiiiiike | 2025-11-25 22:09:09+00:00
I lost a month to Bazel a few years ago. The documentation had so many holes and what was there was either out of date or wildly inaccurate. You could not produce an Angular build using the tutorials as written. Everything was wrong. I'm sure Bazel great if you have a team of people to write bespoke libraries on top of it for each of your targets. I ended up using turbo for frontend and uv workspaces on the backend.
by lelandbatey | 2025-11-25 22:09:35+00:00
Yes, with asterisks. If you're serving static files from your house, the risk of having your server taken over is incredibly low. If you're hosting Wordpress on your home server, that risk spikes massively. So make sure you understand what is and is not dangerous, and of course, only expose the "low risk parts" to the outside world.
by Dylan16807 | 2025-11-25 22:11:07+00:00
> It's not a bug until main uses it incorrectly.

It's always a bug. The lifetime is wrong.

The mere ability to "use it incorrectly" and break memory safety is evidence of a bug. Safe rust in a program without unsafe can't use anything incorrectly in that way. Safe rust in a program with appropriately careful unsafe can't use anything incorrectly in that way.

> The lifetime is outside of the unsafe block.

The unsafe block uses the types from the surrounding function, so you can't change those types without double checking the unsafe block is still valid.

> I can change it from static and we still have the same bug.

Change it to something correct and have the same bug?

Because your continued examples look like no. If you make the lifetime arbitrary then it's still messed up, and if you get the lifetime off the vec then the bug is fixed.
by al_borland | 2025-11-25 22:11:41+00:00
> Most people now forget that 50+ years ago, the husband was the sole bread winner, kept his job for most of his life, and could afford the house, car, 4 children and a few pets.

When people say things like this, they gloss over the fact that the standard of living, of what most people find acceptable, has gone up dramatically. Average home size has more than doubled, while family size has gone down. Cars have significantly more technology in them. Everyone now needs a $1k smart phone in their pocket.

I live in a home from the 1940s. I’m sure at some point there was a family of 5 living here. My dad grew up in a similar home in the 1950s with 6 people in the home. I think you’d be hard pressed to find someone these days who think my house is big enough for a family that size.

My parents both have some emotional scars I’ve seen from growing up poor in the idyllic era everyone likes to reference.

I think debt has really allowed things to get out of hand. The availability and normalization of using debt for everything has meant companies don’t have to keep prices affordable or pay decent wages, they just need to convince the public that having excessive amounts of personal debt is ok and normal. Then they also create new forms of debt to hide it from people and keep them spending, like BNPL. The idea of living within one’s means has shifted to mean if a person can make the monthly payments.
by drnick1 | 2025-11-25 22:11:53+00:00
I suppose it depends on what exactly is meant by "data science." If find that for stochastic simulations, C++ and the Eigen library are unbeatable. You get the readability of high-level code with the performance of low-level code thanks to the "zero-cost abstractions" of Eigen.

If by data science you mean loading data to memory and running canned routines for regression, classification and other problems, then Python is great and mostly calls C/FORTRAN binaries under the hood, so Python itself has relatively little overhead.
by semiinfinitely | 2025-11-25 22:11:53+00:00
> We are left with only a professional and personal obligation to reemphasize the obvious: Ask what you do know, what you should know, and how big the gap is between them before embarking on creating an IT system. If no one else has ever successfully built your system with the schedule, budget, and functionality you asked for, please explain why your organization thinks it can

translation: "leave it to us professionals". Gate-keeping of this kind is exactly how computer science (the one remaining technical discipline still making reliable progress) could become like all of the other anemic, cursed fields of engineering. people thinking "hey im pretty sure I could make a better version of this" and then actually doing it is exactly how progress happens. I hope nobody reads this article and takes it seriously
by fragmede | 2025-11-25 22:12:01+00:00
That’s kind of a shitty way to put it. Mira wasn’t a PM at OpenAI. She was CTO and before that VP of Engineering. Prior to OpenAI she was an engineer at Tesla on the Model X and Leap Motion. You’re right that she’s not a published ML researcher like Ilya, but "right place, right time" undersells leading the team that shipped ChatGPT, DALL-E, and GPT-4.
by piva00 | 2025-11-25 22:12:43+00:00
Could you please abstain a little bit from incurious, boring, and borderline inflammatory hot takes? Seems to be a pattern for you [0][1][2][3][4] and it's quite boresome. Just a heads-up, go do that on Twitter or something else.

[0] https://news.ycombinator.com/item?id=46050438

[1] https://news.ycombinator.com/item?id=46010655

[2] https://news.ycombinator.com/item?id=46007899

[3] https://news.ycombinator.com/item?id=45998006

[4] https://news.ycombinator.com/item?id=45852749
by agreeahmed | 2025-11-25 22:12:49+00:00
Definitely - it's the nature of software that it tends towards higher order abstractions that make the tools easier and easier to use. The final frontier is English as a programming language. The tools that are easiest to program in English (via a coding agent that "compiles down" your prompt into code) tend to have the tersest APIs, with the least amount of reasoning about state across service boundaries.

It's very likely at this point that the supermajority of future programmers will have almost no formal computer science education. They'll want tools that don't require a deep understanding of the prior generations' layer of abstraction. That's kinda the world we're preparing for - builders who don't need to be deeply technically involved in the details of their vendors in order to build successful software companies
by extr | 2025-11-25 22:13:01+00:00
Yeah data.table is just about the best-in-class tool/package for true high-throughput "live" data analysis. Dplyr is great if you are learning the ropes, or want to write something that your colleagues with less experience can easily spot check. But in my experience if you chat with people working in the trenches of banks, lenders, insurance companies, who are running hundreds of hand-spun crosstabs/correlational analyses daily, you will find a lot of data.table users.

Relevant to the author's point, Python is pretty poor for this kind of thing. Pandas is a perf mess. Polars, duckdb, dask etc, are fine perhaps for production data pipelines but quite verbose and persnickety for rapid iteration. If you put a gun to my head and told me to find some nuggets of insight in some massive flat files, I would ask for an RStudio cloud instance + data.table hosted on a VM with 256GB+ of RAM.
by Capricorn2481 | 2025-11-25 22:13:10+00:00
Forget lifetimes, do this. It's a bug. It's in the safe code. You fix it in the safe code, because it misused unsafe code.

let vec: Vec<i32> = vec![1, 2, 3, 4, 5]; let ptr = vec.as_ptr(); let len = vec.len(); let slice_ref = unsafe {slice::from_raw_parts(ptr, len)}; drop(vec); println!("{:?}", slice_ref);
by ChadNauseam | 2025-11-25 22:13:14+00:00
Unison is one of the most exciting programming languages to me, and I'm a huge programming language nerd. A language with algebraic effects like Unison's really needs to hit the mainstream, as imo it's "the next big thing" after parametric polymorphism and algebraic data types. And Unison has a bunch of other cool ideas to go with it too.

This isn't really what they're going for, but I think it can potentially be a very interesting language for writing game mods in. One thing about game mods is that you want to run untrusted code that someone else wrote in your client, but you don't want to let just anyone easily hack your users. Unison seems well-designed for this use case because it seems like you could easily run untrusted Unison code without worrying about it escaping its sandbox due to the ability system. (Although this obviously requires that you typecheck the code before running it. And I don't know if Unison does that, but maybe it does.) There are other ways of implementing a sandbox, and Wasm is fairly well suited for this as well. But Unison seems like another interesting point in the design space.

Still on the subject of Game Dev, I also think that the ability system might be actually very cool for writing an ECS. For those who don't know, an ECS basically involves "entities" which have certain "components" on them, and then "systems" can run and access or modify the components on various entities. For performance, it can be very nice to be able to run different systems on different threads simultaneously. But to do this safely, you need to check that they're not going to try to access the same components. This limits current ECS implementations, because the user has to tediously tell the system scheduler what components each system is going to access. But Unison seems to have some kind of versatile system for inferring what abilities are needed by a given function. If it could do that, then accessing a component could be a an ability. So a function implementing a system that accesses 10 components would have 10 abilities. If those 10 abilities could be inferred, it would be a huge game changer for how nice it is to use an ECS.
by delaguardo | 2025-11-25 22:13:18+00:00
It should be easy to add source info for every token, some of them already keep both (size and offset) I can create a branch for that.

> I'm curious how much AI was used in the creation of edn.c

A fair amount. This is my first big public project written in pure C. I did consult LLM about best practices for code organisation, memory management, difference in SIMD instructions between platforms, etc. All the things Clojure developer typically don't think about (luxury of a hosted language). Ultimately, the goal was to learn some part of C programming, working reader is a side effect of that.

> These days, I like to get a measure of that for every library I use.

Btw, I'm curious, what kind of measuring you are looking for?
Show HN: KiDoom – Running DOOM on PCB Traces
by mikeayles | 2025-11-25 22:13:35+00:00
I got DOOM running in KiCad by rendering it with PCB traces and footprints instead of pixels.

Walls are rendered as PCB_TRACK traces, and entities (enemies, items, player) are actual component footprints - SOT-23 for small items, SOIC-8 for decorations, QFP-64 for enemies and the player.

How I did it:

Started by patching DOOM's source code to extract vector data directly from the engine. Instead of trying to render 64,000 pixels (which would be impossibly slow), I grab the geometry DOOM already calculates internally - the drawsegs[] array for walls and vissprites[] for entities.

Added a field to the vissprite_t structure to capture entity types (MT_SHOTGUY, MT_PLAYER, etc.) during R_ProjectSprite(). This lets me map 150+ entity types to appropriate footprint categories.

The DOOM engine sends this vector data over a Unix socket to a Python plugin running in KiCad. The plugin pre-allocates pools of traces and footprints at startup, then just updates their positions each frame instead of creating/destroying objects. Calls pcbnew.Refresh() to update the display.

Runs at 10-25 FPS depending on hardware. The bottleneck is KiCad's refresh, not DOOM or the data transfer.

Also renders to an SDL window (for actual gameplay) and a Python wireframe window (for debugging), so you get three views running simultaneously.

Follow-up: ScopeDoom

After getting the wireframe renderer working, I wanted to push it somewhere more physical. Oscilloscopes in X-Y mode are vector displays - feed X coordinates to one channel, Y to the other. I didn't have a function generator, so I used my MacBook's headphone jack instead.

The sound card is just a dual-channel DAC at 44.1kHz. Wired 3.5mm jack → 1kΩ resistors → scope CH1 (X) and CH2 (Y). Reused the same vector extraction from KiDoom, but the Python script converts coordinates to ±1V range and streams them as audio samples.

Each wall becomes a wireframe box, the scope traces along each line. With ~7,000 points per frame at 44.1kHz, refresh rate is about 6 Hz - slow enough to be a slideshow, but level geometry is clearly recognizable. A 96kHz audio interface or analog scope would improve it significantly (digital scopes do sample-and-hold instead of continuous beam tracing).

Links:

KiDoom GitHub: https://github.com/MichaelAyles/KiDoom, writeup: https://www.mikeayles.com/#kidoom

ScopeDoom GitHub: https://github.com/MichaelAyles/ScopeDoom, writeup: https://www.mikeayles.com/#scopedoom
by sbeli | 2025-11-25 22:14:09+00:00
This looks like a REALLY cool tool for tech-focused startups. I like that its not just resolving the stripe bloat but also the code. You can setup a full production-ready payments processor without worrying about the code.

I'm wondering - is there some overhead required to keep operations up? Or Flowglad takes care of everything between code and compliance

Also, sick sweater I have the same one XD
by 0_gravitas | 2025-11-25 22:14:24+00:00
Well, paying money for consumer apps/services (besides games) has always seemed a bit more normalized in the iOS ecosystem, and I imagine it must be a _somewhat_ simpler interface than the lovecruftian monolith of windows-N

saying this as a Linux user, I've never owned an apple device in my life (nor do I want to)
by lawlessone | 2025-11-25 22:14:29+00:00
>What would make it less contrived to you?

No creating a contrived situation where the it's the models only path?

https://www.anthropic.com/research/agentic-misalignment

"We deliberately created scenarios that presented models with no other way to achieve their goals"

You can make most people steal if you if you leave them no choice.

>Giving my assistant, human or AI, access to my email, seems necessary for them to do their job.

Um ok? never felt the need for an assistant myself but i guess you could do that if you wanted to.
by Weves | 2025-11-25 22:14:43+00:00
> ease of installation, streaming support, model agnosticity, chat persistence and blob support

we have all of those!

> how onyx is comparable

For an AI-powered research assistant, Onyx might just work out of the box. We have ~45 connectors to common apps (https://github.com/onyx-dot-app/onyx/blob/main/backend/onyx/...), integrations with the most popular web search providers (https://github.com/onyx-dot-app/onyx/blob/main/backend/onyx/...), and a built in tool calling loop w/ deep research support (https://github.com/onyx-dot-app/onyx/blob/main/backend/onyx/...). If you wanted to customize, you could pretty easily tweak this / add additional tools (or even rip this out completely and build your own agent loop).
by adastra22 | 2025-11-25 22:15:30+00:00
That's not what "readability" generally means. Yes, Rust's semantics are more tightly locked down, and that's a big part of why I use it. But given two well-written source files, one in modern C++ and one in contemporary Rust, can you quickly skim and understand what each one is supposed to be doing, irregardless of bugs that might be lurking? If you made me guess right now which one I'd have an easier time understanding, I'd guess the C++ file.
by imiric | 2025-11-25 22:15:36+00:00
Hi there, and congrats on the launch. I've been following the project from the sidelines, as it has always seemed interesting.

Since everything in software engineering has tradeoffs, I have to ask: what are Unison's?

I've read about the potential benefits of its distributed approach, but surely there must be drawbacks that are worth considering. Does pulling these micro-dependencies or hashing every block of code introduce latency at runtime? Are there caching concerns w.r.t. staleness, invalidation, poisoning, etc.? I'm imagining different scenarios, and maybe these specific ones are not a concern, but I'd appreciate an honest answer about ones that are.
by IshKebab | 2025-11-25 22:16:03+00:00
I disagree. At least at the RTL level they're very similar. You don't really deal with physics there, except for timing (which is fairly analogous with software performance things like hard real-time constraints).

> Result is that there is not a 'right' way to do any one thing that everyone can converge on.

Are you trying to say there is in hardware? That must be why we have exactly one branch predictor design, lol

> The first airplane wing looks a whole lot like a wing made today, not because the people that designed it are "real engineers" or any such BS, but because that's what nature allows you to do.

"The first function call looks a whole lot like a function call today..."