Scala on Dev notes

How to run sbt tasks with custom settings

Wed, 01 Oct 2025 00:00:00 +0000

When preparing build configuration in sbt, you might want to write custom sbt task. Task in sbt is like a function that can depend on other tasks and project settings.

Custom sbt tasks

To illustrate it, let’s write a simple task that validates environment, runs tests and builds an app

import sbt.*

lazy val validateAndBuild = taskKey[Unit]("Validates env, runs tests and builds the app")

val root = project.in(file(".")).settings(
  validateAndBuild := {
    validateEnvVars
    test
    assembly
  }
)

Tasks vs immutable settings

This can be handy when the project grows in complexity. One problem with this approach is that we don’t control the inputs to the sub-tasks that we run. In sbt, settings are initialized when the project is loaded and are not mutable.

Scala Tooling Spree #1 recap

Fri, 31 Jan 2025 00:00:00 +0000

On January 30, 2025, the first Scala Tooling Spree took place, and I had the pleasure of being part of it. Here’s a recap of the event. Spoiler alert: it was awesome!

Event details

The first Scala Tooling Spree was announced on Discord and Bluesky. The event brought together 9 participants who formed 4 teams. Over the course of a 2-hour call, we tackled 4 issues, resulting in 3 pull requests. We had participants with diverse backgrounds, ranging from business application developers to tooling and compiler engineers. Each team had at least one experienced tooling maintainer, ensuring we were never short on expertise!

Understand your build structure and performance

Wed, 29 Jan 2025 00:00:00 +0000

TL;DR: Today I learned that you can trace your build performance with bloop, and it’s especially easy when using Metals. The setup might not be obvious for some.

When working with multi-module projects, build times can sometimes increase unexpectedly. There are a few ways to analyze that statically, but you can always see the live data from your bloop compilation. Let’s explore those options.

Static analysis

When your build.sbt file grows complex it’s easy to lose track of which depends on which. This not only creates confusion and complicates onboarding, but also to slower builds and frustration in consequence.

Useful commands for inspecting sbt build

Wed, 29 May 2024 00:00:00 +0000

TL;DR Today I learned a few useful commands to help you understand complex sbt builds.

task timing

JAVA_OPTS=-Dsbt.task.timings=true sbt

inspecting task

inspect module/taskName

inspecting task tree

inspect tree module/taskName

Hide irrelevant data in your PRs

Fri, 05 Jan 2024 00:00:00 +0000

TL;DR Today I learned that you can hide irrelevant changes from Github PRs. The syntax for .gitattributes can be tricky though.

In my current project, it’s sometimes necessary to re-generate and commit a bunch of files to the repository. This can happen when you store some IaC or test data in the repository.

Sample repository

To demonstrate the problem, here’s an example repository: https://github.com/majk-p/nice-pr-diffs that features two PRs:

The first one is hard to read https://github.com/majk-p/nice-pr-diffs/pull/1/files because it features a wall of text - new testing data that has been added.

Integration testing with Weaver and Localstack

Fri, 29 Dec 2023 00:00:00 +0000

When creating software that makes heavy use of cloud infrastructure, it is wise to test the integration in the end-to-end fashion. Doing so in cloud environment is one option, but it may not be viable for all cases. It can be pricy and you cannot do it in an local environment.

A popular solution to this problem is to run Localstack and test your code against it. In this post we’ll explore how to manage your Localstack resources for E2E tests using Testcontainers, Cats-effect Resource and Weaver.

Introduction to optics in Scala

Tue, 11 Jul 2023 00:00:00 +0000

Throughout this blog I’ve mentioned the benefits of having a strong type system a multiple times. I’ve covered type refinement for value validation, beginner friendly and advanced approach to type-class derivation or type-safe approach to messaging with pass4s.

The possibilities are endless though, so today I want to introduce another topic, that beginners in languages like Scala or Haskell might not be aware of.

In this post I’ll talk about Optics.

Meet Optics

Optics is an umbrella term for accessing and transforming immutable data. We’ll explore the world of optics with the great library Monocle. Before we get started, let’s set the stage and with some problem we can refer to.

Intermediate's guide to derivations in Scala: Magnolia

Sun, 07 May 2023 00:00:00 +0000

In the previous post about Scala derivation I’ve explained the idea of derivation and showed how we can benefit from it by using library-provided derivations. This time let’s dig deeper and implement our own derviation with Magnolia.

TL;DR This post is intended for intermediate Scala users, if you are not familiar with the topic I recommend starting with the beginner introduction first

♻️ Recap

TL;DR you can skip this section if you remember the previous post, it’s just a recap

