frontpage.
newsnewestaskshowjobs

Open Source @Github

fp.

Hurried Announcement: Alessandro Masullo GRH

https://math216.wordpress.com/2026/11/20/hurried-announcement-alessandro-masullo-grh/
2069•jasondavies•15h ago•964 comments

Levent Alpöge claims proof of the Generalized Riemann Hypothesis [pdf]

https://alpo.ge/remark.pdf
2642•iamronaldo•19h ago•1823 comments

Inkling 2 Mini

https://thinkingmachines.ai/news/inkling-2-mini/
996•jasondavies•13h ago•185 comments

ClawDOS – An AI coding agent for DOS

http://ricapar.net/ClawDOS/
61•Ricapar•4h ago•20 comments

We promoted developers into architects without informing them

https://manidoraisamy.com/developer-to-architect.html
433•QueensGambit•15h ago•238 comments

NINLIVE: The Nine Inch Nails live archive

https://ninlive.com/
258•CharlesW•11h ago•66 comments

Clojure will affect the way you think about programming (2017)

https://eli.thegreenplace.net/2017/clojure-the-perfect-language-to-expand-your-brain/
94•sammatilda•7h ago•30 comments

Unforced Navier-Stokes Singularity and the Generalized Riemann Hypothesis

https://terrytao.wordpress.com/2026/11/20/unforced-euler-singularity-unforced-navier-stokes-singu...
445•archon1410•16h ago•181 comments

Surprisingly Adorable Insect Portraits

https://amateurphotographer.com/latest/these-astonishing-insect-portraits-reveal-a-hidden-world-y...
36•NordStreamYacht•3h ago•9 comments

Language Models Can Rewrite Their Own Weights

https://arxiv.org/abs/2611.21885
410•lwhsiao•17h ago•119 comments

Ask HN: I have been unemployed for 2y. 15 years of experience, US. What to do?

184•LetThingsBeDiff•10h ago•144 comments

Sir Brian May adds new dimension to Hera asteroid

https://www.esa.int/articles/about-us/directorates/operations/space-safety/hera/sir-brian-may-add...
105•mooreds•10h ago•24 comments

Valkey kills the skiplist, cuts sorted set overhead by up to 43%

https://valkey.io/blog/from-skiplist-to-b+tree/
133•reconditerose•3d ago•47 comments

Fewer slides, more dragons

https://www.breakingchange.blog/p/fewer-slides-more-dragons
29•firloop•2d ago•10 comments

DreamCoder: Coding harness and IDE from the author of Mastering Emacs

https://www.masteringemacs.org/article/announcing-dreamcoder
216•facundo_olano•14h ago•65 comments

Catching Crumbs from the Table [pdf]

https://gwern.net/doc/fiction/science-fiction/2000-chiang.pdf
10•gchamonlive•10h ago•1 comments

Finite-time blow-up for the Navier–Stokes equations

https://github.com/tristanbuckmaster/navier-stokes/
287•trotro•18h ago•91 comments

Nasdaq erases all 2026 gains as AI sell-off dampens Anthropic’s second day

https://www.theguardian.com/business/2026/nov/20/global-stock-markets-slump-anthropic-ipo-ai-sell...
315•cdrnsf•20h ago•587 comments

Engineer's Guide to Career Growth – Advice from My Time at Stripe and Facebook

https://review.firstround.com/the-engineers-guide-to-career-growth-advice-from-my-time-at-stripe-...
3•kurinikku•2d ago•0 comments

Microsoft's SideWinder Strategic Commander was a failed attempt

https://www.rockpapershotgun.com/microsofts-sidewinder-strategic-commander-was-a-failed-attempt-t...
8•Tomte•3d ago•2 comments

3-legged Persian leopard's 150-mile journey highlights Caucasus border hazards

https://news.mongabay.com/short-article/2026/11/three-legged-persian-leopards-150-mile-journey-hi...
22•rguiscard•3d ago•3 comments

Vibecoding an inference chip

https://ankitg.me/blog/vibecoding-inference-chip/
147•ankitvgupta•15h ago•62 comments

Show HN: Tinnitus frequency finder and audio notch tool

https://trynotched.com/find
177•brianrhea•3d ago•115 comments

Slopstrap – Make your site look hastily vibecoded

https://slopstrap.mikelacher.com/
267•mlacher•18h ago•45 comments

Worlds largest beaver dam in Northern Alberta

https://substack.com/@canadianreturnee/note/c-319574497
25•bookofjoe•1d ago•6 comments

Why the Airbus A321XLR often gets stuck climbing for first few hours of flight

https://simpleflying.com/airbus-a321xlr-often-stuck-climbing-1st-few-hours-flight/
118•edward•1w ago•86 comments

Serious cyberattack thought backed by wealthy operators

https://www.ruv.is/english/2026-11-20-serious-cyberattack-thought-backed-by-wealthy-operators-493411
84•Bender•10h ago•43 comments

The stochastic parrots have apparently proved the Riemann Hypothesis

https://scottaaronson.blog/?p=10344
292•stratos123•14h ago•254 comments

Winedroid – run Android apps without Android (WASM demo)

https://winedroid.soham.sh/demo/
146•sohzm•14h ago•42 comments

Backblaze Notice at Collection and Privacy Policy

https://www.backblaze.com/company/policy/privacy
190•meysamazad•6h ago•58 comments
Open in hackernews

Understanding Java's Asynchronous Journey

https://amritpandey.io/understanding-javas-asynchronous-journey/
17•hardasspunk•1y ago

