8 ms·

Scala gets a lot of hate, but honestly it's a great language. As fast as Java with all the great tooling and ecosystem and compiler/IDE help, as concise as Pyth

Scala gets a lot of hate, but honestly it's a great language. As fast as Java with all the great tooling and ecosystem and compiler/IDE help, as concise as Python and just as usable for fast prototyping and rapid development. How many Python developers would like a 10-20x faster version of the language with better parallelism and concurrency, or Java developers a more concise language better suited for rapid development on top of the huge ecosystem they built their systems on? Scala provides both. There are a bunch of confusing frameworks from Scala's early days that leant it a bad rap, or niche tools that do not fit everyone's use case, but you don't need to use them. I've personally never used Shapeless/Akka/Scalaz/Cats in my entire career and I've gotten by OK. I haven't used SBT for years now. You can use these things if you want, and some people do, but only if you really want to. The Scala community is a Big Tent. Really, every language is converging on Scala: a concise, hybrid OO/FP language with a rich, inferred static type system it uses for bug-catching, tooling support, and performance. Python has got static types and case classes, is getting pattern matching and type-driven compilation. Ruby is getting static types. C# is getting pattern matching and case classes. Java got lambdas, is getting type inference and pattern matching and case classes. Haskell is getting OO-style dot-syntax for records. Go is getting generics. This is a spot in the language design space everyone is trying to get to, and Scala is already there and works great. I use it professionally to implement programming languages, distributed systems, websites, etc. and it really works as well as you'd expect "Superfast Python with static types" or "Java without all the Java-verbosity problems" to work. A true general-purpose high-level language

throwawaygh 6y ago
The one place where Scala really doesn't shine is ML. There's nothing even close to equivalent to PyTorch or Tensorflow. Actually, languages with rich type systems in general seem to really struggle in this space.
- lihaoyi 6y ago
  I'd argue it's just "languages that are not Python struggle in this space". Python has an undoubtably unique ecosystem and gravity around ML, but that's more a unique advantage of Python than a weakness of every other language design
  - MrPowers 6y ago
    Scala does have Spark's ML capabilities. Spark's ML capabilities might not be the best, but they can be run on huge datasets. I'm guessing Dask has better model support, but isn't as scalable as Spark ML.
