frontpage.
newsnewestaskshowjobs

Open Source @Github

fp.

Java4Shell: RCE in OpenJDK when processing Base64

https://calif.io/java4shell/
904•werrett•11h ago•231 comments

GPT‑6.2 Astra and Sol

https://openai.com/index/introducing-gpt-6-2-astra-sol/
1257•jasondavies•15h ago•776 comments

ID.me terms required for IRS sign-in

https://consumerrights.wiki/w/ID.me_terms_required_for_IRS_sign-in
343•DeepLogin•8h ago•147 comments

Quad9's withdrawal from France: A canary in the coal mine

https://blog.cloudflare.com/quad9-withdrawal-from-france/
554•subset•10h ago•173 comments

Google's AI answers reducing search traffic by 40%

https://revscope.co/blog/search-seo-geo-2026/
352•slashdev•8h ago•270 comments

Nvidia stopped disclosing Singapore sales as revenues hit $104B

https://www.ft.com/content/dbde7a30-548c-4f9d-a4be-7898a0c24dcf
523•louiereederson•15h ago•238 comments

Interviewed at a YC startup, found out they used my LinkedIn without permission

https://reddit.com/r/recruitinghell/comments/1xyr6ml/interviewed_at_a_yc_startup_spent_30_hours/
336•throwawaysleep•3h ago•80 comments

Microsoft's ONNX Runtime has disappeared from GitHub

https://github.com/microsoft/onnxruntime
306•nvader•9h ago•66 comments

Alkaline batteries are obsolete – but not for the reason you'd think [video]

https://www.youtube.com/watch?v=I1rlK3BKmyA
7•surprisetalk•2d ago•0 comments

Talos Linux

https://www.siderolabs.com/talos-linux
5•SweetSoftPillow•38m ago•0 comments

Archive Team is archiving the Apple Support Community (closes November 20, 2026)

https://wiki.archiveteam.org/index.php/Apple_Discussions
185•digitaldragon•9h ago•62 comments

Highly classified US national security communications network goes down

https://www.cnn.com/2026/11/17/politics/highly-classified-national-security-communications-networ...
567•monkeydust•17h ago•653 comments

Why Fibonacci?

https://www.evilgeniuslabs.org/why-fibonacci
28•_Microft•3h ago•2 comments

AI is killing All About Berlin

https://nicolasbouliane.com/blog/death-by-ai
246•grey-area•2h ago•203 comments

MAI Code 2 and Code 2 Flash

https://microsoft.ai/news/introducing-mai-code-2-and-mai-code-2-flash/
353•lemonish97•14h ago•153 comments

350 years ago, Ole Rømer discovered that light has a finite speed

https://www.sciencenorway.no/culture-history-history-of-science/350-years-ago-this-man-discovered...
327•dxs•13h ago•99 comments

GoGoGrandparent (YC S16) Is a Front End JavaScript / TypeScript Engineer

https://www.ycombinator.com/companies/gogograndparent/jobs/05woouL-front-end-javascript-typescrip...
1•davidchl•5h ago

jQuery 4.1.0

https://github.com/jquery/jquery/releases/tag/4.1.0
318•petecooper•13h ago•164 comments

Australia's full national topographic library at your fingertips

https://www.ga.gov.au/news/australias-full-national-topographic-library-at-your-fingertips
12•bryanrasmussen•1h ago•6 comments

Phrack 73 Released

https://phrack.org/issues/73/introduction_md
368•notmine1337•14h ago•52 comments

Claude was trained on protein sequences at scale

http://xinmingtu.cn/blog/2026/claude-opus-5-5-protein-sequences/
43•gmays•5h ago•21 comments

Harvard researchers find AI coding agents shifted the bottleneck to code review

https://complexdiscovery.com/harvard-researchers-find-ai-coding-agents-shifted-the-bottleneck-to-...
170•judahmeek•11h ago•228 comments

Solid 2.0

https://www.solidjs.com/blog/solid-2-0-the-long-hold/
303•pier25•13h ago•86 comments

Why is Gemini 4 Carbon taking so long?

https://kernel.dev/blog/why-is-gemini-4-carbon-taking-so-long/
74•deenadz•4h ago•44 comments

Fun with Constrained Programming

https://blog.cmpxchg8b.com/2012/09/fun-with-constrained-programming.html
68•colejohnson66•3d ago•2 comments

Show HN: Unref – A Python dead code finder built on Ruff's parser

https://github.com/Apakottur/unref
20•McAvey•1d ago•0 comments

Cerebras Disaggregated Inference

https://www.cerebras.ai/blog/cerebras-launches-disaggregated-inference
74•emschwartz•7h ago•17 comments

What is the best harness for each model?

https://runta.com/blog/introducing-frontierharness-eval-v1-1/
368•Edward40•18h ago•125 comments

Tencent Hy4 Flash

https://hy.tencent.ai/research/hy4-flash
120•lyra1337•11h ago•21 comments

43k+ new periodic solutions to the three body problem found by volunteers

https://www.threebodyorbits.com/hunt
10•threebodyorbits•3d ago•3 comments
Open in hackernews

Falsify: Hypothesis-Inspired Shrinking for Haskell (2023)

https://www.well-typed.com/blog/2023/04/falsify/
90•birdculture•1y ago

Comments

sshine•1y ago
How does Hedgehog and Hypothesis differ in their shrinking strategies?

The article uses the words "integrated" vs. "internal" shrinking.

> the raison d’être of internal shrinking: it doesn’t matter that we cannot shrink the two generators independently, because we are not shrinking generators! Instead, we just shrink the samples that feed into those generators.