Comments

Neywiny•1y ago
I don't get it. The first example in JS vs Java looks very similar. Now all those other code blocks, they certainly have more going on but idk how that compares to JS. And to answer the questions:

A completable future is something that in the future may complete. I think that's self explanatory. A promise seems equally vague.

Boilerplate looks the same. JS is just a function, Java they put a class around it. Java requires exception handling which is annoying but having fought errors in async JS, I'll take all I can get.

API is eh. Sure. But that's not even shown in this example so I have no idea.

So JS saves like 3 lines? Is that really so much better?

cogman10•1y ago
> A completable future is something that in the future may complete. I think that's self explanatory.

But not the reason for the name :).

It's called "completable" because these futures have a method on them `future.complete("value")`. Before their introduction, there was a `Future` API that java had.

nogridbag•1y ago
Yeah that first example is rather poor. And it uses the word boilerpate to seemingly refer to the stuff unrelated to the async code (class declaration, exception handling, main method).

I don't use Java async much, but I guess if you have a utility method named "setTimeout" than the example can simply be:

    public CompletableFuture<String> fetchData() {
        return setTimeout(() -> "Data Fetched", 10000);
    }

    public void loadData() {
        fetchData().thenAccept(System.out::println);
    }
Which is simpler or equivalent to the JS example.
stevoski•1y ago
The Java 1 example uses lambdas, which were introduced in Java 8.

It’s probably intentional, because it allows showing the Java 1 Thread approach succinctly.

But as long-term Java person, I find it jarring.

philipwhiuk•1y ago
Java's had `var` since Java 10 but apparently the author deliberately ignored that to make the example as wordy as possible.

It's a little tiring to read a Java example with an entry-point (the public-static-void bit) and then a JavaScript example without one.

If you strip that out the original Java is:

  var future = CompletableFuture.supplyAsync(() -> {
        try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Data Fetched";
        });
  future.thenAccept(result -> System.out.println(result));
  System.out.println("Prints first"); // prints before the async result
which is only obtuse due to checked exceptions.

Arguably it's still a different thing you're doing, because it's not scheduling a task on a pool, it's creating a thread which sleeps for 10 seconds.

elric•1y ago
`var` is very unhelpful in situations where the reader might not be entirely familiar with the context, especially when using factory methods.

I don't think the author was trying to make the example "wordy" so much as "clear".

cogman10•1y ago
Also, arguably, the wrong way to do something like this.

The author uses `setTimeout` for javascript. The equivalent for Java is either the `Timer` class or a `ScheduledExecutorService`. Doing a `Thread.sleep` simply isn't how you should approach this.

With that in mind, if you want to use both these things and keep the completable future interface you'd have to do soemthing like this.

    ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
    var future = new CompletableFuture<String>();
    scheduler.schedule(()->future.complete("Data Fetched"), 10, TimeUnit.SECONDS);
    future.thenAccept(result -> System.out.println(result));
    System.out.println("Prints first"); // prints before the async result
    scheduler.shutdown();
AtlasBarfed•1y ago
Does no.js still limit you to a single core/CPU use?

Or as a node successfully been able to start utilizing more cores underneath its JavaScript single thread model. It presents the programmer?

I just remember early node.js from like 15 years ago and the single background task limitation of JavaScript running in a web page.

Cuz you got async code is nice, but what you really wanted to be able to harness in modern CPUs is multi-core

That said, I've been looking for an article like this for a while, although I think there are other associated libraries that also had steps in here. I do think the jvm adopted a lot of those, but I'm not sure if they actually are better than the original extension libraries.

msgilligan•1y ago
I simplified the first example to:

  void main() {
      CompletableFuture<String> future = CompletableFuture.supplyAsync(this::asyncMethod);
      future.thenAccept(result -> IO.println(result));
      IO.println("Prints first");             // prints before the async result
      future.join();                          // Wait for future to complete
  }

  String asyncMethod() {
      try {
          Thread.sleep(10000);
      } catch (InterruptedException e) {
          return "Interrupted";
      }
      return "Data Fetched";
  }
I made the following changes:

1. Move the asynchronous function called in the CompletableFuture to its own method

2. Use Java 25 "instance main method" (see JEP 25: https://openjdk.org/jeps/512)

3. Use Java 25 IO.println() to simplify console output

4. Instead of throwing a fatal exception on interruption, return "Interrupted" immediately.

5. Use future.join() so the main method waits for the future to complete and the "Data fetched" output is printed.

This program can be run directly from source with `java Example.java`. (If you're using Java 24 or a version of Java 25 prior to EA 22, you need to use `java --enable-preview Example.java`)

Here is a modified version of the example that interrupts the thread:

  void main() {
      ExecutorService executor = Executors.newSingleThreadExecutor();
      CompletableFuture<String> future = CompletableFuture.supplyAsync(this::asyncMethod, executor);
      future.thenAccept(result -> IO.println(result));
      IO.println("Prints first");             // prints before the async result
      executor.shutdownNow();
      future.join();                          // Wait for future to complete
  }

  String asyncMethod() {
      try {
          Thread.sleep(10000);
      } catch (InterruptedException e) {
          return "Interrrupted";
      }
      return "Data Fetched";
  }
wpollock•1y ago
In Java 24, new features support educational and demonstration use. You don't need a class to wrap your main method, which also has a simpler signature. To compare JavaScript with Java examples, one should make use of these features.

While the examples may need some work, I enjoyed this post, it nicely shows the evolution of Java concurrency.