Today we’re excited to welcome Dick Wall, who will be joining Typesafe as a developer advocate. Dick has played an important role in the Java and Scala communities, running podcasts, hosting trainings and giving talks all over the world. We’re incredibly excited and honored to have him on our team. 

Welcome, Dick!


Typesafe: You might be best known for the Java Posse podcast, the first and still the most popular Java programming podcast. Can you tell us about your path to Java and what led you to become involved in the Scala community? Why now?

Dick: When I started the Java Posse Podcast with 2 of my good friends: Tor Norbye and Carl Quinn (later adding Joe Nuxoll, and later still, Chet Haase) to the mix, it was because I wanted to stop wasting my commute time and use it instead to keep up to date on my work and other topics. Like many people, I was an enterprise Java developer in my career at the time. Finding Linux podcast material at the time was possible, but there was nothing specifically for Java back then, so in the manner of all things open source, I stepped up to scratch my own itch. We didn’t know where it would go at the time, and knew little about community, it was a bit of a trial by fire.

Fast forward about 4-5 years into the Java Posse, and a recurring theme had become common in the Java space. A combination of feature paralysis in the Java language, and lots of other interesting options emerging in other spaces like Ruby and .NET made it seem like the future of Java was getting bleak. Like many people, I started casting around for an alternative and Carl pointed Scala out to me. It took me about 2 weeks to become infatuated with the language. That was around 5 years ago now.

I teamed up with Bill Venners (co-author of Programming in Scala) around 3-4 years ago and we started offering on training courses for Scala. Around the same time, the ecosystem grew large enough that I could start working in Scala full time, and I have done since then.

Community is a habit, a hard habit to break, and there is always a demand for community work, so I kept my hand in there, talking at user-groups and conferences about Scala, and setting up the Bay Area Scala Enthusiasts (one of the first Scala user groups).

So, why now is a difficult question because there hasn’t really been a “now” moment, it’s something that I inexorably drifted into over the past few years. I have chosen to join Typesafe at this time because I think the time is right and it’s the most effective way I can help the community right now.

Typesafe: What Scala feature are you most excited about?

Dick: I read this to mean Scala language feature, and I can’t answer just one so I will try and keep it to only a handful instead.

The highest on my list is the humble case class. Having as little as a single line of source code bring into being a value type based on best practices profoundly changes the way you can use a type system. Any function parameter or return value can now be a distinct type with almost no effort, and can have named fields, equality that works, and the compiler can “know a hawk from a handsaw” which is a vast improvement over “stringly typed” interfaces.

Case classes are used everywhere in Scala. You can throw a pure domain model together in just a few lines to model your problem domain, create APIs and builders that are easy to discover and use, and build up algebraic data types for all sorts of purposes.

Of course, no mention of case classes would be complete without mentioning pattern matching. Case classes come with deep pattern matching enabled out of the box, and this allows you to solve all sorts of problems in another way than relying on deep (and often obscure) inheritance hierarchies. It is very much in the philosophy of Scala to allow you to choose which way you want to code - inheritance and polymorphism are still very much available, but sometimes a well used pattern match makes things much easier.

Traits are, of course, one of the great differentiators for Scala as well, and have led to many new patterns of usage, as well as giving back most of the benefits of multiple inheritance whilst dealing with most of the issues. Traits also allow ideas like type-classes and contexts to be implemented more freely without the worry of burning your single base class, or being stuck with the lion’s share of the work (as you would face with Java’s interfaces, for example)

My final choice for now would be implicits, particularly implicit parameters and the use of implicit evidence and context bounds. Implicit conversions can also be amazingly useful but need to be used thoughtfully and carefully. Implicit parameters are where the real action is though. Coupled with traits and case classes, you can implement pure domain models with no bleed over from concerns like persistence, and then implement the persistence through the use of typeclasses, which cleverly bring traits and implicits together to make a powerful and elegant solution to the problem without compromise. This is another reason I like the many features of Scala, they can be combined in patterns like these to greatly increase the value of the whole beyond the sum of the parts.

There are many other features that I could mention, of course, but I think this is a long enough answer already :-).

Typesafe: You’re first and foremost an engineer, and you’ve been involved in the community for a long time now. What new initiatives will you be involved with now that you’ve joined Typesafe?

Dick: When I worked Google I was involved early in their Developer Operations division (really as it was being assembled). It’s called DevRel (Developer Relations) now, but the aim is the same, to put real engineers in a place where they can be of the most use to engineers external to the company. It tends to be an area overlooked all too often.

Software developers don’t like a lot of smoke and mirrors. They don’t want to be told that this feature is awesome, only to find out that it doesn’t really work. What they need to be told is “this doesn’t work right now. It will within the next 3 months, but for now here is your workaround”. Those are the kind of facts that help developers make the right decision, deliver software and also build trust between entities and communities.

At the same time, a developer advocate (my official title) knows that it is not just a one way street. Seeing, and understanding, the real world needs of people using Scala and other Typesafe technologies is essential to their continued use and usefulness, and providing a high-signal, low-noise channel back to the Typesafe engineers will be a big part of the advocacy program and something that Kevin and myself will work hard on.

Of course, an engineer isn’t any use if he or she forgets how to be an engineer. Not only that, but I would be bored if I didn’t write code regularly. My aim is to try and bring all these factors together, to help developers through their problems while listening to their wishes and concerns, add value into the Typesafe products whenever I can and stay grounded in the code. One of my first ideas is to increase integration between Typesafe Activator and github, it’s the kind of goal that suits all the criteria.

One more thing we are looking to do is to expand an internal program to identify Scala spokespeople already out there in the community doing good work, and to help them be more effective, for example by connecting them with Scala user group organizers when they travel and other ideas that help increase their reach.

Typesafe: You run trainings at Escalate Software; tell us more about Escalate and your involvement?

Dick: Escalate Software (consisting of Bill Venners and myself) was one of the earliest companies to offer Scala training in the US, possibly in the world. We have consistently offered the Stairway to Scala Applied and Advanced courses for 4 years now (I just looked and our first open course was in San Francisco almost exactly 4 years ago). We came up with the name Applied fairly quickly because it seems like there is a bit of a social stigma (at least in Silicon Valley) to attending an Introductory or Beginner’s course, and in fact it’s a poor name for it anyway, since the material comes at you pretty fast and it’s not a simple 101 introduction.

About a year and a half ago we also became official Typesafe training partners, and now offer Play and Akka courses directly from the Typesafe training materials in addition to our stairway courses. We still do training regularly, both internal for companies and also open courses (in fact we have the Advanced and Akka courses coming up around the Scala by the Bay conference in a couple of weeks). You can always find out the latest on the open courses and other information about us at our website:

Typesafe: Thanks, Dick, and welcome aboard!



View All Posts or Filter By Tag


Going Reactive 2016

White Paper

Microservices In Production

White Paper

Fast Data: Big Data Evolved

White Paper

An Introduction to Reactive Streams, Akka Streams and Akka HTTP


Reactive Platform: Monitoring 1.0, Commercial features &...