> distinguish between things that aren't meaningfully distinguishable. Are these semantically the same? Runnable action1 = () -> System.out.println("foo");

> distinguish between things that aren't meaningfully distinguishable. Are these semantically the same? Runnable action1 = () -> System.out.println("foo"); Runnable action2 = () -> System.out.println("bar"); action1.run(); action2.run(); var action3 = runAsync(() -> System.out.println("foo")); var action4 = runAsync(() -> System.out.println("bar")); action3.join(); action4.join(); > You only need to submit if you want to do stuff in parallel and then join (also, there are no extra steps). I'm not comparing parallel to sequential. My point was that we're already doing parallel programming: CompletableFuture<Result> fx = CompletableFuture.supplyAsync(() -> result); CompletableFuture<Result> fy = CompletableFuture.supplyAsync(() -> result); Result x = fx.join(); Result y = fy.join(); Parent doesn't like the existing parallel model. New model looks like: // > plus no need for thread pools anymore. ThreadFactory tf = Thread.builder().virtual().factory(); ExecutorService e = Executors.newUnboundedExecutor(tf); // > No more [...] Completable<Future>, promises et al. Future<Result> fx = e.submit(() -> { ... return result; }); Future<Result> fy = e.submit(() -> { ... return result; }); Result x = fx.get(); Result y = fy.get(); If going from the first to the second is an improvement, I don't understand the excitement. Especially when other languages look like: fx <- async (return 3) fy <- async (return 3) x <- wait fx y <- wait fy