Discord is now Scala’s main chat platform. Please join us at https://discord.com/invite/scala
Safe to say I never got it right
ended up with a platypus
but a platypus not fit for life
I want to try smalltalk
it's basically the "true communism" of OOP according to the fans
Is it recent? what is it about?
have you ever written smalltalk?
The talk is about the tooling gap, which is vast.
yeah it's very interesting
tooling is so important
I find it lousy for plugging in new functionality, not earlier conceived, to relevant parts of an existing design.
Rewiring an entire inter-method dependency graph in a subclass is entirely possible, and terrifying. I can't even get that right the first time I write it, much less when maintaining it.
Basically you need strict LSP but also every dependency of method a on b has to be treated as part of the interface. Then things might "get confusing", but they generally work.
The whole point is that in the superclass, whether it's calling its own
bar or the subclass bar is irrelevant insofar as the superclass can observe.
It is, admittedly, a little too easy to muck it up and make it matter.
But hey, it's easy to muck up recursion and make it infinite, and we still use recursion :)
What is confusing is when foo depends on bar in the superclass, but in the subclass bar depends on foo. Then in a subsubclass, who do you override to get the right behavior?
Some hard things aren't worth mastering if they don't give you enough benefit, though.
A lot of things you have to do as design patterns in Java can be expressed directly in Scala so that slice of the complexity pie isn't relevant anymore.
Etc.
Hi everyone,
I'm trying to perform a database transaction and pass the DB connection around multiple operations that are executed in Futures and my database connection seems to "escape" the scope and close before my Future could finish. I found a bunch of sites (namely Slick's github) discussing the matter and how hard it is to mix transactions and futures/asynchrony, none of which seemed to have a solution. I figured I'd try my luck and see if perhaps one of you ever figured a solution to this. This is my code:
val result: Future[Unit] = db.withTransaction { implicit conn: Connection =>
for {
_ <- step1(product.id, baseFields)(conn) // Future[Unit]
_ <- step2(product, dto)(conn) // Future[Unit]
} yield ()
} // This finishes executing before the future resulting from step1 and step2 is completed
// ... `result` is then eventually handled by the Play FrameworkNote: I'm not using a database abstraction library and I'm using JDBC directly.
That's some very old API, these days slick is using a kind of IO monad I'm prettty sure, but I have my own wrapper around JOOQ and I use a similar API myself and I avoid having to wait for Futures inside a transaction like the plague, because it's holding a connection hostage while something of indeterminate duration is happening; I keep all our database code synchronous and as short as possible and if there's async communication with another service it's done before or after the transaction