As a fun little survey, I just want to know: why did you start learning Scala? When did you start learning Scala? (Optional. Just to have some point of reference about what “Scala” meant at that time – could be an approximate year or approximate version. No judgement for recency nor… anciency?). A cool story is great, but please break out those two data points in short bullets. You don’t have to mention Spark if you don’t want to.
I’ll start by saying:
I came for actors and futures, and stayed for compile-time metaprogramming, flexible syntax, and the pure possibilities of ill-advised DSLs.
Early 2.10, I think.
I wanted something that would let me do callback-oriented concurrency kind of like Node.js, but with a type system and a compiler. I found Scala (with what would later become Akka embedded in its standard library), and it was a good fit. I was briefly enamored with the CPS plugin and its shift/reset (an idea which petered out due to disinterest, but funnily enough resurfaced with gusto when the keywords were changed to async/yield) but really knew I had found my jam when I discovered I could program the type system. Then, shapeless introduced a principled way of doing that (from Haskell, which I’m guessing was a bit out-of-the-blue) and I was fully hooked. The descent into functional/algebraic/banana madness follows, but my point is that it was the flexibility and the powerful-but-dangerous parts that made me stake my career on Scala for the past 12+ (yikes) years.
[The context here is that we see a lot of assertions-by-hearsay about what attracts (or repels) programmers to (or from) the Scala language and platform. But what better way to find out than to ask real live Scala programmers? Surveying repelled non-users is left as an exercise for the reader.]
I got into Scala around 2.8, when I had grown frustrated by how hard it was to write data analysis in Java because as soon as you didn’t use primitives, you didn’t have any operators. So I tried Python, but everything custom ran 10x slower. So for anything worth thinking about, I would have had to write C++, which is full of footguns that I’d been shooting myself with for years. I learned Scala mostly by reading the docs and API (and a book or two) and trying things out.
Scala seemed to be everything a language ought to be: compact syntax with symbolic operators!!!, designed for high productivity, strongly typed, large set of libraries available (if you count the JVM), great cross-platform support, and so on–and with a little bit of care you could get JVM-class performance (but not C++). And because it’s so multi-paradigm, it kept me continuing to learn it for a long time: there were lots of corners which prompted me to see some new angle on how to write code, which was very valuable as a learning experience.
(Edit: since someone else has mentioned the opposite, for me, Scala 3 has enhanced most of the advantages that I found in Scala 2. Prior to Scala 3, I was slightly tempted by Rust as my primary language, but with Scala 3 I am quite sure that, no, Scala remains my favorite by a substantial margin all else being equal. All else is not equal all of the time, so I use a variety of languages.)
Had been writing Java for… forever, almost (1.1.7B on Compaq Tru64). Came to Scala via Apache Camel Scala DSL sometime in 2011/12, was intrigued and gave it a shot at a small-ish project involved in building a simulator for slot machines and other games. Scala 2.9.2 IIRC, using Play! (and discovering Akka under its hoods!). Stayed since because of its type system (HLT looking at you), metaprogramming capabilities (Shapeless was eye opening!) and overall design elegance. Shipped quite a few things to prod since (even in the most improbable companies ;)-) ) and looking forward to continuing to do so.
I came to Scala because the Java 8 Stream API piqued my interest in what could be done with map/flatMap/Option/etc and there was coincidentally a job opening for a Scala developer position (this was mid 2015).
I’ve stayed with Scala for the subsequent 10 years - and the first job change where I kept using the same language as my previous job (Scala was the first language that was comfortable enough to justify limiting my options by targeted a specific language in my job search).
This was largely due to the balance between industry and academic concerns being far better than any other language I’d seen before, and the balance of advanced language features (like higher-kinded types) and industry-standard reliability and tooling support created a space where I could code quickly and smoothly enough that my fingers could finally keep up with my brain and the result would be something I could still read and maintain 6 months down the line (in no small part thanks to the Cats ecosystem).
I’ve avoided Scala 3 because I’ve found in it a notable drop in readability and the balance between industry and academic concerns has shifted so far out of balance that I wasn’t confident in staking my future on it’s ability to keep me employed or myself intellectually satisfied.
I love programming in a way that ideas flow from my brain to my fingers out into the world like water flows downriver, and while Scala 2 enables that, Scala 3 so far has seen itself incapable of avoiding tossing damns in that flow.
I came to Scala in 2020 right at the beginning of the pandemic, through a self-learning track with MOOCs. I was doing OSSU CS and chose the Scala Specialization as my final project. I had absolutely no idea what Scala was at the time, it said “Functional Programming” and that was enough I already knew a ton of FP: Standard ML, Racket/Scheme, Haskell. Scala 3 was very new and the MOOCs were not ported yet, so my intro was Scala 2.13. I quickly switched to 3 after.
What others might find interesting is that, I was more of an “FP die-hard” back then and really disliked Scala at first, but the “object-functional” won me over time… It’s not rare for me to have mutable vars/collections, immutable FP, and OOP in the same file! Scala takes a long time to appreciate truly.
i came for parsing combinators around 2013, because antlr generated too big java classes for plsql parser (i wrote code formatter), so i decided to write parser from scratch and found out it’s easier with scala.
I am teaching a course on programming languages that mixes object-oriented, functional and concurrent programming. For years, I did it using Java (OO and CP) and SML (FP). Around 2014, someone mentioned Scala and I realized I could do everything I was doing (and more!) without having to switch languages. I switched the course to Scala in 2015. I find Scala to be both concise and readable at the same time, which is great for teaching. I ended up writing a book on FP and CP using Scala as the illustrative language.
Like others in this thread, I tend to favor a hybrid style more than a pure FP style. I like my classes and my subtype polymorphism, but I also rely heavily on persistent data structures, standard higher-order functions, and immutable objects. And type classes have been a life saver more than a few times!
I still use Java in other courses, but it tends to frustrate me. Even when students are writing Java programs, I evaluate them with tests I write in Scala (especially for CP). I wrote a few utilities in Scala for stuff I use all the time, and recently I’ve started to write Java bridges for them so I can continue to use them when I’m stuck with Java.
I use the latest Scala 3 in a braceless style, using a 3-space indentation (I’ll use 4 spaces with Scala 4). The early days were rough, but now that IntelliJ has caught up, I have no major complains. (And yes, moving code around and cutting/pasting could still work a bit better.) Some of my students use braces and others don’t, probably due to other languages they program with (some have more of a Java background while others have done more Python).
I have been always fond of FP although I couldn’t get real time experience working with a FP language. About 7 years ago, I was tired of programming in the mainstream imperative languages - C++, Java, C#, Python, and the like. I was not interested anymore in writing loops and such. I wanted to program on a higher plane (functional style).
I had begun exploring Scala. The syntax instantly impressed me - concise yet expressive. The language dropped every bit of conventional and redundant syntax, which cuts to the chase. I was thrilled about the strong type system, implicits esp. recursive implicit resolution, typeclasses etc. Even just Future was good enough for me at that time. That got me hooked on Scala.
Also, I wasn’t particularly interested in developing pet projects but wanted to use it as my primary language. Luckily, my new job at the time was Scala-based, which set me on a course to never let go of Scala. Fortunately, I found a friend and mentor at work who helped me a lot in learning idiomatic Scala.
Overall, Scala has made a tremendous influence in my career, and I love programming in Scala.
The first language I learned was 6502 ML, the second was Basic and then, in the late seventies, Pascal. Pascal was the first language which gave me the feeling that you are working on your problem instead of the language. It made it possible to conceptualise any task “right the first time”. In other words, the language did exactly what you would intuitive expect it would do. Fast forward many years and programming in C, C++, Eifel, Python, Java … Then a friend showed me Scala (late 2013), and after some playing around I got that same, warm, feeling of Pascal. You code, it works, without ado or clutter. So, in bullets:
I switched to Scala for its elegant, mostly orthogonal language and the power to formulate the problem bug free from the start
Since 2013 (scala 2.10??)
BTW, although i program a lot, it’s not my primary profession.
(Finally have time to catch up, post-work-onsite.)
I first hit Scala in early 2008 (wow, appears to be Scala 2.6 from the timing). I was taking my first stab at creating my own startup, CommYou, after five years of working mainly in C#. I had spent the latter months of 2007 trying to build it in Java and Javascript, and was just about prepared to give up in disgust – Java’s religious aversion to even simple FP was maddening after C#, and Javascript was basically a toy still.
So I did some research, and picked up Scala as the one good-looking OSS language that could handle both OO and FP. (And ActionScript as the only decent way to build a front end, but that’s a whole separate story.) CommYou wound up built on top of Scala Actors – the official OOTB Actor implementation, which almost nobody even remembers the existence of any more – with the result that I downloaded Scala-OTP, the library that would soon become Akka, the day Jonas released the prototype.
Move forward four years and one ActionScript-centric dayjob later, to mid-2012, and I decided to take a second stab at the startup game, bootstrapping Querki, which I knew from the outset was going to be Scala-based. (I’d remained active in the community, even though I couldn’t use it day-to-day.)
I’ve been working in Scala full-time ever since, on:
Querki (Typesafe stack, heavily based on Akka Cluster Sharding behind Play, with an SPA FE built in a homebrew Scala.js framework built from Haoyi’s Scalatags, Scala.Rx, and Autowire libraries – the first production Scala.js application, I believe, and still running today, even though I’ve failed to make any money at it)
Artima (various Scala projects working for Bill Venners)
Rally Health (a relatively large, very quiet Scala-centric shop, mainly Lightbend stack, but I built three products there quietly using cats-effect, although still running under Play)
Troops (small ZIO-based startup connecting Salesforce data to the Slack interface)
Slack/Salesforce (did you know there is Scala at Salesforce? There’s Scala quietly lurking at Salesforce, albeit mainly in the form of that ZIO-based Troops engine inside Slack)
One Pass (one of the projects I’d founded at Rally, now its own startup, based on the same Play/cats-effect platform, starting to explore http4s and Scala 3)
Still my favorite way to build serious software, despite constantly having to advocate for it at each employer.
And having just taken a quick look at the Wikipedia page for Scala (to look up the version I started on) – somebody might want to fill in the features for the more-recent versions. There’s basically no details since 2.13.0, so it’s hard to get a sense of just how much action there’s been here over the past decade.
I already knew a ton of FP: Standard ML, Racket/Scheme, Haskell. Scala 3 was very new and the MOOCs were not ported yet, so my intro was Scala 2.13. I quickly switched to 3 after.
), 