MurphyA/hacker-news huggingface dataset:
by jaredklewis | 2025-07-10 17:32:19+00:00
> Prefer permissive licenses only if you want to subsidize big business.

Another reason to prefer permissive licenses is if you want anyone to use your project.

Most coding out there in the world is done in the service of a commercial enterprise and my experience is that companies won't use copy left projects. Companies are generally happy to use projects with permissive licenses or pay for SaaS or commercial licenses, but anything with the GPL is a non-starter.

There are a few, well known exceptions (Linux, GCC), but I can't think of any exceptions from projects started in the last 20 years.

I don't necessarily think this view is entirely rational or irrational, but I’m confident this attitude exists; companies using GPL projects are pretty rare. Anyone found differently?
by naasking | 2025-07-10 17:32:41+00:00
// Computes the delivery date for each component. let r = query p select (c, d) from ReadyDate(c; d)

facepalm. Select should always come last, not first, haven't we learned anything from the problems of SQL? LINQ got this right, so it should look like:

query p from ReadyDate(c; d) select (c, d)

Very cool language otherwise.
Show HN: Open source alternative to Perplexity Comet
by felarof | 2025-07-10 17:33:07+00:00
Hey HN, we're a YC startup building an open-source, privacy-first alternative to Perplexity Comet.

No invite system unlike bunch of others – you can download it today from our website or GitHub: https://github.com/browseros-ai/BrowserOS

--- Why bother building an alternative? We believe browsers will become the new operating systems, where we offload much bunch of our work to AI agents. But these agents will have access to all your sensitive data – emails, docs, on top of your browser history. Open-source, privacy-first alternatives need to exist.

We're not a search or ad company, so no weird incentives. Your data stays on your machine. You can use local LLMs with Ollama. We also support BYOK (bring your own keys), so no $200/month plans.

Another big difference vs Perplexity Comet: our agent runs locally in your browser (not on their server). You can actually watch it click around and do stuff, which is pretty cool! Short demo here: https://bit.ly/browserOS-demo

--- How we built? We patch Chromium's C++ source code with our changes, so we have the same security as Google Chrome. We also have an auto-updater for security patches and regular updates.

Working with Chromium's 15M lines of C++ has been another fun adventure that I'm writing a blog post on. Cursor/VSCode breaks at this scale, so we're back to using grep to find stuff and make changes. Claude code works surprisingly well too.

Building the binary takes ~3 hours on our M4 Max MacBook.

--- Next? We're just 2 people with a lot of work ahead (Firefox started with 3 hackers, history rhymes!). But we strongly believe that a privacy-first browser with local LLM support is more important than ever – since agents will have access to so much sensitive data.

Looking forward to any and all comments!
by ta8645 | 2025-07-10 17:33:09+00:00
Perhaps. But I think you'll find there are a lot of black rectangles on a PCB that aren't actually transistors. You'll end up having to teach the child a lot more if you want accurate results. And that's the same kind of training you'll have to give to an LLM.

In either case, your assertion that one _understands_, and the other doesn't, seems like motivated reasoning, rather than identifying something fundamental about the situation.
by bonoboTP | 2025-07-10 17:33:23+00:00
> Also woth noting that Higgs claimed that the publish or perish climate of the 90s would have made his work in the early 60s impossible.

I found the posted article interesting in that it seemed to contradict this sentiment. See from the section titled "Göttingen and the birth of modern academia".

Not the 60s vs now comparison, but the article contradicts the idea that "publish or perish" is new. Instead it says that careers depended on publication counts before original research was even expected of university professors.
by sparkie | 2025-07-10 17:33:45+00:00
To retain referential transparency, we basically need to ensure that a function provided the same arguments always returns the same result.

A simple way around this is to never give the same value to a function twice - ie, using uniqueness types, which is the approach taken by Clean. A uniqueness type, by definition, can never be used more than once, so functions which take a uniqueness type as an argument are referentially transparent.

In Haskell, you never directly call a function with side effects - you only ever bind it to `main`.

Functions with (global) side effects return a value of type `IO a`, and the behavior of IO is fully encapsulated by the monadic operations.

