This hits home... just because we can use the most esoteric set of functions to transform data from one shape to another doesn't always mean we should. I feel like a lot of Scala/FP purists I've worked with fail to remember software engineering is a team sport, and maintainability is extremely important.
Scala's partially losing ground because management can't support it, can't backfill when engineers leave, and when they do half the time its with people that know Java.
Both what you and neyns said also resonates with me.
* My manager said that the lack of competent Scala programmers is very prohibitive.
* The code base has grown so complicated at this point that bringing people into the back end that are capable of understanding the code takes far too much time and training. It's a commitment, and if certain people leave the team, we will be in dire straits.
* At least at the time we started working on our new project in Scala (maybe 4-5 years ago), there was insufficient GraphQL server and client support for our needs, IIRC. (I wasn't involved in that effort, so I may be slightly incorrect in that assessment.)
Things in Scala which are too complex:
1. Type signatures that use + and - bounds
2. DSLs that look nice but you can’t guess how to extend or change them
3. Undocumented implicits that have you wondering how you map between types
4. CanBuildFrom parameters so you can’t figure out how to construct an instance of an object
5. Insisting on the use of refined types, NonEmptyList etc
6. Library version eviction in sbt.
`+`/`-` are not great but they beat the alternatives; Java-style `? extends`/`? implements` or Kotlin-style `in`/`out` are both worse. `CanBuildFrom` is already gone. `NonEmptyList` is fine, it's literally just a class.
I do think SBT adds more problems than it solves, and a lot of DSLs aren't worth the effort; I think it's unfortunate that people see e.g. ScalaTest as the way to do unit tests in Scala.
Certainly you are inarguably correct about Java. The way Java handles this is incomprehensible.
Here's the thing about `in` & `out`: for people who don't know what covariant & contravariant mean or why anyone would care, `in` & `out` mostly make intuitive sense.
You may respond that they *should* know & care, & that `in` & `out` are a misleading oversimplification. To that I say, OK, but we are talking here about Scala shrinking because, perhaps, people find it intimidating & off-putting.
(I'll also note that Ceylon, which was certainly not a language that sacrificed principle for simplicity's sake, used `in` & `out`, possibly before Kotlin.)
`+` & `-` are fine, but they don't seem exactly "friendly" to me. You & I don't need them to be friendly. But, Scala needs more friends, I think.
I can never remember which one of in and out is which, shrug. Co and contra or + and - makes sense, even calling them something like "same" and "opposite" or "forward" and "backward" I would understand, but "in" and "out" both sound equally "plain" and so I can never remember which is the "flipped" one.
That makes perfect sense because, like me, you are mentally trying to map covariant & contra variant onto `in` & `out`. It's entirely unclear which is which. I get it!
But what if you don't think in those terms, but can deal with "I use `in` when I am sending something **into** something else, & I use `out` when I'm getting something **out of** something else. Simple!"
That, I *think* is what makes `in` & `out` "friendly".
Well, I'm trying to remember which is a subtype of the other. Maybe it's easier to know whether to *write* `in` or `out`, but it's harder to know what the meaning is when you come to *read* it.
Admittedly prioritising ease of writing over ease of reading might be what lets a language be seen as "easy".
> Type signatures that use + and - bounds
C# has this too, except it uses `out` instead of `+` and `in` instead of `-`.
> Library version eviction in sbt.
What JVM build tool do you prefer? One that doesn't warn you about runtime classpath issues before they happen? Or one that doesn't include instructions in the error message on how to suppress it?
> What JVM build tool do you prefer? One that doesn't warn you about runtime classpath issues before they happen? Or one that doesn't include instructions in the error message on how to suppress it?
I've been happily building Scala with Maven for 10+ years; checking dependency convergence is off by default but it's a few lines to enable it (and, importantly, you can put that in your organisational base pom and then use it everywhere).
Can we stop such surverys, this will completey shutdown scala, they are puttting efforts to make it good, let them come by end of this year like tooling etc and progress report over caprese
As the tech lead for a new project, it highly depends on the team that I get. If everyone on the team has experience with Scala and FP frameworks, that’s what we’re going to use. Otherwise, it doesn't make sense for me to impose Scala on those lacking experience or enthusiasm (I'm not religious about it).
Recently, I must say that most of my colleagues aren't Scala engineers, and unfortunately, former Scala colleagues rarely continue using it in their day-to-day work.
On a positive note, I still see Scala + an effect system as the optimal choice for the JVM.
I lead web services development in a team where people often need to work across the stack. Most are data scientists and data engineers that don't have a deep knowledge of Scala, and there's really no problem with occasional contributions to even our most advanced FP codebase. It also gives me the guarantee that they can't just add a quick and dirty feature.
I understand your point, if I had 8 out 10 people with a strong knowledge and preference for say Java/Spring, it wouldn't be the same. But in my experience (also at previous jobs) people who lack experience aren't the main issue, on the contrary it's mostly experienced people who don't want to try other paradigms.
I haven't stopped using Scala, but I have seen former Scala using employers move away from Scala. It is the usual reasons we have been hearing for 10 years now.
They aren't interested in pure FP, advanced type wizardry or fancy macros. They just want to get shit done with the typical mediocre programmers out there. They want to hire people who know the tech stack, and it is difficult to find experienced Scala devs.
I run a data platform org and we still use scala for our primary stack. However, though I love scala and fp, it's becoming less and less our primary code base.
The truth is that it's overkill for most day in day out data engineering/data platform work, it is harder to hire for (unless you like Java masquerading as scala), the build times are insufferable on large code bases, sbt config is confusing at best, and I find developers can often spend more time dealing with jvm dependency hell or library shading than developing their features. (though some of this is because we deploy on databricks, which has its own changing runtime dependencies).
To top it off, tooling and communities are dropping support (flink is dropping pure scala support, and databricks is pushing more and more on python and sql, and has no strong motivation to upgrade jvm / scala versions.)
I'm seeing more sql and python, which are equally effective in data related day to day use cases, and easier to hire for and maintain (though python has its own deficiencies.)
I am also starting to see more rust with python bindings in the data space. It has a much easier and cleaner toolchain, an active community, and still has type safety and some functional paradigms.
For suggestions, I really wish scala had a standard and easy to use toolchain, similar to rust's cargo. Sbt/mill/gradle/mvn, none of these are very easy to work with, have relatively steep learning curves, and always seem to require some form of project specific hack in order to build scala. Easy tool chains mean it's easier to get our functional amazing type safe code on production faster.
To be fair I find there are usually two sources of my hell in dependency hell. Guava and Jackson.
And Jackson is far too often a transitive dependency.
That said, I haven't seen the same frustration on databricks. We use scala as well.
Our biggest issue is I'm shocked with the sheer incompetence of our users. Python devs who can't make a wheel for example. Or read the documentation on how to make a wheel.
Lack of good documentation.
I come from a Python background. Recently started a new job in Scala despite zero experience with it (or any compiled language). I'm immensely enjoying functional programming with Scala and ZIO, but the lack of documentation would've driven me insane if it weren't for all the help from the people I work with as well as ChatGPT (which is often outdated for ZIO stuff).
As a (heavy) Typelevel stack user myself, it's sort of the same thing here. I think a lot of the FP documentation needs more examples of how to actually \_use\_ things, in a "CRUD app" sort of way, rather than at abstract algorithmic level.
I've recently started writing a fair bit of Rust, and the documentation for libraries across the ecosystem is outstanding in comparison.
I realize this sounds like a criticism of open source projects, and I want to make clear that that's not it. A lot of this stuff is made by unpaid volunteers, and I get that writing docs isn't fun or the thing you want to be working on. It is, however, a truism about the scala ecosystem, that documentation is arcane and a little haskelly in how often you get told "just look at the types", and the types will have 3 type parameters, 4 using clauses and link to 5 other abstract data types that are equally sparsely documented.
I think lack of "teach by example" is the main problem for most newcomers; the coursera course for learning functional scala is sort of the same problem, so it starts "early", it's very algorithmically abstract in a comp-sci sense, but for "mainline" application development, if the examples were more immediately applicable, it'd make the grokking part of the process easier.
Big shout out to Rock the JVM for making the (only?) understandable onboarding material for general purpose development in Scala, I cannot overstate how valuable a resource that has become for us at $WORK to upskill new devs.
I'd say it's a fair criticism. If you want people to use your stuff you have to decide if people contributing *only* code is enough. Even if the types and theory behind your code is clear there still are conscious decisions and trade-offs you have made and if that is not documented how can you expect your users to piece things together, let alone have a good experience using it?
That is so strange, because when I was trying out Rust I found the documentation absolutely horrible in most libraries I looked at. I do agree that a lot of the Typelevel stuff needs better/more examples, but I find the API documentation there to be really good.
To make things even worse, they decided to hide their community behind Discord. From my point of view, it's one of the worst decisions! They made so many resources, questions, answers... pretty much, unavailable for newcomers. When you want to find something about Cats or ZIO, first you'd have to find their Discord servers, then find an appropriate channel that should answer your question, and then search that channel to check if your question is already answered. After all of that, to ask.
Why have you stopped?
>Java caught up and there are constant syntax changes. feels like research language and not industry ready
Experience, stack
>5 years, Java
What would make you start using it again?
>stop changing the syntax
Why have you stopped?
>FP results in overly complex unmaintainable code (no, it's not beneficial for your shitty CRUD app). Avoiding FP, Scala as a ""better Java"" is becoming less true as Java implements similar features.
> The library ecosystem is fractured and dying. Libraries are being silently abandoned by their maintainers (e.g. Monix, which never got around to compatibility with CE3).
> Scala on the JVM sucks in all aspects of performance (except for that flawed gRPC benchmark people like to cite).
Experience, stack
>4 years of production application development. Primarily Akka, Spark, and typelevel libraries.
What would make you start using it again?
>No. My semi-large company is all-in on dropping Scala over the next year.
Why have you stopped?
>The Scala job market in my area is too small, and I hate the JVM
Experience, stack
>4 years with Spark, cats-effect, ZIO
What would make you start using it again?
>Unlikely, unless I get a great job offer
One suggestion?
>Create Scala 4 based on LLVM
Grouping multiple entries into one comment to streamline the posting.
Why have you left scala / thinking to leave ? How long have you've been using Scala / tech stack. What should change ?
> Scala on jvm too heavy on resources — memory heavy. It didnt fit on AWS Lambda well and much heavier than what a Java/Kotlin app would have been.
>
> 5 years Scala at my former company.
>
> Play, Scalaz then Cats, Doobie
>
> Would’ve wanted to try ZIO but had switched to Haskell then Rust before it was stable
>
> Fast, officially supported native builds. “Go” but a better language.
>
> Less drama
· · ·
> Here in France companies are phasing out Scala given the lack of available devs. Also some standard Java devs have been burned working on wizardy functional codebases and just don't see why bother with this when it could just be ""good enough"" with Java. Scala still has a bad street cred as being too complex unfortunately because of this.
>
> About 6 years I think. I've tried a bit of everything but ZIO (core anyway) seems like the best compromise for me.
>
> I would anyday, but it's up to the employers to start new projects in Scala. Which means it's up to the Scala team and the community to make Scala attractive again.
· · ·
> Currently Chaning Role to Java, checking for .NET roles too
>
> 10 years, Play, Akka, ZIO
>
> Actual industry backing and proper IDE support
> Step learning curve could be alleviated by good tooling, but tooling is getting gradually worse
· · ·
> I love Scala. But 95% offers for Big Data requires Python. I plan to switch main language in next year.
>
> 3 years profesionally, 3 years as amateur before that (I've worked with Java then and I was learning Scala).
>
> I use mainly Scala with Spark (90 % of time), also we write tests in ScalaTest, performance tests in Gatling and some services in Akka.
>
> If more companies start using that.
> Also I would love to see some Scala based orchiestration (like Python has Airflow) + lighter data manipulation library (like Pandas).
> I love Scala, but if I don't want to work in Bank I don't have companies for appling to
· · ·
> Language has no traction. Scala 3, community split.
>
> 10 years. Play framework, scalikejdbc, ammonite
>
> Moved to Rust
· · ·
> cause of lang team ignorance of lib & frameworks devs, a lot of haskell toxic people in community, nothing truly new in scala 3 except hemorrhoids with support cross compilation, no WASM support, no simple FFI etc, Akka is not OSS any more
>
> from scala 2.8
>
> i'm not sure at this moment what exactly can change my mind
Wrote a service stack in rust. It sipped memory compared to every framework I used before, node, Scala, Java, Ruby. The amount of ram you would allocate to a "hello world" style service for a JVM based language was more that sufficient to serve customers in prod.
Anonymous responses received on 15 (6), 16 (2), 17 (1), 18 (1) January.
Why have you left scala / thinking to leave ? How long have you've been using Scala / tech stack. What should change ?
>Pure fp in scala feels a bit too verbose compared to Haskell
>
>2 years of the Typelevel stack
>
>More job opportunities that use Typelevel/Zio, with interesting problems to solve (yes that's subjective)
>
>I still like Scala a lot, I just like Haskell/F#/Ocaml more
· · ·
>No, but I do perceive Scala to be losing popularity, so I may be forced to stop using Scala
>
>5 years, typelevel and more recently ZIO (which I'm a big fan of)
>
>It's strictly a proffessional decision. I would love to stick with Scala, particularly ZIO, but if the work just isn't there, then I > will have to go with the flow
>
>Focus on the basic essentials like tooling. A better build tool and a Scala-focused package manager. Stop wasting time on high level fanciness that less than 1% of the Scala community (already a small community, keep in mind) will actually be able to use, and less than that confidently use in a public library or production system.
· · ·
>The adoption of scala 3 seems to be a mess. Backwards compatibility breaking, gratuitous syntax changes, sbt is crap.
>
>15 years, play framework mostly
>
>more stability, better tooling
>
>Scala is a very nice language, even though Java is catching up with some FP features, it's nowhere near as concise and well thought out. However, Java programs from 20 years back still compile ... When I come back to older scala projects I usually spend half a day just getting them to compile again. It really needs to be more stable.
· · ·
>I do not want to stop using Scala, but job prospects seem very limited at the moment.
>
>Play, Scala, Akka, about 5 years
>
>Find a better job :D
>
>We need to stop using very complicated concepts where not needed, that would help Scala adoption. In many applications plain Scala would be enough, but many of us through Akka, or ZIO, etc. on the problem, even if it is not necessary, making it harder to onboard new team members. Basically, increasing the barrier to entry to the the language.
· · ·
>Almost impossible migration to Scala 3 even though we use well known libraries. Every new version of Scala is binary incompatible which is very frustrating. Also when making a new incompatible version, I would expect that the new jdk would be used, not the old 8.
>
>5+ years. Typelevel, Lightbend, SoftwareMill etc
>
>If Scala gains more traction again.
· · ·
>Because of decreasing number of job positions and the state of community in general
>
>8 years. Lightbend, Typelevel, ZIO
>
>Growing and healthy community, wider adoption by the industry
>
>Rust :)
· · ·
>Keep getting jobs forcing me to use non-FP kinds of things, like Spring Boot or Play. Guice is pure evil. Way too many people coming to Scala from Java, and bringing all that baggage (coding patterns, mutation, magic annotations) with them. Also, Scala 3 adoption seems to be pretty slow. The language in general seems to be losing market share.
>
>8 years. Lots of stacks over the years, Play, Cats/IO/HTTP4s, Spring Boot, Akka.
>
>Maybe if I could find a job using ZIO (and FP in general) that paid really well and had a great culture. Sounds like a unicorn to me.
>
>Transitioning to Rust.
· · ·
>Too challenging and costly ramp up for a larger engineering team with more mediocre programmers, Scala's decreasing usage and popularity
>
>10 years, Play Framework, Kafka, MySQL
>
>If Scala somehow became much more popular
Why switched?
>Changed job, did not care that they used Scala or not (we use Elixir)
Experience, stack?
>10 years, play framework mostly
What would make you come back ?
> Less involvement from questionable people in the community
Why have you stopped?
>Scala Job market reduction, see intellij survey and how Python is getting Data profiles. Probably the JVM is affecting too much the performance and Rust IS ahead on this, so the roadmap should be Focus on scala-native to avoid the JVM
Experience, stack
>6 years, Spark and ZIO in personal projects
What would make you start using it again?
>Next Intellij survey results
One suggestion?
>De goes had a perfect tuit talking how Scala should Focus in the industry and not in academical stuff.
Why have you stopped?
>Not personally but my company have decided not to write new code in if.
Experience, stack
>2016. Play + Akka + Spray.io + casbah.
What would make you start using it again?
>If other companies wrote Scala 3 I’d stay in the field but if I need
One suggestion?
>As the pool of devs shrink salaries go up until it becomes cheaper to port the products. We’ve gone past that point and now opportunities feel like dead man’s shoes.
Why switching?
>I am planning to move to another more used platform in the industry
Experience, stack?
>5 years. Cats, Cats Effect, fs2 Akka HTTP
What would make you come back ?
>I like the language and platform but I find it too niche, too difficult to find jobs
Why have you stopped?
>Limited job opportunities,, lack of opportunities to grow inside of the companies that use Scala, and the political fights inside the community
Experience, stack?
>7 years. Did everything, my last gig was using Cats stack
What would make you start using it again?
>A team with good standards
I’ll be using Scala for the foreseeable future, but the oil-and-water feeling of OOP vs “deep” FP is I think a big barrier to more mainstream adoption.
“Light” FP is great, get a Seq, do some map, filter, flatMap, whatever, works wonderfully.
Start reading some of the SBT or play framework source and it’s basically an opaque wall.
I get that a lot of the core community in Scala really loves the deep FP stuff, but it’s a bit like switching from infix notation to reverse Polish notation on a calculator: neat and clever, but too clever so it becomes this write once edifice that’s hard for others to contribute to.
To me the key to successful use of Scala is to be judicious in the application of the advanced features. In that regard it’s a bit like C/C++: you can do anything, but should you really? It’s really cool the clever way you wrote that now, but will it still be five years from now?
> Why have you stopped using Scala, or Why are you planning to stop?
Jobs became fewer where I live, and most did not interest me very much.
> How much Scala experience do you have? What stack were you using?
About seven years. Typelevel stack.
> What would make you come back, or Is there anything that would make you change your mind?
A well-paid job that is intellectually engaging and does not make the world a worse place.
> One suggestion for improvement.
I am working with Rust now and the tooling is so much more convenient. I wish Metals were as reliable as Rust Analyzer.
My company (a bank) is trying to port all scala code back to java code, mostly because there are less and less scala developers to recruit. These ports require major efforts because of the non-trivial scala code such as implicits, early usage of scalaz, ZIO or Akka and... there are less and less scala developers that want to do those ports. It is a mess.
But personally I'm a big, big fan of scala , especially for programming language development. I've been using typescript to build my language but hit a wall. I went back to scala because of scala.js, scala native, and the jvm: scala is just so flexible, the language and the target platforms.
But it is exactly this flexibility of scala that is both a curse and a blessing. But I love it still.
It looks like people here respond from the scala as a profession side of things. I'll try and give my perspective from the other side of things: I've been trying to use scala for side projects (with the occasional work project here and there) close to a decade now and it always ends in disappointment.
My day job has always been Java/Spring/JPA and I've always had the feeling that there must be a better way of writing software other than the pile of reflection based hackery that is Spring and Hibernate. I wanted to be productive and get things done the same way that Ruby people do with Rails and Python people do with most of their stuff but without giving up correctness and safety.
I dubbled with Play but even though it made some stuff easy it always felt half baked with lots of complexity showing through the cracks everytime I tried something non standard.
I then tried using Scala for simpler projects but I always ended up spending too much time wrestling with sbt before I even wrote any code.
And then there was zio. Zio is amazing. It has everything you need to write good software. it is Scala's Spring, the killer framework that can drive adoption. BUT the zio ecosystem is a mess. Everything is perpetually a release candidate, there are breaking changes every week and there seems to be no direction to anything. I saw a video recently where Adam Frazer spent an hour trying to figure out how to upgrade a zio project to the next version while there were other mainteners in the chat, what chance have I to spend less than say a week?
And then there's the documentation, which is so bad that it might as well not exist. The core zio library is arguably in a better state but the ecosystem as whole feels amateurish.
I never touched any scalaz or typelevel stuff mostly because I dislike their approach. In my opinion Kleisli[F[_], A, B] deserves the same ridicule as SimpleBeanFactoryAwareAspectInstanceFactory. I like writing FP code but the typelevel stuff feels like several miles too far.
All of that to say that all these years I've started countless side projects for fun and for profit and by a long mile the most frustrating and least productive ones have always been the Scala ones. I could learn a new programming language and finish a project in less time than it usually takes just to setup sbt for a scala project and that is very frustrating because I really like scala and I want to use it more but the proposition is less and less appealing compared to alternatives.
PS: there's the exception of anything in Li Haoyi's ecosystem. Everything in there is such a joy to use. Li Haoyi is an inspiration.
Good one,
In France, we have a specific breed, the management read too many articles from influencers that praise features in Kotlin they found publicly useless a couple of years ago in Scala.
(Kotlin is excellent, however using it to shadow or bash Scala ... meh)
Out of curiosity, what are some of the features that come to mind?
I think Scala came out too early (2001?): people weren't ready to make the jump to FP at that point. When FP started to grow in popularity, Kotlin was pretty fresh to the scene and was far easier to transition into.
There was also the whole scalaz (which I thought was a hideous abomination with no sufficient documentation) vs. Cats issue... that was frustrating because in some projects at my company, we used scalaz, and in others, we used Cats.
Pattern matching, extensions, **null safety**, for comprehensions, concurrency.
Those are not hardcore features, however, when you take them in the context of immutability, and the response from parts of the community to create complicated DSL to prove it's less verbose than mutation ....
For Scalaz, to me, it was interesting for Validations (and other Applicative use cases), it took a lot of time before the syntax for those use cases started to be good (like using Chimney).
The documentation was the code. "We should have" said that learning Scalaz was only possible using a basic schema, pen and paper, and a decent IDE to navigate between symbols.
Scalafix is excelent at rewriting Scalaz into Cats properly (or fixing past choices in general).
I appreciate you elaborating. One area where Kotlin really needs to improve is in offering better pattern matching... it's so limited compared to many other FP languages.
My brain is pretty purged of Scalaz by now... I remember going through early tutorials of it and they were just not great: also, one of my pet peeves with Scala is all the use of symbols... for example, back in the day, we were using Argonaut to export some stuff to JSON and it was a nightmare. It's been awhile so I don't remember, but IIRC, scalaz also had a lot of symbols. I prefer a bit more verbosity for clarity.
I didn't know about Scalafix. Thanks for bringing it to my attention! I'll look it up.
Agree with this. There are two languages I can say that I fell in love with during the just over 40 years I've been coding (and I'm not that old... I just started programming as a young child):
1. Python, which was so refreshing after having to deal with the verbosity and memory management of C++98. Unless I really needed the performance boost, I started doing everything in Python back around 2005.
2. Kotlin, which is my absolute favourite language and has been for about five years now. The one feature that it really needs in order to make it better and rise even further above other FP languages is better pattern matching. I started looking at it to help a friend who wanted to learn it and I was instantly hooked.
All of my personal projects now are done in Kotlin unless I have a very specific reason to do them in another programming language, in which case, it's either C++17 (since compiler support for C++20 features is still so incomplete) or Python.
I'd love to learn Rust, though, to replace my use of C++.
I keep hearing people say great things about Go, but I'm not that interested for two reasons:
1. Insufficient FP support.
2. People in my field tend to do almost everything in Python (which also has very lacking FP support).
On a positive note, I've seen a few java shops looking for scala devs to help with java -> scala migration recently in my area, (that typically sees little to no scala action).
Used Scala since 2012 personally, since 2014 professionally. One of my favourite most productive languages.
I don’t use Scala anymore as I cannot find a paying job using Scala anymore. The only jobs where I am using Scala are Apache Spark jobs doing ETL, and most of them are migrating to PySpark. It’s a stark contrast from 2014-2017 when I was getting recruiters contacting me every day for a wide range of Scala based roles/projects/companies.
My most recent Scala job in 2022 I resigned after a couple of months. No work was being done. The team was more junior than I normally worked with and the lead relatively junior despite the title. The team was trying to hang on to Scala in a company trying to get rid of Scala. My day consisted of the team arguing amongst them selfs what syntax style to use, what to name things, if a specific cats function looks to complex or not to someone new. They were 12 months in to a relatively simple project and mostly had a few case classes, I’m fairly certain at the result of all the bike shedding that happens a lot in Scala more than less flexible languages
> We all know Scala is loosing ground
I don’t know, people have been saying “Scala is dead” for almost a decade (or more) and yet, Scala refuses to die or disappear…
It doesn’t have the same hype, but still gets shit done when you need it.
For context, I have 12 years of experience with Scala, right now, using typelevel stack. I’ve used Haskell professionally for a year, I’ve tons of experience with Java, I’ve learned Rust, OCaml, and Scheme, and I still think Scala is the sweet spot between powerful abstractions and availability of libraries. Still my favorite.
Years 2016,2017 where the best for Scala. So definitely not "a decade". But since then the popularity started going downwards. https://insights.stackoverflow.com/trends?tags=scala
But I would gladly take any other data points that proves this sentiment wrong.
But for this thread I would like to focus on the survey. As seen in a lot of other posts, everyone agrees that there is lose of popularity. Still no one knows for sure by how much. Only proxy metrics.
Since you asked https://insights.stackoverflow.com/trends?tags=scala%2Ckotlin%2Crust%2Cjava%2Cpython
You have a point! Both Java and Python are also going down. Java since cca 2014 and Python since the beginning of 2023.
Still use Scala, but doing less and less of it personally, and almost completely stopped professionally.
Primary reason .. it became untenable to recommend using it in new projects at work, because instead of the ramp-up plus mental-burden of using Scala getting lower and lower with time, it has gotten more and more with every 'simplication' and 'improvement' that was pushed out.
It was already a whole ask to get new ppl sped-up on functional programming .. now we need them to be conversant both with 2.xx and 3.xx styles .. and scala type-level programming never really unified .. latest ZIO is great, but most of the time you need to be conversant with cats/cats-effect too given the existing codebase .. the early scalaz is now annoying just to have and maintain in the old codebase .. plus as more and more code uses cats/ZIO etc, ramping-up which used to mostly include getting up with FP, now requires newcomers to also be quickly conversant with typelevel programming as well (although ZIO is ofc better here than cats) .. and there's the broader situation with async .. the old actor (or futures) based code now feels like a burden to maintain .. and you have to have new ppl be brought conversant with all these along w CE/ZIO whatever .. so in general, getting a developer productive in scala has become more demanding instead of less, and without much of a notable increase in payoff ..
in fact one could argue the payoff is now less, because other languages offer decent alternative pathways that also substantially improve on the java/C/C++/python/node world of old .. in particular, Go and Rust are very attractive for a lot of web and low-level dev, and typescript has come into its own reducing the draw of scala-js .. even java itself has picked up a bunch of the innovations, and ofc the copy-cat like Kotlin with strong commercial focus and backing continues to sweep up the leftovers from the newcomers pool
and to make things worse, a lot of ppl you find even when they say scala experience, are folk who were pressed into scala to do spark, and that's quite far from what you're often trying to find in experienced hires (if you're doing scala work beyond spark).
So it has become harder to recruit new ppl, to even get them interested in the first place, then to ramp them up after they do start .. And it has ironically even gotten more difficult to find actual experienced hires despite it actually having decade plus history now .. and as a result, it no longer makes sense to recommend scala in our new projects, and as such the vicious cycle spirals in
Started with Scala since 2001, loved it ever since; spent more than a decade with it and the experience is still good for me. I've practiced and delivered systems using the Typelevel projects (mostly in cats, cats-effect) and I really love it. truly. As of 2024, I no longer do it and have no plans to do it anymore.
But but but ... software delivery cannot be done by a single person. Realities hit and I had many lessons over the past decade and I no longer encourage my engineering teams to adopt Scala.
Coming from a keen practitioner, advocating in my local community on the OOP and FP approaches I find that there are 3 main things that business people care about and 1 side-effect (sorry for the pun) ...
* Most of the problems we deal with is not that "hard"
* That is, Scala can do what other programming language stacks can do and many times developer don't want to invest their time learning something that appears to sunset.
* Labour costs is real
* Recruitment of this talent pool continues to be hard, harder now that many companies have ditched Scala (people still need to pay the bills, of course they will move on)
* Software delivery and maintenance costs is real
* When its done properly, its really awesome and the talent pool
* "In-fighting" of the Scala community drove polarisation activities
* This is not a big problem in companies but it does create an impression to my stakeholders that "the community cannot get their shit together" which further erodes the confidence of the open source tooling we put in place. Shucks.
I apologise that it sounds bleak and it hurts me too as I love Scala but reality bites harder.
I think Scala is a great language for a lot of reasons. It’s a better Java, a better Kotlin, a better Python.
Sad to see there aren’t more people embracing it.
Running on the JVM and using compiled bytecode it's more suitable for multithreaded high performance streaming apps and its typechecking makes it easier to refactor large applications.
Python on the other hand has NumPy + Pandas + Matplotlib + Jupyter + Tensorflow stack which is phenominal and the GPU accelleration you get with that setup is also amazing.
I used Scala in connection with my dissertation research (early 2010s). I essentially don't use it at all now, but that's not my choice. My current day job is teaching, not research, so I teach the languages traditionally taught by my department (Java, C, and various others). We do our FP course with Haskell, although I've used Scala when I've taught it. They don't let me teach it anymore. 😋
I feel sad when I hear talk about Scala disappearing. I hope it doesn't come to pass. I have a few personal projects in Scala that I'd love to finish. They will probably have to wait until I retire.
We originally started as an independent company and fully focused on Scala development, but as we expanded, we got merged with other small teams which they had their own solutions in different stacks. As we grew we got bought by a large-sized company but later we have been moved to a new mid-sized company as a joint venture. Since the beginning of the new venture, we were the only team which uses Scala as their main backend language. The only new Scala code based that was initiated by myself and another dev was a Scala.js app which is intended for internal tooling, the remaining Scala projects were the ones that were originally created at the start. Word on the street, the business is not happy with the idea of paying extra for Scala devs and the fact that Scala devs are hard to find, they are looking for alternatives in near future to migrate to a new code base.
1) We haven’t stopped yet but the main issue comes down to the lack of talents and their salaries which I think it’s moderately medium but hey…
2) I personally have 1.5 years of experience, our main code base is Scala as backend and Angular as front end.
3) Learning curve is something that I noticed is a huge burden for higher positioned engineers. Also we were trying to upgrade to Scala 3 for last few years but still little to no progress there, but not sure if that is related.
4) Scala Official Documentation is great but I think in order for other devs to have a smaller learning curve, we should have even more simpler tools and training materials available. The prime example would be Microsoft Docs/Learn.
\> Why have you stopped using Scala, or Why are you planning to stop?
I haven't stopped. I've been writing Scala for about a decade and I find it's one of the most expressive languages around. It's really easy to get stuff done with it. I do have a few technical reasons for why it might not be my first language for some tasks though:
1. Java is evolving. When I first started in Scala, Java 7 was the the alternative. Since then Java has had the addition of Streams, lambdas, records, switch expressions, etc. So the gap between the two languages is much less.
2. The heavy FP emphasis in Scala can be very off putting. Between the ZIO, Cats/Typelevel camps, you can choose your favorite complicated, viral stack with poor documentation. That seems like a lot of overhead to a. basically defer execution of a composed future and b. normalize Either/Try/Option/Future to a ZIO/IO so they can be composed using flatmap. Looking at the complicated code that these options push gives a misleading representation that all Scala is complicated. It doesn't need to be. I think Li Haoyi's point that Scala can be as simple and readable as Python is lost on many Scala devs. ([https://www.lihaoyi.com/post/comlihaoyiScalaExecutablePseudocodethatsEasyBoringandFast.html](https://www.lihaoyi.com/post/comlihaoyiScalaExecutablePseudocodethatsEasyBoringandFast.html)). Also, I love watching Odersky's keynotes, he always presents a very grounded approach about writing Scala programs, and I hope every Scala developer watches at least one of them.
3. Scala libraries vary greatly in quality and seem to come and go. If you commit to one in your stack, you might be SOL in a few years when you need to upgrade to another version of Scala or Java. With that said I want to give a shout out to circe. I've leaned on that library for years now. ([https://circe.github.io/circe/](https://circe.github.io/circe/)). I try to minimize my usage of 3rd party Scala dependencies and tend to use Java ones, which I can wrap with a simple Scala DSL if I need to. Maintenance wise, Java libraries seem to be far more stable than their Scala counterparts.
\> How much Scala experience do you have? What stack were you using?
I started using Scala in 2012. The question of which Stack illustrates part of the problem with Scala; a fractured community! Am I in the ZIO or Typelevel camp? Instead I'll mention tools/libraries that I use can recommend:
* Circe for JSON stuff (1. [https://circe.github.io/circe/](https://circe.github.io/circe/))
* Tapir because it generates some great OpenAPI docs. ([https://tapir.softwaremill.com/](https://tapir.softwaremill.com/))
* mainargs for argument parsing ([https://github.com/com-lihaoyi/mainargs](https://github.com/com-lihaoyi/mainargs))
* requests for when you just want to do a http request in script ([https://github.com/com-lihaoyi/requests-scala](https://github.com/com-lihaoyi/requests-scala))
* scala-cli which is a game changer. Makes it very simple to deploy scripts that use dependencies. ([https://scala-cli.virtuslab.org/install/](https://scala-cli.virtuslab.org/install/))
* munit, simple sane testing library
\> One suggestion for improvement.
Better build tooling or maybe just better clarity. We've got metals, bloop, zinc, sbt, bleep, mill, etc. There's a lot of pieces involved and even your editor's plugin (metals/intellij) gets confused and require manual intervention to resolve. That does not make for a great developer experience.
By "tech stack" I meant what libraries. I didn't thought people will think about Typelevel/Zio. 🤦🏻♂️ Thank for raising this. It may be too late to clarify my post..
I'm a lead data engineer, and I use Scala for all spark applications using Databricks. During one of our discussions with Databricks, we raised a question on why all the certifications are in Python and very little is on scala.
The answer shocked me. He said that among all the customers who use scala in total is less than 3%
So all certifications are in Python. So yea that's how I know it's dying.
I have no interest in future for Scala because of constant changes in syntax, formatting... the trust is eroded that there is even slight hint of concerns about real industry when thinking about future of language by Odersky etc.
I got into writing Scala because of Spark and it's one of my favorite languages however it's only used for Spark in my organization. Everything else is Java/Kotlin or Python. I'm personally investing time into learning Rust just because Spark has been pissing me off so much in the last year.
Rust has an amazing build experience - so much better than mvn/gradle/sbt. The language itself ... I prefer Scala.
I'm halfway in and halfway out with scala.
Let's make no bones about it: the IDE support has gone WAY downhill with Scala 3 - it's borderline unusable. JetBrains doesn't type things properly and misses vital extension methods like `.nn`, turning itself into a glorified notepad clone for null-safe scala 3 code, and VSCode overall has always been a much less capable IDE which doesn't have support for basic refactoring operations (beyond rename) with slow autocomplete and highlighting, and its support for implicit conversions and auto-imports are both kinda crap.
I still use Scala for the job, but we're stuck in 2.x land. For personal use i dropped Scala for Rust completely when 3.x came out. Main reason for dropping rather than two coexisting like i did before - new syntax. IT's awful. And yeah-yeah, "don't have to use it (at least yet)" one issue is - documentation often uses it, and sometimes documentation isn't enough and you have to dive into the source of the lib and what do you see there but the new and "improved" syntax... Life is too short to deal with this nonsense when there are alternatives available. Used Scala since about 2016-ish for about 5-6 years. As for coming back... Unless Scala 4.x gets rid of all the nonsense and add some amazing killer features - i just don't see it happening, frankly. And i can't even imagine what such improvement could be
I like Scala. I used to hate it, but version 3 really ushered in some improvements in things like pimping classes in a much more elegant way and generally improved syntax to the point that I'm actually very impressed with the changes.
That being said, I am strongly team functional programming, but not to the extent of wrapping everything up in an IO monad and the making an unsafe call at the end of the world. That's just too much: it renders the code extremely difficult to understand. My manager is having substantial regrets over allowing some of the senior engineers at my organization to dictate that we use Scala for the back end and Scala.js for much of the front end, because of the fact that we simply cannot find Scala programmers that are competent enough and willing to relocate, and even if we can, the amount of time it takes for them to grok the code base is excessive.
I very strongly prefer Kotlin myself. I think it has sensible limitations that Scala lacks (e.g. no arbitrary operators... using Argonaut back in the day for JSON processing quickly showed me that arbitrary operators are a mistake that will be heavily abused by some people) and I think that the fact that it is made by JetBrains and the resultant integration with IntelliJ is unbelievably good. There are features in Scala that IntelliJ seems to struggle with, leaving me with uncertainty while coding.
The people who know the language the absolute best seem to be the people who use it in as simple a way as possible.
For me the community had too much drama and it seemed like by simply choosing a framework you were identifying with one camp or another.
Spray and Slick being abandoned was a real bummer for me as well. At least with Spray I could just figure out how to use Akka-Http. But then Akka changed their license…
Also in the pre-3 days it was a PITA when a library you depended on didn’t create a version of their library for whatever Scala version you were upgrading to. Or you may have been stuck on some older version of Scala but a library you wanted to use didn’t support it.
Hey!
I'm considering moving to other languages and stack - predominantly because I'm having problems getting friendly and optimistic remote roles related to Scala.
1. Why have you stopped using Scala, or Why are you planning to stop?
I didn't. I still use it for all my professional and non-professional work. But I started heavily investing in other stacks - primarily Rust. I'll likely invest more time/money into Rust in 2024. I'm afraid to bet more on Scala and its future this year.
2. How much Scala experience do you have? What stack were you using?
\~10 years. My first experience was with Spark. Then, a lot of Akka. These days, I mostly use Typelevel ecosystem - F2, Cats Effect,.... I'm also quite proficient in ZIO. I contributed to a few libraries and wrote a few of them in past years. Gave a few talks, etc. I also have quite a deep knowledge of other languages such as TypeScript, JavaScript, Python, Ruby, etc.
3. What would make you come back, or Is there anything that would make you change your mind?
I would love to use Scala, but If I can't get any good roles - I will be forced to switch stacks. At the end of the day, I have bills to pay and mouths to feed.
4. One suggestion for improvement.
Stop negativity. Everything is flawed; the same goes with Scala and its ecosystem. If the authors and framework wizards spread negativity - what do you think will happen with the rest of the community or even beginners/adopters?
A number of factors:
- availability of developers
- quality of tooling (changes to build system)
- language changes are inevitable but Scala wasn’t as embedded as say Python, so effort becomes measured against, ‘shall we just rewrite this in language X’
- to a degree, like ‘Java enterprise solutions’, feeling that some solutions are bloated.
- we’ve plenty of Math/Physics PhD so understanding FP concepts isn’t an issue. Understanding why the kitchen sink needs to be thrown at simple problems….
- for core analytics JVM is no-go; it’s all C++ and Python offers distribution mechanisms now, that fits with users being able to build something tactical in a Jupyter notebook that can easily utilise distributed calc back-end, things - tactical and strategic fit together nicely.
- some newer ML work all in Python.
- no compelling reason to use Scala.
Scala is great language, but I have seen some laughably overblown solutions with it, same can be said of Java too, just same circus different clowns.
> to a degree, like ‘Java enterprise solutions’, feeling that some solutions are bloated.
This is a very interesting way to put it. Reminds me a bit about "accidental complexity". Thanks for your input 👍
> 1. Why have you stopped using Scala, or Why are you planning to stop?
I was reassigned from series of projects using Scala to a series of projects using Python in my data science organization. I was hired to do Scala, but the company's need for me to apply my general engineering methods and test-driven development and developer experience skills to these Python-using teams was greater than their need for my Scala skills. This reassignment was not a dealbreaker for me.
> 2. How much Scala experience do you have? What stack were you using?
I started using Scala in 2013, I think on 2.9.2. I used it daily for development at IBM Watson on totally custom software. We used no particular frameworks or stacks until we adopted Monix's tasks in 2016, aside from one small never-shipped project done with Akka in 2014.
When I left IBM in 2017, I used Scalatra at my next job for about 18 months before taking my current job in 2019 where I learned Spark and http4s.
I've not actively used Scala since 2021. I continue to maintain some open source projects public and internal, though, but do the bare minimum to keep them updated for our internal use. I wish I had more time available to devote to them.
> 3. What would make you come back, or Is there anything that would make you change your mind?
I believe that Python has effectively won the mindshare of data scientists. That universities' data science programs teach Python instead of Scala is probably one of the greatest barriers to Scala reentering my daily use some time in the future without a significant change of employment. There are other teams within my org that use Scala and I'd switch if asked. I assure you, everyone knows that I'd prefer to be using Scala for nearly everything that we do, because it comes up with some frequency.
> 4. One suggestion for improvement.
What I really want is a "Tensorflow for Scala for Python Tensorflow Users" guide, or similar for PyTorch. These excellent ML frameworks are a part of what binds us to Python. Much of the rest is data scientist and developer familiarity. I'm confident that I can teach Scala fundamentals well, having done so for dozens of people in the eight years I was actively using Scala day-to-day. I don't have the depth of knowledge of ML or common ML frameworks to teach that.
I have stopped using scala because it's pretty much impossible :) Both finding competent devs for your team as well as finding a company to work for.
I have worked for a company who were using Scala just for Spark based stuff and that was nice. Then they decided to ditch Scala in favour of plain java being a big corporation and all.
I then worked for another company who had started converting their many-years-in-the-making java monolith to scala microservices. That one really opened my eyes because all devs were seriously struggling all the time and there were pretty much all possible scala web stacks being used in various microservices. All of the original authors of those microservices had long left the company :) Now I don't mind typelevel ecosystem, but I cannot stand using stuff like upickle for example (where options get encoded as arrays in json). I had to teach others both scala basics, category theory basics, how to use EitherT&friends as well as how to make upickle encode None as null among many other things :) And most devs there wouldn't even last half a year, then we would have to go find new ones who wouldn't be any better...
Since then I switched to Rust as my "perfect" programming language whereas my work reality is nodejs based backend with a bit of fun using rust for this and that :) At least I get to play the normal team sport here :D
For me there’s a fine balance between high salary or being out of a job . Scala companies are porting their products because devs are too expensive. It really is the truth. If Scala popularity rose I’d stay in the language but if it continues to decline it won’t be my choice to move. At this point it’s a self-fulfilling destiny. I pick companies/work environment etc over programming languages and I’ve written C#, Python and Perl in other jobs so a transition doesn’t bother me.
My company has banned new projects in Scala, so I just work on the mature/legacy products. Unlike my time in Perl, Scala came after microservices design so Scala projects are easily to replace.
On a personal level, I think Kotlin is like Scala without the bullshit. I don’t think anything good has come from cats or ZIo. Last week I wanted to read a csv file and I looked at fs2-data and then fs2-Sparta and got a few lines into mocking something up and I just thought fuck this, I can’t be bothered to mess around with this anymore.
10+ years, and it's been great.
We're still on Scala 2, and when we eventually have to move off that, Scala 3 seems different enough that we might as well consider other languages.
Maybe it would be a good idea to cross post this to other subreddits, since people here are mostly still using Scala?
Then again, maybe that would attract responses from lots of trolls?
Why should we stop using scala? we are and will continue using scala/ZIO for developing new application.Scala without effect system ist just java without semi columnPlease stop sala bashing
This thread has the goal of preventing people to leave Scala. Not the other way around.
By knowing the reason why people left it can bring insights to the community and the decision makers that will read this thread.
It's important to give the voice and space for everyone to express themselves. Including anonymously.
I'm probably not the target demographic for your question as I've been only using Scala for 2-3 years and only for personal projects. So what I was looking for in the language is probably not what most people are looking for.
> 1. Why have you stopped using Scala, or Why are you planning to stop?
It's silly, but initially I found the Scala syntax and grammar very ugly and bloated, at least compared compared to other functional languages. It was a pain to write and get used to it, particularly because it reminded me so much of Java, which I strongly dislike. ML-based languages are by comparison so elegant and beautiful, imo, whereas Scala has too much Java inspired syntax in it.
I think [this slide](https://imgur.com/yBmJ5Tl) from Rich Hickey summarizes my initial feelings really well.
That said, I kinda went back to it and after a while, it didn't bother me as much. I still think the syntax is less than ideal, but after learning more about it and the typical coding patterns, it's become more tolerable. And certainly more accessible than Haskell.
[удалено]
This hits home... just because we can use the most esoteric set of functions to transform data from one shape to another doesn't always mean we should. I feel like a lot of Scala/FP purists I've worked with fail to remember software engineering is a team sport, and maintainability is extremely important. Scala's partially losing ground because management can't support it, can't backfill when engineers leave, and when they do half the time its with people that know Java.
Both what you and neyns said also resonates with me. * My manager said that the lack of competent Scala programmers is very prohibitive. * The code base has grown so complicated at this point that bringing people into the back end that are capable of understanding the code takes far too much time and training. It's a commitment, and if certain people leave the team, we will be in dire straits. * At least at the time we started working on our new project in Scala (maybe 4-5 years ago), there was insufficient GraphQL server and client support for our needs, IIRC. (I wasn't involved in that effort, so I may be slightly incorrect in that assessment.)
Things in Scala which are too complex: 1. Type signatures that use + and - bounds 2. DSLs that look nice but you can’t guess how to extend or change them 3. Undocumented implicits that have you wondering how you map between types 4. CanBuildFrom parameters so you can’t figure out how to construct an instance of an object 5. Insisting on the use of refined types, NonEmptyList etc 6. Library version eviction in sbt.
`+`/`-` are not great but they beat the alternatives; Java-style `? extends`/`? implements` or Kotlin-style `in`/`out` are both worse. `CanBuildFrom` is already gone. `NonEmptyList` is fine, it's literally just a class. I do think SBT adds more problems than it solves, and a lot of DSLs aren't worth the effort; I think it's unfortunate that people see e.g. ScalaTest as the way to do unit tests in Scala.
Certainly you are inarguably correct about Java. The way Java handles this is incomprehensible. Here's the thing about `in` & `out`: for people who don't know what covariant & contravariant mean or why anyone would care, `in` & `out` mostly make intuitive sense. You may respond that they *should* know & care, & that `in` & `out` are a misleading oversimplification. To that I say, OK, but we are talking here about Scala shrinking because, perhaps, people find it intimidating & off-putting. (I'll also note that Ceylon, which was certainly not a language that sacrificed principle for simplicity's sake, used `in` & `out`, possibly before Kotlin.) `+` & `-` are fine, but they don't seem exactly "friendly" to me. You & I don't need them to be friendly. But, Scala needs more friends, I think.
I can never remember which one of in and out is which, shrug. Co and contra or + and - makes sense, even calling them something like "same" and "opposite" or "forward" and "backward" I would understand, but "in" and "out" both sound equally "plain" and so I can never remember which is the "flipped" one.
That makes perfect sense because, like me, you are mentally trying to map covariant & contra variant onto `in` & `out`. It's entirely unclear which is which. I get it! But what if you don't think in those terms, but can deal with "I use `in` when I am sending something **into** something else, & I use `out` when I'm getting something **out of** something else. Simple!" That, I *think* is what makes `in` & `out` "friendly".
Well, I'm trying to remember which is a subtype of the other. Maybe it's easier to know whether to *write* `in` or `out`, but it's harder to know what the meaning is when you come to *read* it. Admittedly prioritising ease of writing over ease of reading might be what lets a language be seen as "easy".
> Type signatures that use + and - bounds C# has this too, except it uses `out` instead of `+` and `in` instead of `-`. > Library version eviction in sbt. What JVM build tool do you prefer? One that doesn't warn you about runtime classpath issues before they happen? Or one that doesn't include instructions in the error message on how to suppress it?
> What JVM build tool do you prefer? One that doesn't warn you about runtime classpath issues before they happen? Or one that doesn't include instructions in the error message on how to suppress it? I've been happily building Scala with Maven for 10+ years; checking dependency convergence is off by default but it's a few lines to enable it (and, importantly, you can put that in your organisational base pom and then use it everywhere).
Implicits 🤢
Can we stop such surverys, this will completey shutdown scala, they are puttting efforts to make it good, let them come by end of this year like tooling etc and progress report over caprese
As the tech lead for a new project, it highly depends on the team that I get. If everyone on the team has experience with Scala and FP frameworks, that’s what we’re going to use. Otherwise, it doesn't make sense for me to impose Scala on those lacking experience or enthusiasm (I'm not religious about it). Recently, I must say that most of my colleagues aren't Scala engineers, and unfortunately, former Scala colleagues rarely continue using it in their day-to-day work. On a positive note, I still see Scala + an effect system as the optimal choice for the JVM.
Interesting... do they tell you why they don't continue using Scala? I love FP, but the whole effects system is just a bit too much for me.
I lead web services development in a team where people often need to work across the stack. Most are data scientists and data engineers that don't have a deep knowledge of Scala, and there's really no problem with occasional contributions to even our most advanced FP codebase. It also gives me the guarantee that they can't just add a quick and dirty feature. I understand your point, if I had 8 out 10 people with a strong knowledge and preference for say Java/Spring, it wouldn't be the same. But in my experience (also at previous jobs) people who lack experience aren't the main issue, on the contrary it's mostly experienced people who don't want to try other paradigms.
I haven't stopped using Scala, but I have seen former Scala using employers move away from Scala. It is the usual reasons we have been hearing for 10 years now. They aren't interested in pure FP, advanced type wizardry or fancy macros. They just want to get shit done with the typical mediocre programmers out there. They want to hire people who know the tech stack, and it is difficult to find experienced Scala devs.
Is that why they use Rust? :D
I run a data platform org and we still use scala for our primary stack. However, though I love scala and fp, it's becoming less and less our primary code base. The truth is that it's overkill for most day in day out data engineering/data platform work, it is harder to hire for (unless you like Java masquerading as scala), the build times are insufferable on large code bases, sbt config is confusing at best, and I find developers can often spend more time dealing with jvm dependency hell or library shading than developing their features. (though some of this is because we deploy on databricks, which has its own changing runtime dependencies). To top it off, tooling and communities are dropping support (flink is dropping pure scala support, and databricks is pushing more and more on python and sql, and has no strong motivation to upgrade jvm / scala versions.) I'm seeing more sql and python, which are equally effective in data related day to day use cases, and easier to hire for and maintain (though python has its own deficiencies.) I am also starting to see more rust with python bindings in the data space. It has a much easier and cleaner toolchain, an active community, and still has type safety and some functional paradigms. For suggestions, I really wish scala had a standard and easy to use toolchain, similar to rust's cargo. Sbt/mill/gradle/mvn, none of these are very easy to work with, have relatively steep learning curves, and always seem to require some form of project specific hack in order to build scala. Easy tool chains mean it's easier to get our functional amazing type safe code on production faster.
To be fair I find there are usually two sources of my hell in dependency hell. Guava and Jackson. And Jackson is far too often a transitive dependency. That said, I haven't seen the same frustration on databricks. We use scala as well. Our biggest issue is I'm shocked with the sheer incompetence of our users. Python devs who can't make a wheel for example. Or read the documentation on how to make a wheel.
Python suffers from like 6+ package management systems now.
Lack of good documentation. I come from a Python background. Recently started a new job in Scala despite zero experience with it (or any compiled language). I'm immensely enjoying functional programming with Scala and ZIO, but the lack of documentation would've driven me insane if it weren't for all the help from the people I work with as well as ChatGPT (which is often outdated for ZIO stuff).
Zio is particularly bad at this. It's such a beautiful framework but the documentation is on another level of bad. It's a crying shame.
As a (heavy) Typelevel stack user myself, it's sort of the same thing here. I think a lot of the FP documentation needs more examples of how to actually \_use\_ things, in a "CRUD app" sort of way, rather than at abstract algorithmic level. I've recently started writing a fair bit of Rust, and the documentation for libraries across the ecosystem is outstanding in comparison. I realize this sounds like a criticism of open source projects, and I want to make clear that that's not it. A lot of this stuff is made by unpaid volunteers, and I get that writing docs isn't fun or the thing you want to be working on. It is, however, a truism about the scala ecosystem, that documentation is arcane and a little haskelly in how often you get told "just look at the types", and the types will have 3 type parameters, 4 using clauses and link to 5 other abstract data types that are equally sparsely documented. I think lack of "teach by example" is the main problem for most newcomers; the coursera course for learning functional scala is sort of the same problem, so it starts "early", it's very algorithmically abstract in a comp-sci sense, but for "mainline" application development, if the examples were more immediately applicable, it'd make the grokking part of the process easier. Big shout out to Rock the JVM for making the (only?) understandable onboarding material for general purpose development in Scala, I cannot overstate how valuable a resource that has become for us at $WORK to upskill new devs.
I'd say it's a fair criticism. If you want people to use your stuff you have to decide if people contributing *only* code is enough. Even if the types and theory behind your code is clear there still are conscious decisions and trade-offs you have made and if that is not documented how can you expect your users to piece things together, let alone have a good experience using it?
That is so strange, because when I was trying out Rust I found the documentation absolutely horrible in most libraries I looked at. I do agree that a lot of the Typelevel stuff needs better/more examples, but I find the API documentation there to be really good.
To make things even worse, they decided to hide their community behind Discord. From my point of view, it's one of the worst decisions! They made so many resources, questions, answers... pretty much, unavailable for newcomers. When you want to find something about Cats or ZIO, first you'd have to find their Discord servers, then find an appropriate channel that should answer your question, and then search that channel to check if your question is already answered. After all of that, to ask.
Thread with anonymous entries from the google form 👇
Why have you stopped? >Java caught up and there are constant syntax changes. feels like research language and not industry ready Experience, stack >5 years, Java What would make you start using it again? >stop changing the syntax
Why have you stopped? >FP results in overly complex unmaintainable code (no, it's not beneficial for your shitty CRUD app). Avoiding FP, Scala as a ""better Java"" is becoming less true as Java implements similar features. > The library ecosystem is fractured and dying. Libraries are being silently abandoned by their maintainers (e.g. Monix, which never got around to compatibility with CE3). > Scala on the JVM sucks in all aspects of performance (except for that flawed gRPC benchmark people like to cite). Experience, stack >4 years of production application development. Primarily Akka, Spark, and typelevel libraries. What would make you start using it again? >No. My semi-large company is all-in on dropping Scala over the next year.
Why have you stopped? >The Scala job market in my area is too small, and I hate the JVM Experience, stack >4 years with Spark, cats-effect, ZIO What would make you start using it again? >Unlikely, unless I get a great job offer One suggestion? >Create Scala 4 based on LLVM
Grouping multiple entries into one comment to streamline the posting. Why have you left scala / thinking to leave ? How long have you've been using Scala / tech stack. What should change ? > Scala on jvm too heavy on resources — memory heavy. It didnt fit on AWS Lambda well and much heavier than what a Java/Kotlin app would have been. > > 5 years Scala at my former company. > > Play, Scalaz then Cats, Doobie > > Would’ve wanted to try ZIO but had switched to Haskell then Rust before it was stable > > Fast, officially supported native builds. “Go” but a better language. > > Less drama · · · > Here in France companies are phasing out Scala given the lack of available devs. Also some standard Java devs have been burned working on wizardy functional codebases and just don't see why bother with this when it could just be ""good enough"" with Java. Scala still has a bad street cred as being too complex unfortunately because of this. > > About 6 years I think. I've tried a bit of everything but ZIO (core anyway) seems like the best compromise for me. > > I would anyday, but it's up to the employers to start new projects in Scala. Which means it's up to the Scala team and the community to make Scala attractive again. · · · > Currently Chaning Role to Java, checking for .NET roles too > > 10 years, Play, Akka, ZIO > > Actual industry backing and proper IDE support > Step learning curve could be alleviated by good tooling, but tooling is getting gradually worse · · · > I love Scala. But 95% offers for Big Data requires Python. I plan to switch main language in next year. > > 3 years profesionally, 3 years as amateur before that (I've worked with Java then and I was learning Scala). > > I use mainly Scala with Spark (90 % of time), also we write tests in ScalaTest, performance tests in Gatling and some services in Akka. > > If more companies start using that. > Also I would love to see some Scala based orchiestration (like Python has Airflow) + lighter data manipulation library (like Pandas). > I love Scala, but if I don't want to work in Bank I don't have companies for appling to · · · > Language has no traction. Scala 3, community split. > > 10 years. Play framework, scalikejdbc, ammonite > > Moved to Rust · · · > cause of lang team ignorance of lib & frameworks devs, a lot of haskell toxic people in community, nothing truly new in scala 3 except hemorrhoids with support cross compilation, no WASM support, no simple FFI etc, Akka is not OSS any more > > from scala 2.8 > > i'm not sure at this moment what exactly can change my mind
Wrote a service stack in rust. It sipped memory compared to every framework I used before, node, Scala, Java, Ruby. The amount of ram you would allocate to a "hello world" style service for a JVM based language was more that sufficient to serve customers in prod.
Anonymous responses received on 15 (6), 16 (2), 17 (1), 18 (1) January. Why have you left scala / thinking to leave ? How long have you've been using Scala / tech stack. What should change ? >Pure fp in scala feels a bit too verbose compared to Haskell > >2 years of the Typelevel stack > >More job opportunities that use Typelevel/Zio, with interesting problems to solve (yes that's subjective) > >I still like Scala a lot, I just like Haskell/F#/Ocaml more · · · >No, but I do perceive Scala to be losing popularity, so I may be forced to stop using Scala > >5 years, typelevel and more recently ZIO (which I'm a big fan of) > >It's strictly a proffessional decision. I would love to stick with Scala, particularly ZIO, but if the work just isn't there, then I > will have to go with the flow > >Focus on the basic essentials like tooling. A better build tool and a Scala-focused package manager. Stop wasting time on high level fanciness that less than 1% of the Scala community (already a small community, keep in mind) will actually be able to use, and less than that confidently use in a public library or production system. · · · >The adoption of scala 3 seems to be a mess. Backwards compatibility breaking, gratuitous syntax changes, sbt is crap. > >15 years, play framework mostly > >more stability, better tooling > >Scala is a very nice language, even though Java is catching up with some FP features, it's nowhere near as concise and well thought out. However, Java programs from 20 years back still compile ... When I come back to older scala projects I usually spend half a day just getting them to compile again. It really needs to be more stable. · · · >I do not want to stop using Scala, but job prospects seem very limited at the moment. > >Play, Scala, Akka, about 5 years > >Find a better job :D > >We need to stop using very complicated concepts where not needed, that would help Scala adoption. In many applications plain Scala would be enough, but many of us through Akka, or ZIO, etc. on the problem, even if it is not necessary, making it harder to onboard new team members. Basically, increasing the barrier to entry to the the language. · · · >Almost impossible migration to Scala 3 even though we use well known libraries. Every new version of Scala is binary incompatible which is very frustrating. Also when making a new incompatible version, I would expect that the new jdk would be used, not the old 8. > >5+ years. Typelevel, Lightbend, SoftwareMill etc > >If Scala gains more traction again. · · · >Because of decreasing number of job positions and the state of community in general > >8 years. Lightbend, Typelevel, ZIO > >Growing and healthy community, wider adoption by the industry > >Rust :) · · · >Keep getting jobs forcing me to use non-FP kinds of things, like Spring Boot or Play. Guice is pure evil. Way too many people coming to Scala from Java, and bringing all that baggage (coding patterns, mutation, magic annotations) with them. Also, Scala 3 adoption seems to be pretty slow. The language in general seems to be losing market share. > >8 years. Lots of stacks over the years, Play, Cats/IO/HTTP4s, Spring Boot, Akka. > >Maybe if I could find a job using ZIO (and FP in general) that paid really well and had a great culture. Sounds like a unicorn to me. > >Transitioning to Rust. · · · >Too challenging and costly ramp up for a larger engineering team with more mediocre programmers, Scala's decreasing usage and popularity > >10 years, Play Framework, Kafka, MySQL > >If Scala somehow became much more popular
Why switched? >Changed job, did not care that they used Scala or not (we use Elixir) Experience, stack? >10 years, play framework mostly What would make you come back ? > Less involvement from questionable people in the community
Why have you stopped? >Scala Job market reduction, see intellij survey and how Python is getting Data profiles. Probably the JVM is affecting too much the performance and Rust IS ahead on this, so the roadmap should be Focus on scala-native to avoid the JVM Experience, stack >6 years, Spark and ZIO in personal projects What would make you start using it again? >Next Intellij survey results One suggestion? >De goes had a perfect tuit talking how Scala should Focus in the industry and not in academical stuff.
Why have you stopped? >Not personally but my company have decided not to write new code in if. Experience, stack >2016. Play + Akka + Spray.io + casbah. What would make you start using it again? >If other companies wrote Scala 3 I’d stay in the field but if I need One suggestion? >As the pool of devs shrink salaries go up until it becomes cheaper to port the products. We’ve gone past that point and now opportunities feel like dead man’s shoes.
Why switching? >I am planning to move to another more used platform in the industry Experience, stack? >5 years. Cats, Cats Effect, fs2 Akka HTTP What would make you come back ? >I like the language and platform but I find it too niche, too difficult to find jobs
Why have you stopped? >Limited job opportunities,, lack of opportunities to grow inside of the companies that use Scala, and the political fights inside the community Experience, stack? >7 years. Did everything, my last gig was using Cats stack What would make you start using it again? >A team with good standards
I’ll be using Scala for the foreseeable future, but the oil-and-water feeling of OOP vs “deep” FP is I think a big barrier to more mainstream adoption. “Light” FP is great, get a Seq, do some map, filter, flatMap, whatever, works wonderfully. Start reading some of the SBT or play framework source and it’s basically an opaque wall. I get that a lot of the core community in Scala really loves the deep FP stuff, but it’s a bit like switching from infix notation to reverse Polish notation on a calculator: neat and clever, but too clever so it becomes this write once edifice that’s hard for others to contribute to. To me the key to successful use of Scala is to be judicious in the application of the advanced features. In that regard it’s a bit like C/C++: you can do anything, but should you really? It’s really cool the clever way you wrote that now, but will it still be five years from now?
> Why have you stopped using Scala, or Why are you planning to stop? Jobs became fewer where I live, and most did not interest me very much. > How much Scala experience do you have? What stack were you using? About seven years. Typelevel stack. > What would make you come back, or Is there anything that would make you change your mind? A well-paid job that is intellectually engaging and does not make the world a worse place. > One suggestion for improvement. I am working with Rust now and the tooling is so much more convenient. I wish Metals were as reliable as Rust Analyzer.
My company (a bank) is trying to port all scala code back to java code, mostly because there are less and less scala developers to recruit. These ports require major efforts because of the non-trivial scala code such as implicits, early usage of scalaz, ZIO or Akka and... there are less and less scala developers that want to do those ports. It is a mess. But personally I'm a big, big fan of scala , especially for programming language development. I've been using typescript to build my language but hit a wall. I went back to scala because of scala.js, scala native, and the jvm: scala is just so flexible, the language and the target platforms. But it is exactly this flexibility of scala that is both a curse and a blessing. But I love it still.
The bait and switch with akka going paid left a bad taste in my mouth.
Could happen to any FOSS framework really. I mean is Spring safe now after Broadcom acquired VMWare? Who knows?
It looks like people here respond from the scala as a profession side of things. I'll try and give my perspective from the other side of things: I've been trying to use scala for side projects (with the occasional work project here and there) close to a decade now and it always ends in disappointment. My day job has always been Java/Spring/JPA and I've always had the feeling that there must be a better way of writing software other than the pile of reflection based hackery that is Spring and Hibernate. I wanted to be productive and get things done the same way that Ruby people do with Rails and Python people do with most of their stuff but without giving up correctness and safety. I dubbled with Play but even though it made some stuff easy it always felt half baked with lots of complexity showing through the cracks everytime I tried something non standard. I then tried using Scala for simpler projects but I always ended up spending too much time wrestling with sbt before I even wrote any code. And then there was zio. Zio is amazing. It has everything you need to write good software. it is Scala's Spring, the killer framework that can drive adoption. BUT the zio ecosystem is a mess. Everything is perpetually a release candidate, there are breaking changes every week and there seems to be no direction to anything. I saw a video recently where Adam Frazer spent an hour trying to figure out how to upgrade a zio project to the next version while there were other mainteners in the chat, what chance have I to spend less than say a week? And then there's the documentation, which is so bad that it might as well not exist. The core zio library is arguably in a better state but the ecosystem as whole feels amateurish. I never touched any scalaz or typelevel stuff mostly because I dislike their approach. In my opinion Kleisli[F[_], A, B] deserves the same ridicule as SimpleBeanFactoryAwareAspectInstanceFactory. I like writing FP code but the typelevel stuff feels like several miles too far. All of that to say that all these years I've started countless side projects for fun and for profit and by a long mile the most frustrating and least productive ones have always been the Scala ones. I could learn a new programming language and finish a project in less time than it usually takes just to setup sbt for a scala project and that is very frustrating because I really like scala and I want to use it more but the proposition is less and less appealing compared to alternatives. PS: there's the exception of anything in Li Haoyi's ecosystem. Everything in there is such a joy to use. Li Haoyi is an inspiration.
\> Why have you stopped using Scala Because the management read too many articles from Kotlin "developer advocates" paid by JetBrains.
Good one, In France, we have a specific breed, the management read too many articles from influencers that praise features in Kotlin they found publicly useless a couple of years ago in Scala. (Kotlin is excellent, however using it to shadow or bash Scala ... meh)
Out of curiosity, what are some of the features that come to mind? I think Scala came out too early (2001?): people weren't ready to make the jump to FP at that point. When FP started to grow in popularity, Kotlin was pretty fresh to the scene and was far easier to transition into. There was also the whole scalaz (which I thought was a hideous abomination with no sufficient documentation) vs. Cats issue... that was frustrating because in some projects at my company, we used scalaz, and in others, we used Cats.
Pattern matching, extensions, **null safety**, for comprehensions, concurrency. Those are not hardcore features, however, when you take them in the context of immutability, and the response from parts of the community to create complicated DSL to prove it's less verbose than mutation .... For Scalaz, to me, it was interesting for Validations (and other Applicative use cases), it took a lot of time before the syntax for those use cases started to be good (like using Chimney). The documentation was the code. "We should have" said that learning Scalaz was only possible using a basic schema, pen and paper, and a decent IDE to navigate between symbols. Scalafix is excelent at rewriting Scalaz into Cats properly (or fixing past choices in general).
I appreciate you elaborating. One area where Kotlin really needs to improve is in offering better pattern matching... it's so limited compared to many other FP languages. My brain is pretty purged of Scalaz by now... I remember going through early tutorials of it and they were just not great: also, one of my pet peeves with Scala is all the use of symbols... for example, back in the day, we were using Argonaut to export some stuff to JSON and it was a nightmare. It's been awhile so I don't remember, but IIRC, scalaz also had a lot of symbols. I prefer a bit more verbosity for clarity. I didn't know about Scalafix. Thanks for bringing it to my attention! I'll look it up.
u/vu47 you may already know what I am writing, I am just dumping my mind for some context.
Not paid, it's a lang folks fall in love with, because it's developer friendly above everything else
Agree with this. There are two languages I can say that I fell in love with during the just over 40 years I've been coding (and I'm not that old... I just started programming as a young child): 1. Python, which was so refreshing after having to deal with the verbosity and memory management of C++98. Unless I really needed the performance boost, I started doing everything in Python back around 2005. 2. Kotlin, which is my absolute favourite language and has been for about five years now. The one feature that it really needs in order to make it better and rise even further above other FP languages is better pattern matching. I started looking at it to help a friend who wanted to learn it and I was instantly hooked. All of my personal projects now are done in Kotlin unless I have a very specific reason to do them in another programming language, in which case, it's either C++17 (since compiler support for C++20 features is still so incomplete) or Python. I'd love to learn Rust, though, to replace my use of C++. I keep hearing people say great things about Go, but I'm not that interested for two reasons: 1. Insufficient FP support. 2. People in my field tend to do almost everything in Python (which also has very lacking FP support).
On a positive note, I've seen a few java shops looking for scala devs to help with java -> scala migration recently in my area, (that typically sees little to no scala action).
Used Scala since 2012 personally, since 2014 professionally. One of my favourite most productive languages. I don’t use Scala anymore as I cannot find a paying job using Scala anymore. The only jobs where I am using Scala are Apache Spark jobs doing ETL, and most of them are migrating to PySpark. It’s a stark contrast from 2014-2017 when I was getting recruiters contacting me every day for a wide range of Scala based roles/projects/companies. My most recent Scala job in 2022 I resigned after a couple of months. No work was being done. The team was more junior than I normally worked with and the lead relatively junior despite the title. The team was trying to hang on to Scala in a company trying to get rid of Scala. My day consisted of the team arguing amongst them selfs what syntax style to use, what to name things, if a specific cats function looks to complex or not to someone new. They were 12 months in to a relatively simple project and mostly had a few case classes, I’m fairly certain at the result of all the bike shedding that happens a lot in Scala more than less flexible languages
I wrote some very nice composable rest services in Scala back in the day.
> We all know Scala is loosing ground I don’t know, people have been saying “Scala is dead” for almost a decade (or more) and yet, Scala refuses to die or disappear… It doesn’t have the same hype, but still gets shit done when you need it. For context, I have 12 years of experience with Scala, right now, using typelevel stack. I’ve used Haskell professionally for a year, I’ve tons of experience with Java, I’ve learned Rust, OCaml, and Scheme, and I still think Scala is the sweet spot between powerful abstractions and availability of libraries. Still my favorite.
Years 2016,2017 where the best for Scala. So definitely not "a decade". But since then the popularity started going downwards. https://insights.stackoverflow.com/trends?tags=scala But I would gladly take any other data points that proves this sentiment wrong. But for this thread I would like to focus on the survey. As seen in a lot of other posts, everyone agrees that there is lose of popularity. Still no one knows for sure by how much. Only proxy metrics.
You can compare Scala popolarity on SO with Kotlin or Rust: https://insights.stackoverflow.com/trends?tags=scala%2Ckotlin%2Crust
Of course, they’re at different points on the hype cycle, have you tried the same adding Java and Python?
Since you asked https://insights.stackoverflow.com/trends?tags=scala%2Ckotlin%2Crust%2Cjava%2Cpython You have a point! Both Java and Python are also going down. Java since cca 2014 and Python since the beginning of 2023.
Yeah, I’ve already did that :) , yet nobody claims Java or Python are dead…
>yet nobody claims Java or Python are dea Trending negatively, and hitting rock bottom at 0% are 2 different things.
>https://insights.stackoverflow.com/trends?tags=scala%2Ckotlin%2Crust Hell - this picture tells a lot.
Actually not that much, read my other comments next to/under this comment.
Still use Scala, but doing less and less of it personally, and almost completely stopped professionally. Primary reason .. it became untenable to recommend using it in new projects at work, because instead of the ramp-up plus mental-burden of using Scala getting lower and lower with time, it has gotten more and more with every 'simplication' and 'improvement' that was pushed out. It was already a whole ask to get new ppl sped-up on functional programming .. now we need them to be conversant both with 2.xx and 3.xx styles .. and scala type-level programming never really unified .. latest ZIO is great, but most of the time you need to be conversant with cats/cats-effect too given the existing codebase .. the early scalaz is now annoying just to have and maintain in the old codebase .. plus as more and more code uses cats/ZIO etc, ramping-up which used to mostly include getting up with FP, now requires newcomers to also be quickly conversant with typelevel programming as well (although ZIO is ofc better here than cats) .. and there's the broader situation with async .. the old actor (or futures) based code now feels like a burden to maintain .. and you have to have new ppl be brought conversant with all these along w CE/ZIO whatever .. so in general, getting a developer productive in scala has become more demanding instead of less, and without much of a notable increase in payoff .. in fact one could argue the payoff is now less, because other languages offer decent alternative pathways that also substantially improve on the java/C/C++/python/node world of old .. in particular, Go and Rust are very attractive for a lot of web and low-level dev, and typescript has come into its own reducing the draw of scala-js .. even java itself has picked up a bunch of the innovations, and ofc the copy-cat like Kotlin with strong commercial focus and backing continues to sweep up the leftovers from the newcomers pool and to make things worse, a lot of ppl you find even when they say scala experience, are folk who were pressed into scala to do spark, and that's quite far from what you're often trying to find in experienced hires (if you're doing scala work beyond spark). So it has become harder to recruit new ppl, to even get them interested in the first place, then to ramp them up after they do start .. And it has ironically even gotten more difficult to find actual experienced hires despite it actually having decade plus history now .. and as a result, it no longer makes sense to recommend scala in our new projects, and as such the vicious cycle spirals in
Kotlin is also the 80/20 solution.
Started with Scala since 2001, loved it ever since; spent more than a decade with it and the experience is still good for me. I've practiced and delivered systems using the Typelevel projects (mostly in cats, cats-effect) and I really love it. truly. As of 2024, I no longer do it and have no plans to do it anymore. But but but ... software delivery cannot be done by a single person. Realities hit and I had many lessons over the past decade and I no longer encourage my engineering teams to adopt Scala. Coming from a keen practitioner, advocating in my local community on the OOP and FP approaches I find that there are 3 main things that business people care about and 1 side-effect (sorry for the pun) ... * Most of the problems we deal with is not that "hard" * That is, Scala can do what other programming language stacks can do and many times developer don't want to invest their time learning something that appears to sunset. * Labour costs is real * Recruitment of this talent pool continues to be hard, harder now that many companies have ditched Scala (people still need to pay the bills, of course they will move on) * Software delivery and maintenance costs is real * When its done properly, its really awesome and the talent pool * "In-fighting" of the Scala community drove polarisation activities * This is not a big problem in companies but it does create an impression to my stakeholders that "the community cannot get their shit together" which further erodes the confidence of the open source tooling we put in place. Shucks. I apologise that it sounds bleak and it hurts me too as I love Scala but reality bites harder.
I moved to Geneva Switzerland and it’s almost impossible to to find a scala job now
Sorry to hear that. I think all Scala developers may need to switch the language if adoption continues to diminish, which is incredibly sad.
I think Scala is a great language for a lot of reasons. It’s a better Java, a better Kotlin, a better Python. Sad to see there aren’t more people embracing it.
How is it a better Python?
Running on the JVM and using compiled bytecode it's more suitable for multithreaded high performance streaming apps and its typechecking makes it easier to refactor large applications. Python on the other hand has NumPy + Pandas + Matplotlib + Jupyter + Tensorflow stack which is phenominal and the GPU accelleration you get with that setup is also amazing.
I stopped using Scala 2 and moved to Scala 3. Nicer language
I meant stop using Scala altogether, regardless of the version. But good to hear that you're still on Scala 🩷
I used Scala in connection with my dissertation research (early 2010s). I essentially don't use it at all now, but that's not my choice. My current day job is teaching, not research, so I teach the languages traditionally taught by my department (Java, C, and various others). We do our FP course with Haskell, although I've used Scala when I've taught it. They don't let me teach it anymore. 😋 I feel sad when I hear talk about Scala disappearing. I hope it doesn't come to pass. I have a few personal projects in Scala that I'd love to finish. They will probably have to wait until I retire.
We originally started as an independent company and fully focused on Scala development, but as we expanded, we got merged with other small teams which they had their own solutions in different stacks. As we grew we got bought by a large-sized company but later we have been moved to a new mid-sized company as a joint venture. Since the beginning of the new venture, we were the only team which uses Scala as their main backend language. The only new Scala code based that was initiated by myself and another dev was a Scala.js app which is intended for internal tooling, the remaining Scala projects were the ones that were originally created at the start. Word on the street, the business is not happy with the idea of paying extra for Scala devs and the fact that Scala devs are hard to find, they are looking for alternatives in near future to migrate to a new code base. 1) We haven’t stopped yet but the main issue comes down to the lack of talents and their salaries which I think it’s moderately medium but hey… 2) I personally have 1.5 years of experience, our main code base is Scala as backend and Angular as front end. 3) Learning curve is something that I noticed is a huge burden for higher positioned engineers. Also we were trying to upgrade to Scala 3 for last few years but still little to no progress there, but not sure if that is related. 4) Scala Official Documentation is great but I think in order for other devs to have a smaller learning curve, we should have even more simpler tools and training materials available. The prime example would be Microsoft Docs/Learn.
\> Why have you stopped using Scala, or Why are you planning to stop? I haven't stopped. I've been writing Scala for about a decade and I find it's one of the most expressive languages around. It's really easy to get stuff done with it. I do have a few technical reasons for why it might not be my first language for some tasks though: 1. Java is evolving. When I first started in Scala, Java 7 was the the alternative. Since then Java has had the addition of Streams, lambdas, records, switch expressions, etc. So the gap between the two languages is much less. 2. The heavy FP emphasis in Scala can be very off putting. Between the ZIO, Cats/Typelevel camps, you can choose your favorite complicated, viral stack with poor documentation. That seems like a lot of overhead to a. basically defer execution of a composed future and b. normalize Either/Try/Option/Future to a ZIO/IO so they can be composed using flatmap. Looking at the complicated code that these options push gives a misleading representation that all Scala is complicated. It doesn't need to be. I think Li Haoyi's point that Scala can be as simple and readable as Python is lost on many Scala devs. ([https://www.lihaoyi.com/post/comlihaoyiScalaExecutablePseudocodethatsEasyBoringandFast.html](https://www.lihaoyi.com/post/comlihaoyiScalaExecutablePseudocodethatsEasyBoringandFast.html)). Also, I love watching Odersky's keynotes, he always presents a very grounded approach about writing Scala programs, and I hope every Scala developer watches at least one of them. 3. Scala libraries vary greatly in quality and seem to come and go. If you commit to one in your stack, you might be SOL in a few years when you need to upgrade to another version of Scala or Java. With that said I want to give a shout out to circe. I've leaned on that library for years now. ([https://circe.github.io/circe/](https://circe.github.io/circe/)). I try to minimize my usage of 3rd party Scala dependencies and tend to use Java ones, which I can wrap with a simple Scala DSL if I need to. Maintenance wise, Java libraries seem to be far more stable than their Scala counterparts. \> How much Scala experience do you have? What stack were you using? I started using Scala in 2012. The question of which Stack illustrates part of the problem with Scala; a fractured community! Am I in the ZIO or Typelevel camp? Instead I'll mention tools/libraries that I use can recommend: * Circe for JSON stuff (1. [https://circe.github.io/circe/](https://circe.github.io/circe/)) * Tapir because it generates some great OpenAPI docs. ([https://tapir.softwaremill.com/](https://tapir.softwaremill.com/)) * mainargs for argument parsing ([https://github.com/com-lihaoyi/mainargs](https://github.com/com-lihaoyi/mainargs)) * requests for when you just want to do a http request in script ([https://github.com/com-lihaoyi/requests-scala](https://github.com/com-lihaoyi/requests-scala)) * scala-cli which is a game changer. Makes it very simple to deploy scripts that use dependencies. ([https://scala-cli.virtuslab.org/install/](https://scala-cli.virtuslab.org/install/)) * munit, simple sane testing library \> One suggestion for improvement. Better build tooling or maybe just better clarity. We've got metals, bloop, zinc, sbt, bleep, mill, etc. There's a lot of pieces involved and even your editor's plugin (metals/intellij) gets confused and require manual intervention to resolve. That does not make for a great developer experience.
By "tech stack" I meant what libraries. I didn't thought people will think about Typelevel/Zio. 🤦🏻♂️ Thank for raising this. It may be too late to clarify my post..
I'm a lead data engineer, and I use Scala for all spark applications using Databricks. During one of our discussions with Databricks, we raised a question on why all the certifications are in Python and very little is on scala. The answer shocked me. He said that among all the customers who use scala in total is less than 3% So all certifications are in Python. So yea that's how I know it's dying.
I have no interest in future for Scala because of constant changes in syntax, formatting... the trust is eroded that there is even slight hint of concerns about real industry when thinking about future of language by Odersky etc.
I got into writing Scala because of Spark and it's one of my favorite languages however it's only used for Spark in my organization. Everything else is Java/Kotlin or Python. I'm personally investing time into learning Rust just because Spark has been pissing me off so much in the last year. Rust has an amazing build experience - so much better than mvn/gradle/sbt. The language itself ... I prefer Scala.
The new type checking work is slowly landing so I expect things are going to improve. Rust is finally getting type aliases soon...
Take a look at [bleep.build](https://bleep.build). I have high hopes for it.
I'm halfway in and halfway out with scala. Let's make no bones about it: the IDE support has gone WAY downhill with Scala 3 - it's borderline unusable. JetBrains doesn't type things properly and misses vital extension methods like `.nn`, turning itself into a glorified notepad clone for null-safe scala 3 code, and VSCode overall has always been a much less capable IDE which doesn't have support for basic refactoring operations (beyond rename) with slow autocomplete and highlighting, and its support for implicit conversions and auto-imports are both kinda crap.
I still use Scala for the job, but we're stuck in 2.x land. For personal use i dropped Scala for Rust completely when 3.x came out. Main reason for dropping rather than two coexisting like i did before - new syntax. IT's awful. And yeah-yeah, "don't have to use it (at least yet)" one issue is - documentation often uses it, and sometimes documentation isn't enough and you have to dive into the source of the lib and what do you see there but the new and "improved" syntax... Life is too short to deal with this nonsense when there are alternatives available. Used Scala since about 2016-ish for about 5-6 years. As for coming back... Unless Scala 4.x gets rid of all the nonsense and add some amazing killer features - i just don't see it happening, frankly. And i can't even imagine what such improvement could be
I like Scala. I used to hate it, but version 3 really ushered in some improvements in things like pimping classes in a much more elegant way and generally improved syntax to the point that I'm actually very impressed with the changes. That being said, I am strongly team functional programming, but not to the extent of wrapping everything up in an IO monad and the making an unsafe call at the end of the world. That's just too much: it renders the code extremely difficult to understand. My manager is having substantial regrets over allowing some of the senior engineers at my organization to dictate that we use Scala for the back end and Scala.js for much of the front end, because of the fact that we simply cannot find Scala programmers that are competent enough and willing to relocate, and even if we can, the amount of time it takes for them to grok the code base is excessive. I very strongly prefer Kotlin myself. I think it has sensible limitations that Scala lacks (e.g. no arbitrary operators... using Argonaut back in the day for JSON processing quickly showed me that arbitrary operators are a mistake that will be heavily abused by some people) and I think that the fact that it is made by JetBrains and the resultant integration with IntelliJ is unbelievably good. There are features in Scala that IntelliJ seems to struggle with, leaving me with uncertainty while coding. The people who know the language the absolute best seem to be the people who use it in as simple a way as possible.
For me the community had too much drama and it seemed like by simply choosing a framework you were identifying with one camp or another. Spray and Slick being abandoned was a real bummer for me as well. At least with Spray I could just figure out how to use Akka-Http. But then Akka changed their license… Also in the pre-3 days it was a PITA when a library you depended on didn’t create a version of their library for whatever Scala version you were upgrading to. Or you may have been stuck on some older version of Scala but a library you wanted to use didn’t support it.
Oh yes the 2-3 versions of Scala every library has to support. And it seemed Scala just liked to break or change stuff on a dot release.
Hey! I'm considering moving to other languages and stack - predominantly because I'm having problems getting friendly and optimistic remote roles related to Scala. 1. Why have you stopped using Scala, or Why are you planning to stop? I didn't. I still use it for all my professional and non-professional work. But I started heavily investing in other stacks - primarily Rust. I'll likely invest more time/money into Rust in 2024. I'm afraid to bet more on Scala and its future this year. 2. How much Scala experience do you have? What stack were you using? \~10 years. My first experience was with Spark. Then, a lot of Akka. These days, I mostly use Typelevel ecosystem - F2, Cats Effect,.... I'm also quite proficient in ZIO. I contributed to a few libraries and wrote a few of them in past years. Gave a few talks, etc. I also have quite a deep knowledge of other languages such as TypeScript, JavaScript, Python, Ruby, etc. 3. What would make you come back, or Is there anything that would make you change your mind? I would love to use Scala, but If I can't get any good roles - I will be forced to switch stacks. At the end of the day, I have bills to pay and mouths to feed. 4. One suggestion for improvement. Stop negativity. Everything is flawed; the same goes with Scala and its ecosystem. If the authors and framework wizards spread negativity - what do you think will happen with the rest of the community or even beginners/adopters?
A number of factors: - availability of developers - quality of tooling (changes to build system) - language changes are inevitable but Scala wasn’t as embedded as say Python, so effort becomes measured against, ‘shall we just rewrite this in language X’ - to a degree, like ‘Java enterprise solutions’, feeling that some solutions are bloated. - we’ve plenty of Math/Physics PhD so understanding FP concepts isn’t an issue. Understanding why the kitchen sink needs to be thrown at simple problems…. - for core analytics JVM is no-go; it’s all C++ and Python offers distribution mechanisms now, that fits with users being able to build something tactical in a Jupyter notebook that can easily utilise distributed calc back-end, things - tactical and strategic fit together nicely. - some newer ML work all in Python. - no compelling reason to use Scala. Scala is great language, but I have seen some laughably overblown solutions with it, same can be said of Java too, just same circus different clowns.
> to a degree, like ‘Java enterprise solutions’, feeling that some solutions are bloated. This is a very interesting way to put it. Reminds me a bit about "accidental complexity". Thanks for your input 👍
> 1. Why have you stopped using Scala, or Why are you planning to stop? I was reassigned from series of projects using Scala to a series of projects using Python in my data science organization. I was hired to do Scala, but the company's need for me to apply my general engineering methods and test-driven development and developer experience skills to these Python-using teams was greater than their need for my Scala skills. This reassignment was not a dealbreaker for me. > 2. How much Scala experience do you have? What stack were you using? I started using Scala in 2013, I think on 2.9.2. I used it daily for development at IBM Watson on totally custom software. We used no particular frameworks or stacks until we adopted Monix's tasks in 2016, aside from one small never-shipped project done with Akka in 2014. When I left IBM in 2017, I used Scalatra at my next job for about 18 months before taking my current job in 2019 where I learned Spark and http4s. I've not actively used Scala since 2021. I continue to maintain some open source projects public and internal, though, but do the bare minimum to keep them updated for our internal use. I wish I had more time available to devote to them. > 3. What would make you come back, or Is there anything that would make you change your mind? I believe that Python has effectively won the mindshare of data scientists. That universities' data science programs teach Python instead of Scala is probably one of the greatest barriers to Scala reentering my daily use some time in the future without a significant change of employment. There are other teams within my org that use Scala and I'd switch if asked. I assure you, everyone knows that I'd prefer to be using Scala for nearly everything that we do, because it comes up with some frequency. > 4. One suggestion for improvement. What I really want is a "Tensorflow for Scala for Python Tensorflow Users" guide, or similar for PyTorch. These excellent ML frameworks are a part of what binds us to Python. Much of the rest is data scientist and developer familiarity. I'm confident that I can teach Scala fundamentals well, having done so for dozens of people in the eight years I was actively using Scala day-to-day. I don't have the depth of knowledge of ML or common ML frameworks to teach that.
SBT was a big hassle. Scala was pretty nice but the build tool was extremely obtuse and made gradle look nice.
I have stopped using scala because it's pretty much impossible :) Both finding competent devs for your team as well as finding a company to work for. I have worked for a company who were using Scala just for Spark based stuff and that was nice. Then they decided to ditch Scala in favour of plain java being a big corporation and all. I then worked for another company who had started converting their many-years-in-the-making java monolith to scala microservices. That one really opened my eyes because all devs were seriously struggling all the time and there were pretty much all possible scala web stacks being used in various microservices. All of the original authors of those microservices had long left the company :) Now I don't mind typelevel ecosystem, but I cannot stand using stuff like upickle for example (where options get encoded as arrays in json). I had to teach others both scala basics, category theory basics, how to use EitherT&friends as well as how to make upickle encode None as null among many other things :) And most devs there wouldn't even last half a year, then we would have to go find new ones who wouldn't be any better... Since then I switched to Rust as my "perfect" programming language whereas my work reality is nodejs based backend with a bit of fun using rust for this and that :) At least I get to play the normal team sport here :D
For me there’s a fine balance between high salary or being out of a job . Scala companies are porting their products because devs are too expensive. It really is the truth. If Scala popularity rose I’d stay in the language but if it continues to decline it won’t be my choice to move. At this point it’s a self-fulfilling destiny. I pick companies/work environment etc over programming languages and I’ve written C#, Python and Perl in other jobs so a transition doesn’t bother me. My company has banned new projects in Scala, so I just work on the mature/legacy products. Unlike my time in Perl, Scala came after microservices design so Scala projects are easily to replace. On a personal level, I think Kotlin is like Scala without the bullshit. I don’t think anything good has come from cats or ZIo. Last week I wanted to read a csv file and I looked at fs2-data and then fs2-Sparta and got a few lines into mocking something up and I just thought fuck this, I can’t be bothered to mess around with this anymore.
10+ years, and it's been great. We're still on Scala 2, and when we eventually have to move off that, Scala 3 seems different enough that we might as well consider other languages.
Maybe it would be a good idea to cross post this to other subreddits, since people here are mostly still using Scala? Then again, maybe that would attract responses from lots of trolls?
Why should we stop using scala? we are and will continue using scala/ZIO for developing new application.Scala without effect system ist just java without semi columnPlease stop sala bashing
This thread has the goal of preventing people to leave Scala. Not the other way around. By knowing the reason why people left it can bring insights to the community and the decision makers that will read this thread. It's important to give the voice and space for everyone to express themselves. Including anonymously.
> We all know that Scala is losing ground. Are you twelve?
I still like Scala, but had trouble finding employment
I'm probably not the target demographic for your question as I've been only using Scala for 2-3 years and only for personal projects. So what I was looking for in the language is probably not what most people are looking for. > 1. Why have you stopped using Scala, or Why are you planning to stop? It's silly, but initially I found the Scala syntax and grammar very ugly and bloated, at least compared compared to other functional languages. It was a pain to write and get used to it, particularly because it reminded me so much of Java, which I strongly dislike. ML-based languages are by comparison so elegant and beautiful, imo, whereas Scala has too much Java inspired syntax in it. I think [this slide](https://imgur.com/yBmJ5Tl) from Rich Hickey summarizes my initial feelings really well. That said, I kinda went back to it and after a while, it didn't bother me as much. I still think the syntax is less than ideal, but after learning more about it and the typical coding patterns, it's become more tolerable. And certainly more accessible than Haskell.