News, interviews and articles from the Exercism community.

An interview with Erik Schierboom

An interview with Erik Schierboom in which he and Jeremy Walker discuss functional programming, maintaining Exercism tracks, and the upcoming static analysis of Exercism solutions.

Hi Erik. Thanks for featuring in the first Exercism Contributor Spotlight! We wanted to highlight your work because it feels like you contribute to every bit of Exercism and have some great insights from working across the whole project!

So for a bit of background, how did you first get involved in Exercism?

In 2014, I did a functional programming course that used Scala as its language. After finishing that course, I looked for resources to further improve my Scala skills and found Exercism. It didn't take long before I was hooked and also started to do other language tracks on Exercism. Having benefited greatly from comments people left on my solutions, I then started commenting on solutions in the C# track. At some point, I was asked to become a maintainer of the C# track, which I accepted gladly. Five years later, I'm now a mentor in the C# and F# tracks, a maintainer of the C#, F# and Scala tracks and help work on the cross-track problem specifications.

Nice. So you got into Exercism really early in its life. For those who are unaware, could you explain what it means to be an Exercism maintainer, please?

Sure. Abstractly speaking, an Exercism maintainer is responsible for a track's "health." In practice, that can mean a great many things, like implementing new exercises, updating existing exercises or reviewing pull requests from other maintainers. Another important aspect is correctly ordering a track's exercises, to ensure students have the best possible learning experience. Note that being a maintainer does not mean one has to engage in all of the aforementioned activities; it is perfectly valid for a maintainer to only focus on one or two activities.

Thanks! So as well as your focus on C#, F# and Scala, you've pretty much worked through every language track on Exercism. Do you have particular favorites from a learner's point-of-view?

Although I've learned tons from every track I worked through, my favorite track must be the Haskell track. Not only is it a great language with lots of interesting concepts, the quality of its mentors was absolutely stunning. Other favorites are the Kotlin and F# tracks, with Kotlin and F# being extremely well-designed and pragmatic languages that I love programming in.

Yeah, I hear a lot of great things about the Haskell mentors! I imagine working through so many tracks gave you a whole load of interesting insights into coding. Were there any things specifically that you learnt from that experience?

Oh yes, tons of things! Working with a wide variety of languages exposes one to many different ways of approaching problems. These different approaches have all influenced my coding style in some way, although the functional languages have probably influenced me the most. I now find that I use functional concepts whenever I can, even in non-functional languages (which are slowly incorporating functional features).

I've also learnt that while every language is different, many are actually quite similar. As a result, learning a new language becomes a lot easier once you know a couple of them. For example, knowing Haskell means that one could probably pick up F# or Scala relatively quickly. Learning new languages could thus also be a good career move, as you'll be able to switch between languages more easily.

Finally, I've learnt that having mentors guide you while learning a language makes the process so much more enjoyable and effective.

I've found the same. Learning from others is such a multiplier! From a practical point of view, how did you deal with all the setups for the different languages. I often find the thought of learning a new IDE a bit intimidating. Did you stick to an editor you knew while you worked through the languages, or vary it in order to try and get a more idiomatic experience?

For some languages, setting up a new development environment used to be a bit of a hassle, but nowadays most languages are fairly easy to setup. I then try to find an IDE that gives me the best experience for that specific language. As I alternately work on Windows and Mac OS, the IDE should also be cross-platform. An example of a great, cross-platform IDE is Visual Studio Code, which I use for the Haskell, JavaScript, TypeScript, Elm and Elixir tracks. For the other tracks, I use a JetBrains IDE: Rider for C# and F#, IntelliJ IDEA for Java, Scala and Kotlin, and finally RubyMine for Ruby (note: these are also cross-platform IDE's). As you can see, I use multiple editors to get the best experience for each language (although the Jetbrains IDE's are obviously quite similar).

Pro tip: if you are core contributor to an open-source project, Jetbrains allows you to apply for a free open-source license!

That's super useful. Thank you! So, you're a maintainer for C#, F# and Scala. What particularly draws you to those languages?

C# immediately became my favorite language when it was released in 2002. It is a well-designed, elegant language with great tooling and documentation. The language also evolves quite rapidly, which means that there are always new things to learn! One last plus is that it runs on the excellent .NET (Core) framework.