Besides that it seems like falsify has many of the same features like choice of ranges and distributions.

_jackdk_•1y ago
This is the key sentence:

> The key insight of the Hypothesis library is that instead of shrinking generated values, we instead shrink the samples produced by the PRNG.

Hedgehog loses shrink information when you do a monadic bind (Gen a -> (a -> Gen b) -> Gen b). Hypothesis parses values out of the stream of data generated by the PRNG, so when it "binds", you are still just consuming off that stream of random numbers, and you can shrink the stream to shrink the generated values.

Here is a talk that applies the Hypothesis idea to test C++: https://www.youtube.com/watch?v=C6joICx1XMY . Discussion of PBT implementation approaches begins at 6:30.

thesz•1y ago
This is fascinating!

If I understand correctly, they approximate language of inputs of a function to discover minimal (in some sense, like "shortest description length") inputs that violate relations between inputs and outputs of a function under scrutiny.

evertedsphere•1y ago

    newtype Parser a = Parser ([Word] -> (a, [Word])
missing a paren here
moomin•1y ago
I’m honestly completely failing to understand the basic idea here. What does this look like for generating and shrinking random strings,
chriswarbo•1y ago
One straightforward approach would be:

- Generate a random number N for the size (maybe restricted to some Range)

- Generate N `Char` values, by using a random number for each code point.

- Combine those Chars into a string

falsify runs a generator by applying it to an infinite binary tree, with random numbers in the nodes. A generator can either consume a single number (taken from the root node of a tree), or it can run two other generators (one gets run on the left child, the other gets run on the right). Hence the above generator would use the value in the left child as N, then run the "generate N Chars" generator on the right child. The latter generator would run a Char generator on its left child, and an 'N-1 Chars' generator on its right child; and so on.

To shrink, we just run the generator on a tree with smaller numbers. In this case, a smaller number in the left child will cause fewer Chars to be generated; and smaller numbers in the right tree will cause lower code-points to be generated. falsify's tree representation also has a special case for the smallest tree (which returns 0 for its root, and itself for each child).

mjw1007•1y ago
I've found in practice that shrinking to get the "smallest amount of detail" is often unhelpful.

Suppose I have a function which takes four string parameters, and I have a bug which means it crashes if the third is empty.

I'd rather see this in the failure report:

("ldiuhuh!skdfh", "nd#lkgjdflkgdfg", "", "dc9ofugdl ifugidlugfoidufog")

than this:

("", "", "", "")

gwern•1y ago
Really? Your examples seem the opposite. I am left immediately thinking, "hm, is it failing on a '!', some sort of shell issue? Or is it truncating the string on '#', maybe? Or wait, there's a space in the third one, that looks pretty dangerous, as well as noticeably longer so there could be a length issue..." As opposed to the shrunk version where I immediately think, "uh oh: one of them is not handling an empty input correctly." Also, way easier to read, copy-paste, and type.
dullcrisp•1y ago
Their point is that in the unshrunk example the “special” value stands out.

I guess if we were even more clever we could get to something more like (…, …, "", …).

gwern•1y ago
The special value doesn't stand out, though. All three examples I gave were what I thought skimming his comment before my brain caught up to his caveat about an empty third argument. The empty string looked like it was by far the most harmless part... Whereas if they are all empty strings, then by definition the empty string stands out as the most suspicious possible part.
tybug•1y ago
shae•1y ago
I care about the edge between "this value fails, one value over succeeds". I wish shrinking were fast enough to tell me if there are multiple edges between those values.
The Hypothesis explain phase [1][2] does this!

  fails_on_empty_third_arg(
      a = "",  # or any other generated value
      b = "",  # or any other generated value
      c = "",  
      d = "",  # or any other generated value
  )
[1] https://hypothesis.readthedocs.io/en/latest/reference/api.ht...

[2] https://github.com/HypothesisWorks/hypothesis/pull/3555

chriswarbo•1y ago
> As opposed to the shrunk version where I immediately think, "uh oh: one of them is not handling an empty input correctly."

I agree that non-empty strings are worse, but unfortunately `("", "", "", "")` wouldn't only make me think of empty strings; e.g. I'd wonder whether duplicate/equal values are the problem.

chriswarbo•1y ago
> I'd rather see this in the failure report:

> ("ldiuhuh!skdfh", "nd#lkgjdflkgdfg", "", "dc9ofugdl ifugidlugfoidufog")

I would prefer LazySmallcheck's result, which would be the following:

    (_, _, "", _)
Where `_` indicates that part of the input wasn't evaluated.
yorwba•1y ago
A minimal reproducing example cannot guarantee that you'll correctly diagnose a bug just by looking at the example (because multiple potential bugs could cause the same example to fail) but it can guarantee that when you step through the code to understand what's happening, you won't have to deal with huge amounts of irrelevant data.

Maybe an alternative shrinking procedure could directly minimize the number of instructions that need to be executed to hit a failure...

edsko•1y ago
(Author of falsify here.) You are absolutely correct that the empty string isn't always the best counter-example. The goal of shrinking is to shrink to the _simplest_ possible value (this is true for all approaches to shrinking). What constitutes "simple" is very much domain specific. It would certainly be possible to write a generator that would shrink to, say, "foo", as the canonical "simplest" example of a simple string. Indeed, since we are working in a lazy language, you could (with a bit of effort) shrink to `undefined` if the other arguments are not used at all.
mjw1007•1y ago
I agree it can be domain-specific, but I think it's more common than not that empty containers, and the number zero, are corner cases rather than typical values.

So I think it would be a decent quality-of-life improvement to make generators of the sort you suggest easily available, and have the tutorial docs use them from the start.