user1241320

Potentially France could have all imports from US pass by Martinique and they’d save a lot of money

Funny he put like Martinique which is a territory governed by France

Inspired by the Dobble card game, a friend and I built an iOS version where the symbols are emojis! You can customize the difficulty with options like “only green emojis” or other themed sets.

We don’t want to put ads in the game, but we’re exploring ways to add non-free features to make a little money from it. Has anyone done something similar? Any insights or past experiences with monetizing a casual mobile game would be really helpful!

One note from having worked with both that I don’t see mentioned: Golang dependencies are sources you basically pull and compile with your own code. In JVM-land dependencies are precompliled packages (jars). This adds one little step.

> Scala needs a new "official stack"

Maybe so... but so do Python or Javascript. It seems to me some other languages have only one stack (rust: cargo, rustfmt...; the .net world as well). Does it make them better? (honest question). Then again, what's Java official stack?

I'd pick sbt over mvn no doubt. Haven't played with either fury or mill, so can't comment on those (even gradle... I never really used it). But coming from years of Java/Maven I think sbt is way better. Things start complicating a bit if you have lots of plugins or macros probably.

Opposite for me. After years of Scala (which I like) I recently tried to port a few things to Scala 3 and it really feels like some of the wtf-implicit part is gone. We'll still need to make a complete idea about this version 3 though.

Datomic is written in Clojure.

sbt is not perfect but new build tools are coming up lately for Scala (check out lihaoyi/mill and propensive/fury to name) plus people are working with bazel (but i guess that's more for monorepos/very big codebases. my experience (7 years and counting) with sbt is that it's very very good until you need to roll out your own tasks/plugins.

Is this somehow similar to the new Swift Automatic Differentiation feature? https://github.com/tensorflow/swift/blob/master/docs/Automat...

I started using Scala for Play and Akka and I'm currently using Akka[1] in production in many projects.

[1]: http://akka.io/ Akka is the implementation of the Actor Model on the JVM.

I immediately thought of https://github.com/snoyberg/conduit

If I was Lightbend (whose work I use/enjoy/thank for) I think I would put Scala.js inside the Play Framework (as opposed to say Coffeescript)

I, sort of, know the limitations WebAssembly has right now when it comes to JS interop (such as only being able to use functions with numbers as parameters!) but my guess is this is temporary. It'd be curious to see experiments doing something Scala Native -> Emscripten -> JS-land.

Regardless, thanks so much for the work you're doing with Scala.ks (Scala is still my main language and I'm working on removing JS from my toolbox soon).

https://youtu.be/HktWin_LPf4?t=22m31s

My two cents: to me WebAssembly seems like something Scala Native might address, more than Scala.js. Or even better, both project can sort of blend for this purpose as on one hand (SN) addresses LLVM compilation and the other (SJS) is perfect JS interop (not so sure how WebAssembly does that).

There was a small attempt to what you describe: https://github.com/oden-lang/oden

Cool to see also Rust supporting it: https://blog.rust-lang.org/2016/12/22/Rust-1.14.html

Overall I think this is actually good news for people like typelevel[1]... that is people with a strong passion for Scala, a stronger community approach and a slightly different view than Typesafe/Lightbend.

[1]http://typelevel.org/

Try nim*

*http://nim-lang.org/