Scala on Notes about stuff

Define a reusable and lazy pipeline

Mon, 06 Apr 2026 17:48:00 +0200

The problem

I have the idea of a pipeline: it is defined once, it can be reused and when called, it changes its state but does not evaluate eagerly, because it could be “fed” from an infinite source of data.

For example:

all integers which are multiple of 13 and has in its binary representation more ones than zeroes
indices of bytes read from /dev/random which are ascii characters

Perhaps there are two separate issues I’m thinking about here:

Some exercism and kata

Wed, 01 Apr 2026 12:08:00 +0200

Exercism Completed Phase 1 week 3 exercises on exercism:
1. hello-world
2. two-fer
3. raindrops
4. bob
5. hamming
6. pangram
7. isogram
8. difference-of-squares

Played with function composition in scala - implemented simple banner generator (see header of this and previous entry).

Also, learned about external process calling

  object Colors {

    abstract class ColorSource {
      //generate colors from string once
      lazy val into: List[Color] = {
        val hx = hexes()
        println(hx)
        hx.map(Color.decode)
      }
      def hexes(): List[String]
      def random: Color = into(r.nextInt(into.length))
    }

    class Pastel extends ColorSource {
      def hexes(): List[String] = {
        import scala.sys.process._
        val result = (Seq("pastel", "random","-s",  "vivid") #| Seq("pastel", "format", "hex")).!!
        result.split("\n").toList
      }
    }

    class Gradient(from: String="ffffcc", to: String="fd8d3c", n: Int = 5) extends ColorSource {
      def hexes(): List[String] = {
        import scala.sys.process._
        val cmd = Seq("pastel", "gradient", "--colorspace", "HSL", from, to, "-n", n.toString) #| Seq("pastel", "format", "hex")
        println(cmd)
        val result = cmd.!!
        result.split("\n").toList
      }
    }

    class Fixed(cols: List[String]) extends ColorSource {
      def hexes(): List[String] = cols              
    }

    def pastel: ColorSource = new Pastel
    def gradient(from: String, to: String, n: Int) = new Gradient(from, to, n)
    def fixed(cols: List[String]) = new Fixed(cols)
	
	/** ... */
}

Setting up rustlings failed. I probably messed up the configuration (or had old version of rustlings tool). Worked after removal of whole repo (minus execrises done so far),tool reinstall (cargo install rustlings), rustlings init and copying over my exercises.

Discover duplicated files

Sun, 29 Mar 2026 13:31:12 +0200

Problem

I have a directory where I store files: articles, images, notes - in a bit unordered and random fashion: I copy them from other devices, generate some files requried for teaching sessions or create subdirectrories for experimentation.

As a result, this directory is messy and contains a lot of duplicated files. Some of them are quite big (think: .epub or .pdf, not linux distro .iso).

So, I thought, this is a good candiate for a practical problem solving exercise joined with language learning practice for Rust and Scala.

So what Options do I have?

Tue, 17 Mar 2026 13:20:32 +0100

Option types

Option type documentation:

Same names, a bit different API

Scala

In Scala the variants are called: None and Some which are final case subclasses of Option. I’ve noticed the subclassing has the nice property of helping in IDE to discover the variants (which is also the case, for example, for Try subclasses.

Rust

In Rust, the variants are also conveniently named Some and None.

Scala AND Rust ?

Sat, 14 Mar 2026 05:44:57 +0100

Science based programming language learning

Exploring two prorgamming languages at the same time seems like a bad idea, doesn’t it? Well, good learning sources say that the best approaches to effective, expert learnings are:

interleaving (study both languages concurrently — never sequentially)
spaced repetition
deliberate practice at the edge of your comfort zone
retrieval practice (close the docs)
and the explanation effect

Looks like a very good idea to me.

Scala learning path

Fri, 27 Feb 2026 00:00:00 +0000

Perhaps Gemini could plan my learning of Scala?…

Yes, it can.

See:

I wish me good luck.

Credits

Gemini.

Back to Scala

Wed, 25 Feb 2026 00:00:00 +0000

Discovery

Leaving a familiar ground of Java, Maven and Spring Boot, and switching back to another JVM language - Scala - shouldn’t be a Big Deal, right?

Especially when once upon a time I did complete two Cursera courses about Scala and Functional Programming, which - as far as I remember - were really eye-opening, rewarding and funny.

Let’s dive into remote memories…

When I was learning Clojure, I had one issue (no, it was not about parenthesis; those serve me well) and it was: learning Emacs. An adventure of its own. Also, some language concepts needed to settle in my head. My fingers needed to learn paredit shortcuts. And I had a lot of fun.