instance Monad IO where return :: a -> IO a (>>=) :: IO a -> (a -> IO b) -> IO b -- aka "bind"

return lifts a pure value into IO, and bind sequences IO operations. Importantly, there cannot exist any function of type `IO a -> a` which escapes IO, as this would violate referential transparency. Since every effect must return IO, and the only thing we can do with the IO is bind it, the eventual result of running the program must be an IO value, hence `main` returns a value of type `IO ()`.

main :: IO ()

So bind encapsulates side effects, effectively using a strategy similar to Clean, where each `IO` is a synonym of some `State# RealWorld -> (# State# RealWorld, a #)`. Bind takes a value of IO as it's first argument, consumes the input `State# RealWorld` value and extracts a value of type `a` - feeds this value the next function in the sequence of binds, returning a new value of type `IO b`, which has a new `State# RealWorld`. Since `bind` enforces a linear sequencing of operations, this has the effect that each `RealWorld` is basically a unique value never used more than once - even though uniqueness types themselves are absent from Haskell.
by VLM | 2025-07-10 17:33:48+00:00
According to the US Census Bureau, the median house age in the usa is 1980. I live in a 1960 house of the type that is supposedly illegal, although every house in my suburb built since then has had building codes and planning regulations forcing walkability. Cars are forced for specialization. I had a 20 mile each way commute to an absolutely horrible neighborhood but a very high paying job. I am in walking distance of some minimum wage manual labor jobs. I can't afford to work at those minimum wage manual labor jobs and live here, and a car is incredibly cheap compared to my higher income. No one can explain why an architectural movement peaking in 1950s-1970s had no effect on socialization for decades until the smartphone era. Multiple entire generations lived in "soulless car filled suburbs" and socialized wildly according to the data in the article... until smartphones... There's an entire mythology built around the idea that any new problem that occurs began coincidentally with the construction of suburbs in the 1950s, even if the new problem didn't appear for the first 75 years of suburban living.
by Merovius | 2025-07-10 17:34:52+00:00
> You need to have something that uses those templates.

Exactly. That is what I said:

> because you need to know the actual type arguments used, regardless of what the constraints might say.

It is because type-checking concept code is NP complete - it is trivial to check that a particular concrete type satisfies constraints, but you can not efficiently prove or disprove that all types which satisfy one constraint also satisfy another. Which you must do to type-check code like that (and give the user a helpful error message such as “this is fundamentally not satisfiable, your constraints are broken”).

And it’s one of the shortcomings of C++ templates that Go was consciously trying to avoid. Go’s generics are intentionally limited so you can only express constraints for which you can efficiently do such proofs.

I described the details a while back: https://blog.merovius.de/posts/2024-01-05_constraining_compl...
by Tadpole9181 | 2025-07-10 17:35:14+00:00
If it not being an actual Nazi that helps people commit violent crimes and brings up unrelated politics is necessary? So all use cases other than astroturfing?

Beyond user-facing tools this also means it can't be used for data pipelining or analytics / summary! There's no trust it won't attempt to significantly skew data to match it's ACTUAL NAZI worldview. Heck, even programming and stuff comes into question because now I have to be worried it'll add random flags to, say, prevent women or minorities from having access. Or it'll intentionally omit accessibility features for being "woke".
by some-guy | 2025-07-10 17:35:25+00:00
All those things are true, but it's such a small part of my workflow at this point that the savings, while nice, aren't nearly as life-changing to my job as my CEO is forcing us to think it is.

Once AI can actually untangle our 14 year old codebase full of hosh-posh code, read every commit message, JIRA ticket, and Slack conversation related to the changes in full context, it's not going to solve a lot of the hard problems at my job.
by refulgentis | 2025-07-10 17:36:11+00:00
> Yes, it's a matmul; many color models just boil down to simple math.

All do. :)

> For example, look at Li and Luo's 2024 "simple color appearance model"[1], which is very similar to OKLab (just matmul!), and created for many of the same reasons (just an approximation!)