F# was also love at first sight. With elegant syntax and a rich set of (functional) language features, I found that I could do more with less code, particularly when doing domain modeling. It is also a very pragmatic language, with object-oriented features and great interop with existing .NET code (it runs on the same .NET (Core) framework that C# does). An additional strength is its tooling, which is amongst the best available for functional languages. As a bonus, it also has one of my favorite language introductions ever in the fsharpforfunandprofit website.

Scala was the language that introduced me to functional programming, so for that reason it holds a special place in my heart. Like F#, it is a pragmatic language, for much the same reasons. With its integration into Java's ecosystem, it has really helped popularize functional programming.

It's interesting that you got started with functional programming through Scala, mentor F#, but rate Haskell as the best track. For someone who wants to take the dive into functional programming on Exercism, which of those would you recommend they try first?

Great question! My vote goes to F#, as I feel it is the easiest language to pick up. This is mainly due to the F# language being less complex than the other two. F#'s excellent tooling and documentation are also a big plus when getting started. That said, I do highly recommend also joining the Haskell track once you're done with the F# track, as Haskell has some fantastic, advanced features that F# doesn't have.

You've been privy to quite a lot of our plans for the future of Exercism. Is there anything you're particularly excited about for the project?

Of all the improvements being planned, I'm most excited about the static analysis of solutions. The idea is that we'll setup a system that can automatically comment on submitted solutions, by programmatically analyzing those solutions for common issues/suggestions. This should help mentors a lot, as they would no longer have to comment on these common issues/suggestions and can focus on more interesting problems.

If you're interested, check out my (early) prototype of a C# track analyzer, which uses the .NET Compiler Platform to statically analyze C# code.

Yes, the static analysis is pretty much the most exciting thing for me too. It's awesome to see that you already have a prototype together. I think the speed improvements that static analysis will give us will dramatically improve Exercism, and I'm really excited about how we can extend it to teach total beginners to code. I think it's a real game-changer.

Final question, do you have any personal projects or causes that are close to your heart, which you'd like to give a shoutout too?

To me, getting involved in Exercism, contributing to its open-source code base and mentoring people has been an incredibly rewarding experience. I've learned tons of things, got to know some pretty great people and feel I have been able to help many people.

I would like to encourage people to see if they can get involved too. If you have a language you are passionate about and want to help people learn—sign up as a mentor on Exercism. If you prefer writing code, choose an open-source project and contribute. I promise it is far less scary than it sounds and you'll feel great doing it!

Awesome! Thank you for taking the time to chat and for all your work on Exercism!

Avatar of author
Jeremy Walker
Co-founder of Exercism. I'm an entrepreneur and software developer, and have been running a variety of businesses and non-for-profits for the last decade in the fields of medicine, education and artificial intelligence.
View Profile

Community Comments

Great article, I'm super excited for the blog!

Question for Erik: Has your work on Exercism helped you in other aspects of life outside of open source?

@Logan: Excellent question! Well, the first thing that comes to mind is that Exercism showed me how much people can benefit from a little help from others. I've tried to apply this to my non-working life too, and it has really had a positive effect on my life.

Furthermore, communicating on Exercism demonstrated how careful one has to be when communicating over the internet. It is so easy for a message to be interpreted differently from what you tried to say. This is why I always try to be very careful when formulating things online.

And lastly, in general working on Exercism and helping other makes me feel good!

Nice interview, and I'm excited about future posts on the blog.

Erik: As a long-term imperative programmer who has started to see the merits of FP but hasn't achieved anything like deep fluency I'm wondering if you could broadly describe a progression track in terms of languages, in terms of simplicity vs features? You mentioned F# as a good starting point; that's great, but if F# will get me N% of the way to Haskell is there an intermediate language (or two) to pick up between them? And broadly speaking what are the "killer" features that the more advanced languages have that the less advanced lack?

@yawpitch: Well, I would indeed suggest to start with F# to learn the basics (you could also do this in Scala of course if you're more JVM-minded). That would definitely teach you the most important functional programming concepts. As such, I don't think you would need an intermediate language to make the jump to Haskell. The "killer" features of Haskell are:

  • It is a purely functional language. Conversely, F# and Scala are not pure functional languages, they contain non-pure concepts (like mutability). Not having these non-pure concepts means that you have to solve some things differently than in other languages (like e.g. doing IO).
  • True laziness: in Haskell, computations are by default only executed when needed.
  • Type classes: this is quite an advanced concept that I would suggest you learn by doing :) This is also where the oft-dreaded monad concept comes into play. No

I think those concepts are the most important "advanced" concepts of Haskell.