Beginner's guide to derivations in Scala

Sun, 23 Apr 2023 00:00:00 +0000

When learning about Scala, there are a few things that might be surprising. One of such mechanisms is code derivation. With this post I want to demystify the term for those of you who are learning Scala and functional programming in general.

TL;DR This post is intended for Scala beginners and does not go into the details of building your own derivation. Instead, it shows the client side of things, aiming to show the impact on the code simplification.

Tech bytes #5 in Kraków recap

Thu, 16 Mar 2023 00:00:00 +0000

Last Thursday (13.04.2023) I had the pleasure to speak at the 5th edition of Tech Bytes in Kraków.

TL;DR This post is a short recap of the event

🔧 The right tools for the right job

This edition had two talks scheduled, both focused on programming languages, specifically Scala and Elixir. “The right tools for the right job” was the topic of the meeting.

The talks were:

Get rid of boilerplate with Scala by myself
What is Elixir and what it can do with concurrency challenges? - sharing Elixirator insights by Józef Pawlikowski and Alexander Sosnovskiy

Sadly Alexander wasn’t able to join us but Józef did his best to present his peer’s part.

Beginner's guide to toolkits in Scala

Sat, 11 Mar 2023 00:00:00 +0000

So you are learning Scala and see all the news about scala-cli and it becoming the new scala runner, Scala Toolkit, Typelevel Toolkit and things become a little confusing?

This post is here to help you understand what’s going on. To make some sense of it, let’s tell a bit of a story.

💻 Scala runner and scala-cli

First of all, what’s Scala runner? basically it’s the program that you launch by typing scala in your terminal. It can launch a basic REPL or run provided Scala file, but not much more.

Wrocław Scala User Group #2

Sun, 29 Jan 2023 00:00:00 +0000

In this post I want to share a short recap of first Wrocław Scala User Group (WSUG) meetup. This will be kind of TIL entry, it doesn’t aim to cover the full presentation content. If you’d like to join the next meeting, join us at Wroclaw Scala User Group at meetup.com. The meetup was held in Polish so the slides are not translated.

First talk - ‘Pain-free APIs with Smithy4s’ - Jakub Kozłowski kubukoz

In this talk Jakub introduced us to Smithy - an IDL (Interface Definition Language) built for defining implementation agnostic API descriptions. During the talk we have focused on the aspects that are difficult when designing and evolving a system, namely the communication problems.

Wrocław Java User Group

Sat, 14 Jan 2023 00:00:00 +0000

In this post I want to share a short recap of first Wrocław Scala Java Group (WSUG) meetup. This will be kind of TIL entry, it doesn’t aim to cover the full presentation content. You can find the full agenda at the event page. If you’d like to join the next meeting, join us at Wroclaw Java User Group at meetup.com.

We just had one talk this time, and it was delivered by yours truly.

Scala type bounds - <: vs <:<

Fri, 16 Dec 2022 00:00:00 +0000

In this short entry I want to shed some light at the difference between <: and <:< in Scala.

TL;DR

<: is a language feature built into the compiler: upper type bound
<:< is it’s generalization: generalized type constraints - it’s provided in the standard library

Let’s start with the first one. <: is called the upper type bound. We use it to express type boundaries for generic types as for example here:

TIL: Mimic value class in Typescript

Thu, 15 Dec 2022 00:00:00 +0000

TL;DR Today I learned how to mimic Scala-like value class in Typescript

Doing day to day scala I often use value classes to model the data like:

final case class UserId(value: String) extends AnyVal
final case class City(value: String) extends AnyVal

This is especially useful when you want to add some meaning to primitive types. It also makes the compiler help you to avoid passing irrelevant data to downstream methods.

Read more about value classes in the documentation https://docs.scala-lang.org/overviews/core/value-classes.html.

Wrocław Scala User Group - first meetup

Tue, 13 Dec 2022 00:00:00 +0000

In this post I want to share a short recap of first Wrocław Scala User Group (WSUG) meetup. This will be kind of TIL entry, it doesn’t aim to cover the full presentation content. You can find the full agenda at the event page. If you’d like to join the next meeting, join us at Wroclaw Scala User Group at meetup.com.

This is my second post in #100DaysToOffload.

First talk - Scala CLI - what’s the new Scala runner capable of? by Łuksz Wroński lwronski

This talk was strictly focused on scala-cli, a great command line utility for working with Scala. I’ve already introduced it in some of my articles (e.g. refined). If you’re not familiar with the tool, I strongly recommend visiting the getting started page, the documentation is really good and there’s no point rewriting it here.