I don't understand what this shows me. I don't see anyone in the thread arguing there can only be one color model with one matmul. I feel self-concious I'm missing something, so I thought maybe the implication is this a real scientist working on a real space therefore our haranguing about "actual" perceptual spaces is hair-splitting, as we see a color scientist making an approximation. You also note that it is an approximation, as does the paper, so I don't think that's the case...idk :(

> Like OKLab, it also improves upon CAM16-UCS hue linearity issues in blue. Ironically, Luo was one of the authors who proposed CAM16-UCS in 2017.

What's the ironic part? (my understanding: you read this as a competition, so you find it ironic, in the colloquial sense, that the color space you perceive us advocating for, or that Oklab can replace, was created by someone who made a singular matmul type-space like Oklab in a paper?)

> I'm not yet convinced it is superior to OKLab (you can see my implementation here: [2]).

I appreciate your work and desire here and you have firey curiosity. In practice, color science uses UCS spaces to measure color difference, not render colors. (he uses CAM16-UCS and CAM16 interchangeably as well, it's confusing)

> And I think you might be mis-remembering Ottosson's original blog post; he demonstrates a gradient between white and blue, not blue and yellow.

You're right! That makes a whole lot less obvious that there's something wrong. :( Here, the sin is throwing away the whole science bit and says that's fine, look at this example.

See gradients here. https://m3.material.io/blog/science-of-color-design

Note particularly the black and white one. Gives a great sense of how much of an outlier Oklab is, and you can't fuck around with lightness that much, that's how you measure contrast.
by simonw | 2025-07-10 17:36:21+00:00
Here's the full paper, which has a lot of details missing from the summary linked above: https://metr.org/Early_2025_AI_Experienced_OS_Devs_Study.pdf

My personal theory is that getting a significant productivity boost from LLM assistance and AI tools has a much steeper learning curve than most people expect.

This study had 16 participants, with a mix of previous exposure to AI tools - 56% of them had never used Cursor before, and the study was mainly about Cursor.

They then had those 16 participants work on issues (about 15 each), where each issue was randomly assigned a "you can use AI" v.s. "you can't use AI" rule.

So each developer worked on a mix of AI-tasks and no-AI-tasks during the study.

A quarter of the participants saw increased performance, 3/4 saw reduced performance.

One of the top performers for AI was also someone with the most previous Cursor experience. The paper acknowledges that here:

> However, we see positive speedup for the one developer who has more than 50 hours of Cursor experience, so it's plausible that there is a high skill ceiling for using Cursor, such that developers with significant experience see positive speedup.

My intuition here is that this study mainly demonstrated that the learning curve on AI-assisted development is high enough that asking developers to bake it into their existing workflows reduces their performance while they climb that learing curve.
by narush | 2025-07-10 17:36:33+00:00
Our largest funding was through The Audacious Project -- you can see an announcement here: https://metr.org/blog/2024-10-09-new-support-through-the-aud...

Per our website, “To date, April 2025, we have not accepted compensation from AI companies for the evaluations we have conducted.” You can check out the footnote on this page: https://metr.org/donate
by aakashadesara | 2025-07-10 17:36:38+00:00
Consensus Deep Search is a research agent that produces full literature reviews across 200M academic papers—in under two minutes.

It breaks down complex questions, conducts structured multi-step searches, and returns AI-generated reports with citations, visuals, and evidence mapping.

Key features:

- Structured literature search across 6,000+ scientific domains

- Analyzes and filters 1,000+ papers per query

- Outputs a cited report with intro, methods, results, and discussion

- Visualizes research consensus, key authors, and knowledge gaps

Built to accelerate discovery by turning questions into high-quality answers—fast.
by Jeaye | 2025-07-10 17:37:10+00:00
> There exists a much smaller subset of jank that is capable of compiling itself.

If your fitness test is compiler SLOC, there does indeed exist better designs. However, each of those will sacrifice performance and robustness in favor of that simplicity and concision.

I don't want to implement jank in jank. I don't think jank will ever be self-hosting. Why? Multiple reasons.

Firstly, jank isn't a systems language and in order to perform the tricks necessary for a fast runtime, I need a systems language like C++. I want jank to be the fastest Clojure around and that will require more than just a 5000 line small self-hosted compiler.

Secondly, jank has two audiences. The first audience is existing Clojure devs. A self-hosted jank would work well for them. However, the second, larger, audience is existing native devs. For them, jank needs to have an idiomatic native interface in order to embed it into their programs. The Clojure side of jank is not designed to create C++ APIs; it's designed to consume them. However, the C++ side of jank _is_ a C++ API and is designed to be a library.

Thirdly, jank's seamless interop is unprecedented for a lisp. This requires the bleeding edge (literally unreleased LLVM main, as of writing) of Clang and LLVM in order to be possible. This is necessary both for full JIT capabilities as well as the ability to seamlessly reach into C++ to use any value, function, or type, from jank, even when that requires JIT template instantiation. The typical small compiler approach of compiling to C and using TCC will not allow me to achieve this. Again, different fitness test.

> The current approach is likely going to just bog the author down, dealing with accidental complexity from c++ and llvm especially.

It sounds to me like you're designing another language, not jank. With all of this said, of course jank's design and code could be improved. I'd be able to point out more issues in jank's code than anyone, I'd wager, since I've introduced most of them. But the bulk of your point, of having less C++ and more jank, would lead to a smaller, slower, and less robust language. I will pay the cost of C++ in order to build the language I want.
by sershe | 2025-07-10 17:37:35+00:00
"cannot think of a single success story with PE that has created a successful company that hasn't imploded. I belive most PE funds lose money too. Why anyone would buy a company that a PE fund has gotten its hooks into is beyond me."

It's funny that the narrative where a bunch of generally smart well connected people renowned for their greed set money on fire for decades doesn't make you rethink your priors.

There's actually a fair amount of research.

Pure performance https://www.nber.org/digest/jul12/private-equity-performance

Effects on employment and productivity E.g. https://www.nber.org/digest/feb20/economic-effects-private-e... Notable numbers for me are for public vs private firms. Apparently principal - agent problem is a real thing!

Tangential on how betting your own money is more efficient than other's https://www.nber.org/papers/w13061
by dinfinity | 2025-07-10 17:37:36+00:00
GPs link doesn't even show what was claimed ("The other 3 have needed costly maintenance").

From that link:

"The first of these turbines is scheduled for redeployment in May 2022, with the final turbine to be deployed in March 2023, complete with a retrofitted wet mate connection system, which more than halves the costs of future turbine recoveries and deployments."

"The company’s AR150 turbine was re-deployed last month, after being out of the water for upgrade and maintenance work."

The single long-running turbine can be compared to the upgraded turbines to measure the effect of the upgrades, and it provides the headlines this thread is about. The upgrades themselves are also clearly valuable R&D work.
by Xss3 | 2025-07-10 17:38:08+00:00
That may be but i immediately uninstalled Thunderbird from all my devices upon seeing that its low priority and unassigned.

I wont be using any email client that can break and delete all my emails from local and the server. Why would i? It may be a lottery but it isnt one i want to play.

The fact that they see this as low priority shows theyre morons.

Who would say 'yes please' to an email client that might permanently destroy some of your most important data at random?
by whstl | 2025-07-10 17:38:17+00:00
The day landlords start accepting "integrity" and "elevating the profession" as payment for the rent is the day that engineers will do what you're saying.

The only way to make this kind of thing work is by threatening to send people to jail. Like building-engineers having to report asbestos, or electricians being forced to report code violations and authorities actually following up on it. Of course regulation is like kryptonite for the engineering/HN crowd, so let's keep building shit on thoughts and prayers.
by reverendsteveii | 2025-07-10 17:39:17+00:00
Anyone remember the urinal game? It was a flash game that presented these scenarios. It struck me because I got a really good score despite never having been intentionally taught any of the "rules" of using a wall of urinals w other men. We all just sort of new them. They are, in order of precedence:

1) Keep at least one empty urinal between you and any other men where possible

2) Avoid the urinal closest to the door where possible

