I am not positive that the programming language plays an ultimate role here. I’ve worked in places where I hated to write elixir, just because the working conditions were horrible and vice-versa, had a nice job where I was writing on android with kotlin and enjoyed having some nice teammates that were open to write kotlin in a more functional way and simplifying the codebase.

I personally don’t mind working in whatever language, as long as the people I work with create readable and tested code, not drown themselves in some stupid design patterns and complexity that they have read from some random books, or try to abstract things that will never need abstraction in the lifetime of the project. Sadly no language is protected from such things in this regard, so it’s more important IMO to pick a company and a team you enjoy working with.

I was also trying to learn scala professionally about half a year ago after not being able to find an elixir job for long.

I made a few conclusions about the language for myself:

1. It has features of FP mixed with features from OOP and imperative, which makes codebases a mess, I like functional languages because they have less complex features, not the other way around;
2. because of so many features, the ecosystem is fractured into lots of philosophies/frameworks/libraries that all do things in different ways, one worse than the other;
3. the standard language constructs are designed as an afterthought. Take for example what they call monads and how they are implemented like some kind of list interfaces under the hood, the way you chain them with what they call a for loop is just horrible design that has no reason to be like that.

At this point I would rather pick kotlin, as it is more focused and has a clear goal on what it tries to achieve, while scala tries to do a lot of things and none of them that well.

I would recommend to try out clojure instead, I’ve heard many great things about the language and the revolving ecosystem.

I’ve developed in many functional languages professionally, from various lisps to Haskell, Scala, F# and they differ.

Languages like Haskell and Scala that emphasize development with types are entirely different from most dynamically typed languages. You have to at least get a basic understanding of monads, type classes (implicits) and type systems (which isn’t impossible). This implies a steep learning curve in both, methodology, as well as syntax. To top it all, Scala has one of the most versatile type systems I worked with.

That said, the struggle you are feeling is expected, but the understanding and insights you’ll get are valuable and this will even improve your coding in Elixir. I recommend to get used to it and enjoy the insights into different concepts of software development. Even if it hurts.

30% is a large paycut so whatever decision you make, don’t make it quickly.

Spark/Scala experience for a couple of years here

1. Toooo many features, specially for the FP part I would say.
2. The language prefers to be implicit more than explicit. You end up reading the whole codebase to understand just a single file.
3. People who choose Scala tend to abstraction, so projects tend to be very complex because of that and it becomes difficult to switch from one project to another.

That being said, the language is very likeable and allows you to go deeper in you FP knowledge if it’s whats you want. Just don’t give up on your first try

Can’t agree more XD