In this post we will be exploring a more advanced pattern from functional programming - Tagless Final. Our goal will be to show how we can use it make our programs on one hand simpler, on another easy to extend
In this article you will learn how to set up GraphQL backend server with Akka HTTP and Sangria. We will also discuss common use cases, like integration with Slick and how to manage many-to-many relations.
What are the implications of boxing/unboxing? How can we decrease heap memory allocation? Read on to find out
Some say, the best way to learn is by example. In this post we will grab the 'Each' library by ThoughtWorks, explain why it's useful, how it was designed (macros, implicits and other cool Scala stuff) and try to reuse them in our code. The goal is to learn by exploring Each and pick up some Scala ideas along the way.
In this post we look at two approaches to dealing with domain specific types - unboxed tagged types and case classes and how well they integrate with play framework 2.4 and slick 3.0.
If you want to know how to use `akka-http` to build your own server, you may find it worth your while reading this article. You'll learn how to build a websocket server. Some other topics are covered here, e.g. basic REST responses or akka-stream processing.
In Scalac we use Slack for communication and more. We decided to create a framework for our custom Slack integrations, so we transform it into a living heart of our company. Here are some details on how and why we did that
In this blog series we will look on how we can use Akka HTTP, Activate and other useful libraries to build an application completely in Scala. This post will explore the persistence layer and how we can use STM to work with the database
In this tutorial series we will look on how we can use Akka HTTP, Activate and other useful libraries to build an application completely in Scala. We will explore each component in detail explaining various techniques and approaches. The first part we will lay the foundation for our app and in the next parts we will be extending this framework.
A lot of dynamically typed languages have function that catch-all all messages doesn't exists in the object. It gives these languages a lot of power to write DSL. With Scala, you have an opportunity to write DSLs in the same way. Learn why and how.
In this post we explore possibilities of rapid prototyping in our favorite programming language using Skinny framework
Akka Streams is an exciting new technology from Typesafe that is an implementation of the Reactive Streams specification. RabbitMQ is a messaging broker implementing AMQP 0-9-1 protocol. It's known for its reliability, speed and simplicity in everyday use. These two technologies seem like a perfect fit, so in this post I'm going to explore some basic integration possibilities and example usage.
Preparing environment for integration tests is not easy. Usually you need to run one or more external services - database, rabbitmq, web server, etc. What's more, you have to be sure that they are up and running. After performing the tests you have to be able to turn them off. My plugin makes it possible to start all required applications directly from SBT console with minimal effort.
A few weeks ago I've started coding in a big Lift project. One of my first tasks was to create a simple HTTP API for communication with underlying Akka actors. This one was easy thanks to RestHelper. Second task was to add request rate limiting for this API. It appears that Lift despite its many features doesn't have rate limiting plugin. So, I had to roll my own.