3) Avoid the kid's urinal

I've since discovered two other rules:

4) You may speak to other men if you are in the same phase of using the restroom as them. Eg: if you are both at the urinal or if you are both washing your hands

5) Stalls can be used as urinals if and only if all urinals are occupied AND there is no line for stalls. This is a fairly common occurrence in men's rooms
by anonnon | 2025-07-10 17:39:21+00:00
Specifically, it's non-literal strings that are mutable. Implementations of either may allow you to modify the literals, but it's likely to break something due to interning. The Common Lisp standard is clear that destructive literal modification is undefined behavior. I believe it's the same in Smalltalk, and I remember you were admonished to never use the direct modification messages (like at:put: or replaceFrom:to:with:) on strings without copying them first.
Ask HN: What types of posts do you most enjoy on Hacker News?
by FerkiHN | 2025-07-10 17:39:26+00:00
I've been spending a lot of time on HN lately and I’m always fascinated by the range of content here — from deep technical writeups and startup war stories to lightweight tools, philosophical questions, and debugging-at-3am humor.

So I wanted to ask the community:

What kinds of posts do you personally enjoy the most on HN? Do you come here mainly for Show HNs, Ask HNs, in-depth articles, founder stories, tutorials, weird edge cases, or something else?

Are there specific themes, types of tools, or even authors that always catch your attention?

