I would really enjoy seeing this in Java.
I would really enjoy seeing this in Java.
It's a complex problem with a lot of edge cases and tricky error cases that need to be handled properly, which is where the elegance of the language or the programming paradigm usually goes down the drain.
I'd like to see a fully functional snippet of code that gracefully handles errors in both languages.
Use a Future + \/ monad.
val fNotifications: Future[List[Notification]] = // get notifications from the database
val fPosts: Future[List[Post]] = // get posts from a different database
// If getting notifications fail, log the error and pretend there are no notifications
val safeNotifications = fNotifications rescue { t: Throwable => log.error(t); Future(Nil) }
// If getting posts fails, log the error and try retrieving stale posts from the cached post server
val safePosts = fPosts rescue { t: Throwable =>
log.error(t)
// If the cached post server fails too, just pretend there are no posts
cachedPostsDatabase.getForCurrentUser rescue { t: Throwable => log.error(t); Future(Nil) }
}
val facebookPage: Future[Page] = for {
notifications: List[Notification] <- safeNotifications
posts: List[Post] <- safePosts
} yield {
// Code here executes when both/all outer futures are ready
renderFBPage(notifications, posts)
}
// We can return the future or call more rescues on it or combine it with more futures
is a thumbnail sketch of how you'd implement the facebook timeline in Scala if you were doing so. There are even better abstractions that I've started using (functional reactive programming specifically) but none of them come with the standard library, so I thought that was a bit unfair.I haven't used Qasar specifically but I did use other java extensions that add some scala features for a while (Lombok and the Checkers Framework). The thing is, once you're using those you're effectively using a different language ("extended java") with its own bugs - and the community for that language is much smaller than that for scala.
I'm not sure how this happened, but I just use Guava's ListenableFuture and am happy again.
It's better to leave this to frameworks or libraries that have their own event loop mechanism to handle callbacks.
This is trivial to add (Guava offers it as ListenableFuture), but either way, it's a library concern, not a language one, so I don't think it makes sense to pit Java and Scala over this.
But you're right, I should've said that the syntax (while a vast improvement over previous Java) is not as nice as for/yield, and the lack of higher-kinded types in Java means you can't write functions that handle Futures and other types with similar semantics generically.