A Scala journey: a Senior Software Engineer and conference speaker
Our guest tells how his Scala programming journey began, shares his views on how the language has evolved, and much more!
In 2024, Scala turns 20, and to mark the occasion we asked experts to tell us about their Scala journeys. Our guest works as a Senior Software Engineer, speaks at conferences and runs an internal training programme.
How did you first get introduced to Scala, and what did you think about it?
In 2012, I enrolled in Martin Odersky’s “Functional Programming Principles” course. It opened two new worlds for me at once: the Scala programming language and functional programming. Of the two, I’d say functional programming blew my mind a little more. Still, coming from Java 7, how easily I could express functional concepts in Scala felt revolutionary too. For one thing, the immutability-first approach made no sense to me at all; I recall making myself write immutable data structures without really grasping the reason.
Tell us about a moment when you realized, “Aha! Scala is awesome!” What Scala’s features and capabilities made you feel that way?
A major breakthrough came when I began to “feel” immutability – there was no going back from that, and from then on it was mutable code that seemed awkward. I also appreciated how powerful pattern matching is – you get used to it fast, and then other languages that offer only an if or a switch. feel restrictive. And finally, there’s the way Scala blends OOP and FP, letting you pick the best of both worlds and move between them seamlessly.
How has Scala influenced your approach to solving programming problems?
My path through functional programming taught me a lot. In the beginning, it was a rocky ride, because I followed the principles blindly without really understanding what I was doing. Eventually, I reached a stage where I could say I applied the functional approach deliberately. I suppose I grasped the M-word well enough to explain it to other people.
That is when my journey with our internal training programme began. I genuinely believed in the functional approach, so I could sincerely teach it and motivate others to adopt it.
At some point, though, doubt crept in – I wasn’t certain whether we were overcomplicating things by using functional programming everywhere. As I learned more about direct-style programming, it became even clearer to me that there’s life beyond monads. That’s where I stand today, and I’m excited about what comes next.
What are your go-to tools and libraries when working as a software developer?
When it comes to libraries, my only answer is “it depends”, because it really does – it’s shaped by the problems you have to solve and the environment you solve them in. As for tools, I’ve been working with IntelliJ IDEA since version 4 (I think), and that looks like something that won’t change.
How has the Scala community impacted your programming journey? Any standout interactions or support stories to share?
I gave talks at a few conferences and also helped out the organizers of a Scala conference on several occasions. Having seen the conference world from multiple angles (speaker, attendee, organizer), I’m thankful to everyone who helps create opportunities to share knowledge in this way.
Did you have any hilarious or embarrassing moments while learning Scala?
I suppose I had a few once I began teaching Scala. Time and again, it turned out that I believed I understood how certain language features worked – until somebody asked that one tricky question. It was a good reminder that learning never stops: you never know it all, and being a mentor means you have to learn even more.
What advice would you give to someone just starting with Scala?
Embrace the concepts that seem counterintuitive, such as immutability, avoiding nulls, or a functional/declarative way of, e.g., working with collections. At first you’ll have to make yourself use them, but believe me, they’ll become natural sooner than you think.
How have you seen Scala evolve over the years, especially in your field of work?
Overall, I’d say Scala learned its lessons, and a lot of the changes in Scala 3 simplified things that had proven too complex in Scala 2. That includes untangling the implicit keyword, which did lots of different things under one name, and at last adding proper enum support (which in Scala 2 was far from ideal).
Through the years, we’ve watched the rivalry between the Typelevel stack (Cats and Cats Effect) and ZIO (formerly Scalaz). The rivalry wasn’t always strictly technical, but it definitely pushed both ecosystems forward.
One area that feels less like evolution and more like a never-ending story is JSON (de-)serialization. Even though it’s a crucial part of many applications, Scala has never had one standard way of doing it. To this day, picking a JSON library – something that should be a no-brainer – is among the design choices you need to make when starting a project.