Scala

Game Development

Vulkan Drawing Loop: The First Triangle

This is the third article in a series introducing the Vulkan graphics API. We'll build upon the previous two articles and draw our first triangle on the screen.

Game Development

Vulkan Graphics Pipeline

This is the second article in the series covering the Vulkan graphics API, its organisation and how to get started with it. We'll cover the concept of a graphics pipeline and how one can leverage features of Scala to effectively set it up.

Scala

Vulkan setup in Scala

Vulkan is a modern API to access graphics cards and use them for rendering and other purposes. This is the first article in a series that covers how Vulkan API is organised an how one can get started with it. We'll use Scala as an example target language.

Scala

Context Function for DSL Design in Scala

A strong side of Scala is its DSL capability. DSLs, or domain-specific languages, are programming languages designed for convenient expression of operations in a certain domain. An example of such a DSL is the one I designed for Simple Rockets 2 – SR2 Compiler. That DSL can be used to program

Scala

Launching Rockets with Scala

If you’re an aerospace hobbyist, there’s a good chance that you’ll have a ton of fun with Simple Rockets 2. It’s a game where you build and fly rockets. Similarly to Kerbal Space Program, it allows you to pick up basic rocket science casually while playing

Scala

Following Causal Chains in Dotty Codebase

In this article, I'm sharing my process of learning how to fix issues in complex codebases, such as the one of the Scala 3 compiler (otherwise known as Dotty).

Scala

Debugging Complex Scala Code: Tried and True Approaches

In this article, I'd like to describe how my processes evolved and what breakthrough moments I had while fixing bugs in Dotty. Tooling Having the right tools while working on a problem is paramount. Try writing your next project in Notepad. No syntax highlighting, no code completion, no

Scala

Effect Extensions Pattern

When programming in a purely functional style, we aim to reify side effects into data structures called effect types. An effect type you are using should be the same throughout the entire application so that different parts of the application are composable. When having multiple side effects and a single

Scala

Implicits mechanism in Scala

Motivation There are three things Scala implicits mechanism is good for: * Conversion from one type to another * Method injection * Dependency injection Conversion from one type to another may be needed when a variable of one type is used where another type is expected. For example, a java.lang.Integer is

Scala

Introduction to Type classes Webinar

Hello, It is my pleasure to invite you to a free webinar of mine where I am going to introduce type classes and some basic usage of them in purely functional libraries. The webinar will take place on Sunday, April 2nd, 3 PM UTC. The content covered will include: * An

Scala

Introduction to Recursion Schemes with Matryoshka

Recursion is the GOTO of functional programming - Erik Meijer^1 Recursive data structures In our daily programming life, we encounter recursive data structures on a regular basis. The best-known examples include linked lists and trees. Often working with such data structures we have a need to evaluate (collapse) them

Scala

Rewriting Process Algebra, Part 3: FreeACP Implementation

This is the third part of my progress report on a rewriting-based implementation of SubScript, FreeACP. This part covers the architecture of FreeACP I came up with so far while implementing the rewriting engine for SubScript. If you have not read the previous parts of this report, you are advised

Scala

Rewriting Process Algebra, Part 2: Engine Theory

This is a second part of a progress report on my attempt to model a process algebra as an expression rewriting machine. This part covers the theoretical foundations of the two implementations (engines) of SubScript: the standard one, and FreeACP, the one I am building. The other two parts: * Rewriting

Scala

Rewriting Process Algebra, Part 1: Introduction to Process Algebra

This is the first part of a progress report on my attempt to model a process algebra as an expression rewriting machine. The process algebra in question is SubScript, which is an extension of ACP. It is recommended to familiarize yourself with ACP and process algebras before reading this article

Scala

Dissecting Shapeless: Poly

In this article, I would like to analyse the architecture of Shapeless' polymorphic functions and their inner workings. If you are new to Shapeless, you may want to read the first article of the series: Learning Shapeless: HLists. This article does not aim to introduce polymorphic functions or provide

Scala

Dissecting Shapeless: HLists

Shapeless is a Scala library that aims to make programming more type-safe. This means that you let the compiler know as much as possible about your program, so that if something is wrong with it, it is more likely to be caught during compile time. Since a lot of the