Reactive @

Blog | about Scala, Reactive & Scalable applications

Because we're passionate about staying up-to-date with the newest trends in the industry and have the opportunity to work on interesting projects, we gain a lot of knowledge. On this blog we share our experiences to give something back to the community.

Receive FREE advice, tutorials and interesting articles right in your inbox by subscribing to our newsletter and learn how to succeed building Reactive & Scalable applications!

Play JSON in Scala: intro and beyond the basics

Yennick Trevels
Sunday March 22, 2015

Scala has many json libraries, and the Play-json library is one of them. It started as an integral part of the Play Framework, but has since then become a standalone project which can be used anywhere. I'll give a short summary of how the basic usage looks like, but then quickly dive into some special cases you might run into when implementing your custom parsers and provide short & sweet solutions.

Upcoming Scala and Akka Trainings Q1-2 2015 by Xplore Group Belgium

Yennick Trevels
Sunday February 1, 2015

As a Typesafe certified training partner we regularly schedule Scala-related trainings in Belgium. This post gives you an overview of our offer for the first half of 2015, which includes both the "Fast Track to Scala" and "Fast Track to Akka with Scala" courses.

Building a Microservice with Twitter's Finagle: Quick Start

Yennick Trevels
Saturday January 10, 2015

Microservices are becoming the de facto standard when it comes to architecting complex applications. Each microservice handles one small part of the application and can be deployed as a standalone service without having to run it in an application server. Twitter's Finagle project can help you build these microservices since it's a lightweight RPC system for the JVM to build high-concurrency servers. In this guide I'll show you how to get started building such a microservice with Finagle in a step-by-step process.

Scala tips: Improving the imperfect part 2

Yennick Trevels
Wednesday January 7, 2015

In this second entry in the 'improving the imperfect' series we'll have a look at three more interesting patterns that you can use to improve your Scala code. One about Scala pattern matching, another one about Scala implicits and finally a pattern that might be useful in your unit tests.

Scala tips: Improving the imperfect part 1

Yennick Trevels
Sunday November 16, 2014

You probably know the feeling you may experience when you look back at Scala code you wrote some time ago. You know that you can write the same code in a more concise and descriptive way.There’s nothing wrong with that, it’s part (of the fun) of learning Scala. In this post Yennick will show you some highly effective ways to improve your code for some of the most common cases.

Sorting on multiple fields and Tuples

Eric Loots
Friday November 7, 2014

In this post, a brief overview is given of how the implicit ordering on Tuples in the Ordering trait can be used to order sequences of objects. It also shows how implicits can be used to select a specific sorting scenario from a set of possible cases.

Futures and Thread pools

Eric Loots
Wednesday October 22, 2014

In this article we explore the utilization of Futures in the context of parallelization of code execution. We use the calculation of π as an example.

Slick: A new approach to database access in Scala

Yennick Trevels
Sunday October 19, 2014

Slick is a new approach to interact with databases. It's an open source library using functional-relational mapping (instead of ORM or object-oriented mapping) to query and update database tables. In this article Yennick provides you and overview on how it compares to traditional ORM frameworks and how basic usage looks like.

Scala: Why it should matter to you as a business owner

Yennick Trevels
Wednesday August 20, 2014

Scala, a programming language for the JVM, can be a game changer for your business and projects. Join me in an overview of what the language and its ecosystem can bring to your business.