I’m not asking to “game the system” — just genuinely curious what people love seeing here.

Thanks! — FerkiHN
by vinhatson | 2025-07-10 17:39:26+00:00
This report analyzes a historical class of security flaws known as “reflected vulnerabilities,” which were once potent zero-day attack vectors targeting early Windows versions and antivirus software. We examine classic exploitation techniques, such as parser attacks, packet fragmentation, and syscall abuse, which could lead to remote code execution (RCE) or privilege escalation. The objective is educational, demonstrating how modern defenses in Windows 11 and Windows Defender—such as Address Space Layout Randomization (ASLR), Data Execution
by AuryGlenz | 2025-07-10 17:39:40+00:00
We only have a 3 year old and a baby, but my wife and I have already argued a bit about this. She's all in on the sports train - it was a large part of her life growing up for her and her siblings. I, on the other hand, did a lot with my free time as a kid/teen.

I think part of the problem is that for people like her they can't imagine their kids not being in all sorts of sports, but they don't realize just how much the time commitment has ballooned. By the time it's too late they're all in and they're effectively in a sports sunk cost fallacy.
by Jeaye | 2025-07-10 17:39:59+00:00
jank will lean heavily into leiningen, though it will have deps.edn support. I think that the process of doing this is much simpler than whatever Clojure CLI devs are doing these days:

lein new jank hello-world cd hello-world lein run lein test lein package

Going forward, we'll see about a leaner version of lein. Maybe we can fork lein and compile it in jank or maybe we'll need to make our own. For now, default lein will be the recommendation.
by FerkiHN | 2025-07-10 17:40:12+00:00
For me personally, I love those posts where someone shares a small tool they built, especially if it’s written in C, Rust, or even Bash. There’s something inspiring about seeing a minimal, self-contained project that solves a real problem in a clever way.

Also really enjoy “Ask HN” posts where people ask things like “What do you wish more devs knew?” or “What’s something underrated in software engineering?”

Curious to read everyone else’s favorites!
by hoerensagen | 2025-07-10 17:40:41+00:00
Maybe I'm misunderstanding but the Author seems to think that the main conversion losses in electricity generation come from renewables

Edit:

I think this paragraph should be enough to show that it is not advisable to trust the author on anything to do with energy:

>Due to the weight of all this stuff, and the relatively mild heat and scattered light coming from the Sun, solar panels produce no more than 20 Watts for each kg of their mass, even on a sunny day. Meanwhile wind turbines, with their massive concrete bases and tall steel towers, generate a mere 6 Watts for every kg of their weight. (Batteries fare slightly better at 240 W/kg.) For comparison diesel fuel produces 13,000 Watts for every kg of fuel burned. A regular diesel engine weighing 150 kg can thus easily produce 110 kW of power, while the same feat would require 5.5 tons of solar panels directly lit by the Sun at noon.