- currymj 6y ago
  i don't know if it's the type system... Julia has a very rich type system. It's not exactly popular (yet?) but it's certainly very usable and good for numerical work and ML. but they started out with the goal of building a numerical language from day one. I can imagine if you have a completely general purpose language, and want to provide an library that's an interface to low-level numerical libraries, NumPy style, that this task might be more difficult to get right in a language with more complicated types. There seem to be a lot of half-assed unfinished numerical libraries in both Scala and Rust.
  - dwohnitmok 6y ago
    Julia has dynamic types. I think the parent is referring to statically typed languages by "rich type systems" (because dynamic types can often have arbitrary richness since they're basically just another form of runtime errors/exceptions).
    - eigenspace 6y ago
      This depends a lot on what one means by richness I suppose. I'd say that Python, Javascript, mosts lisps that don't have CLOS, etc. are all dynamic languages with very non-rich type systems. Julia's type system (and to a lesser extent Common Lisp's) are very different. They can do a lot of extremely powerful things with their type systems, just not (usually) static type checking (though even that's changing in julia land with JET.jl: https://github.com/aviatesk/JET.jl https://github.com/aviatesk/JET.jl)
      - dwohnitmok 6y ago
        Yeah; I think the distinction with runtime types among dynamic languages is that you can always emulate any other system's dynamic type system with some amount of constant syntactic overhead in any other system. E.g. you could write a CLOS system or Julia's multiple dispatch in Javascript if you wanted. It would just be extremely ugly because you would have to wrap every function and every function call (so as to intercept the native function call and substitute your own). Nonetheless though that's "only" a constant amount of (painful) syntactic noise per call, which means that it is conceivable for a library to provide this functionality. And in fact occasionally libraries will require users to wrap all functions in order to give those functions certain "superpowers." It is of course nicer if it integrates very nicely with the language rather than being full of wrappers everywhere so there is still a lot of value in these runtime type systems being built from the ground-up with certain features in mind. But it's a very different world from static types, where usually if one static type system is missing features of another, no amount of emulation will get you there.
- dwohnitmok 6y ago
  > Actually, languages with rich type systems in general seem to really struggle in this space. I suspect there's two factors. First, I think the current crop of languages with "rich type systems" (I imagine you're thinking of Haskell, Scala, ML and the like?) basically all are in this weird uncanny valley where people get tempted into trying all sorts of cool type tricks to make everything line up, and the type systems are just not _quite_ expressive enough to make it all go well. Most of the time if you just use arrays/your language's usual collection type of numbers (or arrays of arrays... etc.) in those static languages you'll do great. To take it to next level and really model ML faithfully I think you probably will need some version of dependent types and there just aren't really any good implementations of that at the moment. Secondly, a lot of ML is powered by data scientists and statisticians to whom dynamic languages mesh probably better with their own educational background (when was the last time you saw types written out in a stats textbook?). It's really kind of jarring and annoying to have to deal with type systems when you've never done any professional programming before.
  - bgorman 6y ago
    What I have seen in the wild is that in dynamic languages programs end up being "stringly" typed, where a mistyped string in the program results in an error, and programs needlessly rely on array positioning. ML languages that support variants eliminate these unnecessary errors are no cost to runtime performance. What problems have you encountered where a ML system couldn't represent things better than primitive type system? The two things that come to my mind are when the program has to accept arbitrary user input (strings), and writing an extremely expressive program i.e. a lisp interpreter with support for variable argument length functions. Even in these cases, I think the guarantees around the messy sections help with refactoring and my general sanity.
    - dwohnitmok 6y ago
      > What problems have you encountered where a ML system couldn't represent things better than primitive type system? I assume you mean a primitive type system to be a strict subset of an ML type system? So in that case the answer in theory is clearly negative. The problem is more that ML type systems give you more, and fool you into thinking that's enough to try to use the extra bits, when that's not quite enough. > ML languages that support variants eliminate these unnecessary errors are no cost to runtime performance. Closed variants are fantastic. I love them. I miss them every time I use a programming language without them. What I'm talking about is requirements like making sure that all your matrix dimensions line up (you mention variadic arguments, which is another good one if you're trying to follow a lot of mathematical notation). A lot of ML-inspired statically typed languages let you come really close to making all that work. But are just unergonomic enough to make things painful if you really try to statically verify those things.
- MasterDDT 6y ago
  Its because data scientists dont want to learn scala if they don't have to. As a scala developer, I see https://jupyter.org/ https://jupyter.org/ and https://almond.sh/ https://almond.sh/ and cant think of a good reason to use the first one. All the OP's comments would apply.
- forgetfulness 6y ago
  Maybe you can argue that it's been outclassed but Spark's ML toolbox is plenty serviceable for commercial applications and used all over the world. Now that all the APIs are centered around Dataframes, Scala's rich type system has been relegated to providing implicits for the SQL-like DSL, which is a shame, but it's still an eminently Scala-centric tool.
reader_mode 6y ago
Last time I tried scala it took forever to build a relatively small project and the compiler was a heavyweight ram gobbler, which translated to shitty IDE performance as well. Now granted last time I tried Scala was probably 6 years ago, but I honestly doubt they got that language to compile as fast as Go - so I don't really see the Python comparison.
- lihaoyi 6y ago
  Not as fast as Go, but straight compilation is about ~3x faster than 2015, with many improvements around incrementality and IDE speed that make things a lot better. Compilation still isn't "as fast as Go", but has probably approached "acceptable" now in 2021. As one data point, "slow Scala compiles" was the #1 biggest developer complaint at my company when I joined in 2017, and nowadays that complaint doesn't even break the top 10. Scala compiles are not great, but not terrible. A lot about Scala sucked in 2015, and I wouldn't recommend 2015 Scala to anyone, but it's not 2015 any more. 2021 Scala is what I'm talking about
  - harryh 6y ago
    This is super interesting. I was a pretty early adopter of Scala, but our org grew fairly frustrated with in in 2013/14 due to the slow compiler. We invested a ton of effort into building tools to mitigate this problem (effort we'd rather have spent on our actual business). I haven't really touched it beyond tiny toy projects since 2015 though. Really glad to hear that compilation speed has gotten so much better.
    - lihaoyi 6y ago
      Yeah the effort to speed up compilation around Scala 2.12 really took off. You can see it in the compiler benchmarks: https://scala-ci.typesafe.com/grafana/dashboard/db/scala-benchmark?orgId=1&from=now-5y&to=now https://scala-ci.typesafe.com/grafana/dashboard/db/scala-ben... Where the better-files library went from taking ~700ms to compile in 2016 to ~230ms today. Definitely a huge improvement that our developers appreciate every day!
rizpanjwani 6y ago
which framework would you recommend instead of Akka?
- lihaoyi 6y ago
  For most use cases you probably don't need Actors at all. How many systems do you see using Actors in Java/Python/Ruby/PHP/C#? Not many, and they get by just fine. A plain old web server handling HTTP/Thrift/GRPC works for 90% of people, maybe add Futures for parallelism/concurrency and you satisfy 90% of those remaining I use my own Castor actor library for some of my own projects where Actors were really becoming necessary, but at 2 files and 200 lines of code it would be a stretch to call it a framework. If you really think the "Akka-way" is what fits your thinking, go ahead and use it, but it's by no means necessary, and I think most people can get by just fine without it.
- cheriot 6y ago
  It depends on what you're doing. Do you need a framework at all?
dwohnitmok 6y ago
> Haskell is getting OO-style dot-syntax for records. Go is getting generics. I would dispute the former means Haskell is getting OO features (more the case that it's finally realized that having proper records a la Purescript or Elm is pretty important for day-to-day code; records and objects are quite different beasts) and Go getting generics is Go getting functional (or OO features, I don't find Go particularly OO to begin with). > Really, every language is converging on Scala I think this is more symptomatic of Scala trying to do so much to begin with, such that any change any language makes can be tied to some feature Scala has. That being said, I'm really happy to see Scala 3 reining in a lot of those choices (except a new parallel set of whitespace-based syntax... that seemed like a gratuitous cost to one's novelty budget, but time will tell; the community already seems to be warming to it). To those starting out with Scala, lihaoyi's book is a great place to begin! I'll offer one piece of advice (to those beginners, not lihaoyi, who I'm sure needs none of my advice). These days when I talk to people about Scala who've never used it before, I don't like talking about it as a hybrid FP/OO language. I prefer to describe it as an OO language with a lot of syntax sugar and standard library choices to enable emulation of FP on top when desired. It is useful to think of Scala the base language, i.e. what everything desugars to, as an OO language. This is neither good, nor bad. However, I think this realization helps illuminate a lot of strategies around coding in Scala. If your having performance issues, drop down to the desugared OO layer and you'll probably find ways to squeeze out more performance. If you're having a hard time understanding how some of the FP constructs work, step through their desugared OO equivalents (e.g. there aren't really higher-order functions, just an automatic instantiation of FunctionN classes wrapping methods at call sites). Scala 3 has smoothed out a lot of the mismatch so that its most obvious issues are gone (monomorphic functions vs polymorphic methods, weird eta expansion issues, weird subtyping requirements for implicit prioritization, etc.), but I've still found treating OO as the core of Scala to be a general rule of thumb which is useful for new Scala programmers when they come across something they think should work but doesn't. As you work more and more in Scala and that conversion of FP to OO primitives becomes extremely fluid and natural for you, a lot of choices and quirks that Scala has become far easier to explain and a lot easier to deal with.
- lihaoyi 6y ago
  Yeah the line between FP and OO can be argued over. At my work it's pretty OO, with FP used where convenient. People join and start reading/writing Scala with zero experience or training, and it works out OK. At Stripe, I understand their Scala is pure FP, with the first onboarding docs discussing "What is a Monad". I assume they need more training for people who don't have a pure-FP background, but if it works for them who am I to judge. My own personal style is somewhere in between, certainly more FP than at my work, but nowhere near as FP as those who are really into it.
crystaln 6y ago
I used Scala and loved it for a period, back in the Scala Lift days. It’s a beautiful language in many ways, that is also just too bloated with complex features that enable a small amount of brevity at the expense of a huge amount of cognitive overhead. I do kind of miss it though. Right now I’m pretty happy with Typescript...
- lihaoyi 6y ago
  The community as a whole has definitely dialled back use of complex features. If you're used to Lift-era Scala, that was probably the high water mark in terms of "people having fun with confusing features and syntax", and things have gotten steadily more "normal" in the intervening half decade (perhaps approaching a full decade!) To be clear, these complex features are still there, it's just that people tend to not use/overuse/abuse them as much. Just like how Python has metaclasses and import-hook metaprogramming, but it's not something that a typical developer has to deal with on a day-to-day or even year-to-year basis
  - cmollis 6y ago
    love your book.. and your blog. Thanks!!
- dwohnitmok 6y ago
  To add to lihaoyi's sibling comment, some good examples of things people realized were overly complex pits of pain in Scala but were all the rage in the Lift days are the cake pattern and gratuitous use of implicit conversions. Those thankfully have largely disappeared. The design space of programs in Scala is still large (detractors might say too large), but it's way better explored now and there's a much clearer idea of the various tradeoffs among the various approaches as well as how to harmonize one with another.
  - cutler 6y ago
    I think Scala will always suffer from its choice to make implicits so fundamental. Whether abused or not they impede compiler efficiency and complicate code. Implicits were the main reason I dropped Scala a few years ago.
fmakunbound 6y ago
> 10-20x faster version It’s also at least 10-20x more complex a language. Can’t see the appeal to Python users.
FowlSoft2013 6y ago
I agree, I picked up Scala a bit over a year ago and have loved it. I believe there is a happy medium between the functional and OO aspects. Finding this sweet spot is where the language outshines others. Using classes as decomposition components and then using Scala's functional aspects such as immutability and the large offerings of classic functions (map, reduce, fold) give you a powerful and productive language.
- MrPowers 6y ago
  The new libs make Scala way more enjoyable: * os-lib: allows for nice filesystem operations * upickle: allows for sane JSON * utest / munit: sane testing (rather than Scalatest) * scalafmt: great go-like automatic code formatting As long as Scala keeps replicating all the features in other programming languages, it'll have a bright future. It's a really powerful programming language.
cutler 6y ago
I think the space you describe is better served by Kotlin now ie. better Java compatibility, decent FP (even better with Arrow), first-class Spring integration and dominance of the Android platform. That's a lot of value.
- lihaoyi 6y ago
  Yeah I don't disagree. Kotlin is great. I personally think Scala is a better Kotlin than Kotlin is for most use cases, with the exception of Android, but there's a big enough market to support multiple such languages
killtimeatwork 6y ago
> I've personally never used Shapeless/Akka/Scalaz/Cats in my entire career and I've gotten by OK. Everything's great until you join a team which uses it...
cmollis 6y ago
completely agree..scala is a fantastic language. Scala has gotten a lot of hate, for sure Some for good reasons, but much of it is, I think, doesn't really apply anymore. I've been using daily for about 2 years now and it would be difficult to go back to Java at this point, for all of the reasons you stated. For me, it feels most like Swift.. concise but expressive, but with more mature collection and concurrency primitives. I think developers are looking at it more closely now that they're more experienced with functional capabilities in other languages and now can understand all of the type constructions. Granted, most of what I've done is in Spark, but I use it now for other mundane things like os scripting (something I would have used Python for previously). There are some great libraries for it and can't recommend it enough.

throwawaygh 6y ago

The one place where Scala really doesn't shine is ML. There's nothing even close to equivalent to PyTorch or Tensorflow. Actually, languages with rich type systems in general seem to really struggle in this space.

lihaoyi 6y ago
I'd argue it's just "languages that are not Python struggle in this space". Python has an undoubtably unique ecosystem and gravity around ML, but that's more a unique advantage of Python than a weakness of every other language design
- MrPowers 6y ago
  Scala does have Spark's ML capabilities. Spark's ML capabilities might not be the best, but they can be run on huge datasets. I'm guessing Dask has better model support, but isn't as scalable as Spark ML.
currymj 6y ago
i don't know if it's the type system... Julia has a very rich type system. It's not exactly popular (yet?) but it's certainly very usable and good for numerical work and ML. but they started out with the goal of building a numerical language from day one. I can imagine if you have a completely general purpose language, and want to provide an library that's an interface to low-level numerical libraries, NumPy style, that this task might be more difficult to get right in a language with more complicated types. There seem to be a lot of half-assed unfinished numerical libraries in both Scala and Rust.
- dwohnitmok 6y ago
  Julia has dynamic types. I think the parent is referring to statically typed languages by "rich type systems" (because dynamic types can often have arbitrary richness since they're basically just another form of runtime errors/exceptions).
  - eigenspace 6y ago
    This depends a lot on what one means by richness I suppose. I'd say that Python, Javascript, mosts lisps that don't have CLOS, etc. are all dynamic languages with very non-rich type systems. Julia's type system (and to a lesser extent Common Lisp's) are very different. They can do a lot of extremely powerful things with their type systems, just not (usually) static type checking (though even that's changing in julia land with JET.jl: https://github.com/aviatesk/JET.jl https://github.com/aviatesk/JET.jl)
    - dwohnitmok 6y ago
      Yeah; I think the distinction with runtime types among dynamic languages is that you can always emulate any other system's dynamic type system with some amount of constant syntactic overhead in any other system. E.g. you could write a CLOS system or Julia's multiple dispatch in Javascript if you wanted. It would just be extremely ugly because you would have to wrap every function and every function call (so as to intercept the native function call and substitute your own). Nonetheless though that's "only" a constant amount of (painful) syntactic noise per call, which means that it is conceivable for a library to provide this functionality. And in fact occasionally libraries will require users to wrap all functions in order to give those functions certain "superpowers." It is of course nicer if it integrates very nicely with the language rather than being full of wrappers everywhere so there is still a lot of value in these runtime type systems being built from the ground-up with certain features in mind. But it's a very different world from static types, where usually if one static type system is missing features of another, no amount of emulation will get you there.
dwohnitmok 6y ago
> Actually, languages with rich type systems in general seem to really struggle in this space. I suspect there's two factors. First, I think the current crop of languages with "rich type systems" (I imagine you're thinking of Haskell, Scala, ML and the like?) basically all are in this weird uncanny valley where people get tempted into trying all sorts of cool type tricks to make everything line up, and the type systems are just not _quite_ expressive enough to make it all go well. Most of the time if you just use arrays/your language's usual collection type of numbers (or arrays of arrays... etc.) in those static languages you'll do great. To take it to next level and really model ML faithfully I think you probably will need some version of dependent types and there just aren't really any good implementations of that at the moment. Secondly, a lot of ML is powered by data scientists and statisticians to whom dynamic languages mesh probably better with their own educational background (when was the last time you saw types written out in a stats textbook?). It's really kind of jarring and annoying to have to deal with type systems when you've never done any professional programming before.
- bgorman 6y ago
  What I have seen in the wild is that in dynamic languages programs end up being "stringly" typed, where a mistyped string in the program results in an error, and programs needlessly rely on array positioning. ML languages that support variants eliminate these unnecessary errors are no cost to runtime performance. What problems have you encountered where a ML system couldn't represent things better than primitive type system? The two things that come to my mind are when the program has to accept arbitrary user input (strings), and writing an extremely expressive program i.e. a lisp interpreter with support for variable argument length functions. Even in these cases, I think the guarantees around the messy sections help with refactoring and my general sanity.
  - dwohnitmok 6y ago
    > What problems have you encountered where a ML system couldn't represent things better than primitive type system? I assume you mean a primitive type system to be a strict subset of an ML type system? So in that case the answer in theory is clearly negative. The problem is more that ML type systems give you more, and fool you into thinking that's enough to try to use the extra bits, when that's not quite enough. > ML languages that support variants eliminate these unnecessary errors are no cost to runtime performance. Closed variants are fantastic. I love them. I miss them every time I use a programming language without them. What I'm talking about is requirements like making sure that all your matrix dimensions line up (you mention variadic arguments, which is another good one if you're trying to follow a lot of mathematical notation). A lot of ML-inspired statically typed languages let you come really close to making all that work. But are just unergonomic enough to make things painful if you really try to statically verify those things.
MasterDDT 6y ago
Its because data scientists dont want to learn scala if they don't have to. As a scala developer, I see https://jupyter.org/ https://jupyter.org/ and https://almond.sh/ https://almond.sh/ and cant think of a good reason to use the first one. All the OP's comments would apply.
forgetfulness 6y ago
Maybe you can argue that it's been outclassed but Spark's ML toolbox is plenty serviceable for commercial applications and used all over the world. Now that all the APIs are centered around Dataframes, Scala's rich type system has been relegated to providing implicits for the SQL-like DSL, which is a shame, but it's still an eminently Scala-centric tool.

reader_mode 6y ago

Last time I tried scala it took forever to build a relatively small project and the compiler was a heavyweight ram gobbler, which translated to shitty IDE performance as well. Now granted last time I tried Scala was probably 6 years ago, but I honestly doubt they got that language to compile as fast as Go - so I don't really see the Python comparison.

lihaoyi 6y ago
Not as fast as Go, but straight compilation is about ~3x faster than 2015, with many improvements around incrementality and IDE speed that make things a lot better. Compilation still isn't "as fast as Go", but has probably approached "acceptable" now in 2021. As one data point, "slow Scala compiles" was the #1 biggest developer complaint at my company when I joined in 2017, and nowadays that complaint doesn't even break the top 10. Scala compiles are not great, but not terrible. A lot about Scala sucked in 2015, and I wouldn't recommend 2015 Scala to anyone, but it's not 2015 any more. 2021 Scala is what I'm talking about
- harryh 6y ago
  This is super interesting. I was a pretty early adopter of Scala, but our org grew fairly frustrated with in in 2013/14 due to the slow compiler. We invested a ton of effort into building tools to mitigate this problem (effort we'd rather have spent on our actual business). I haven't really touched it beyond tiny toy projects since 2015 though. Really glad to hear that compilation speed has gotten so much better.
  - lihaoyi 6y ago
    Yeah the effort to speed up compilation around Scala 2.12 really took off. You can see it in the compiler benchmarks: https://scala-ci.typesafe.com/grafana/dashboard/db/scala-benchmark?orgId=1&from=now-5y&to=now https://scala-ci.typesafe.com/grafana/dashboard/db/scala-ben... Where the better-files library went from taking ~700ms to compile in 2016 to ~230ms today. Definitely a huge improvement that our developers appreciate every day!

rizpanjwani 6y ago

which framework would you recommend instead of Akka?

lihaoyi 6y ago
For most use cases you probably don't need Actors at all. How many systems do you see using Actors in Java/Python/Ruby/PHP/C#? Not many, and they get by just fine. A plain old web server handling HTTP/Thrift/GRPC works for 90% of people, maybe add Futures for parallelism/concurrency and you satisfy 90% of those remaining I use my own Castor actor library for some of my own projects where Actors were really becoming necessary, but at 2 files and 200 lines of code it would be a stretch to call it a framework. If you really think the "Akka-way" is what fits your thinking, go ahead and use it, but it's by no means necessary, and I think most people can get by just fine without it.
cheriot 6y ago
It depends on what you're doing. Do you need a framework at all?

dwohnitmok 6y ago

> Haskell is getting OO-style dot-syntax for records. Go is getting generics. I would dispute the former means Haskell is getting OO features (more the case that it's finally realized that having proper records a la Purescript or Elm is pretty important for day-to-day code; records and objects are quite different beasts) and Go getting generics is Go getting functional (or OO features, I don't find Go particularly OO to begin with). > Really, every language is converging on Scala I think this is more symptomatic of Scala trying to do so much to begin with, such that any change any language makes can be tied to some feature Scala has. That being said, I'm really happy to see Scala 3 reining in a lot of those choices (except a new parallel set of whitespace-based syntax... that seemed like a gratuitous cost to one's novelty budget, but time will tell; the community already seems to be warming to it). To those starting out with Scala, lihaoyi's book is a great place to begin! I'll offer one piece of advice (to those beginners, not lihaoyi, who I'm sure needs none of my advice). These days when I talk to people about Scala who've never used it before, I don't like talking about it as a hybrid FP/OO language. I prefer to describe it as an OO language with a lot of syntax sugar and standard library choices to enable emulation of FP on top when desired. It is useful to think of Scala the base language, i.e. what everything desugars to, as an OO language. This is neither good, nor bad. However, I think this realization helps illuminate a lot of strategies around coding in Scala. If your having performance issues, drop down to the desugared OO layer and you'll probably find ways to squeeze out more performance. If you're having a hard time understanding how some of the FP constructs work, step through their desugared OO equivalents (e.g. there aren't really higher-order functions, just an automatic instantiation of FunctionN classes wrapping methods at call sites). Scala 3 has smoothed out a lot of the mismatch so that its most obvious issues are gone (monomorphic functions vs polymorphic methods, weird eta expansion issues, weird subtyping requirements for implicit prioritization, etc.), but I've still found treating OO as the core of Scala to be a general rule of thumb which is useful for new Scala programmers when they come across something they think should work but doesn't. As you work more and more in Scala and that conversion of FP to OO primitives becomes extremely fluid and natural for you, a lot of choices and quirks that Scala has become far easier to explain and a lot easier to deal with.

lihaoyi 6y ago
Yeah the line between FP and OO can be argued over. At my work it's pretty OO, with FP used where convenient. People join and start reading/writing Scala with zero experience or training, and it works out OK. At Stripe, I understand their Scala is pure FP, with the first onboarding docs discussing "What is a Monad". I assume they need more training for people who don't have a pure-FP background, but if it works for them who am I to judge. My own personal style is somewhere in between, certainly more FP than at my work, but nowhere near as FP as those who are really into it.

crystaln 6y ago

I used Scala and loved it for a period, back in the Scala Lift days. It’s a beautiful language in many ways, that is also just too bloated with complex features that enable a small amount of brevity at the expense of a huge amount of cognitive overhead. I do kind of miss it though. Right now I’m pretty happy with Typescript...

lihaoyi 6y ago
The community as a whole has definitely dialled back use of complex features. If you're used to Lift-era Scala, that was probably the high water mark in terms of "people having fun with confusing features and syntax", and things have gotten steadily more "normal" in the intervening half decade (perhaps approaching a full decade!) To be clear, these complex features are still there, it's just that people tend to not use/overuse/abuse them as much. Just like how Python has metaclasses and import-hook metaprogramming, but it's not something that a typical developer has to deal with on a day-to-day or even year-to-year basis
- cmollis 6y ago
  love your book.. and your blog. Thanks!!
dwohnitmok 6y ago
To add to lihaoyi's sibling comment, some good examples of things people realized were overly complex pits of pain in Scala but were all the rage in the Lift days are the cake pattern and gratuitous use of implicit conversions. Those thankfully have largely disappeared. The design space of programs in Scala is still large (detractors might say too large), but it's way better explored now and there's a much clearer idea of the various tradeoffs among the various approaches as well as how to harmonize one with another.
- cutler 6y ago
  I think Scala will always suffer from its choice to make implicits so fundamental. Whether abused or not they impede compiler efficiency and complicate code. Implicits were the main reason I dropped Scala a few years ago.

fmakunbound 6y ago

> 10-20x faster version It’s also at least 10-20x more complex a language. Can’t see the appeal to Python users.

FowlSoft2013 6y ago

I agree, I picked up Scala a bit over a year ago and have loved it. I believe there is a happy medium between the functional and OO aspects. Finding this sweet spot is where the language outshines others. Using classes as decomposition components and then using Scala's functional aspects such as immutability and the large offerings of classic functions (map, reduce, fold) give you a powerful and productive language.

MrPowers 6y ago
The new libs make Scala way more enjoyable: * os-lib: allows for nice filesystem operations * upickle: allows for sane JSON * utest / munit: sane testing (rather than Scalatest) * scalafmt: great go-like automatic code formatting As long as Scala keeps replicating all the features in other programming languages, it'll have a bright future. It's a really powerful programming language.

cutler 6y ago

I think the space you describe is better served by Kotlin now ie. better Java compatibility, decent FP (even better with Arrow), first-class Spring integration and dominance of the Android platform. That's a lot of value.

lihaoyi 6y ago
Yeah I don't disagree. Kotlin is great. I personally think Scala is a better Kotlin than Kotlin is for most use cases, with the exception of Android, but there's a big enough market to support multiple such languages

killtimeatwork 6y ago

> I've personally never used Shapeless/Akka/Scalaz/Cats in my entire career and I've gotten by OK. Everything's great until you join a team which uses it...

cmollis 6y ago

completely agree..scala is a fantastic language. Scala has gotten a lot of hate, for sure Some for good reasons, but much of it is, I think, doesn't really apply anymore. I've been using daily for about 2 years now and it would be difficult to go back to Java at this point, for all of the reasons you stated. For me, it feels most like Swift.. concise but expressive, but with more mature collection and concurrency primitives. I think developers are looking at it more closely now that they're more experienced with functional capabilities in other languages and now can understand all of the type constructions. Granted, most of what I've done is in Spark, but I use it now for other mundane things like os scripting (something I would have used Python for previously). There are some great libraries for it and can't recommend it enough.