Relearning Scala (Environment Setup)

##Introduction

I haven't learned anything new lately, so I decided to study Scala 3. Scala used to be somewhat popular, but recently I rarely hear about it. It may simply be because I no longer use Scala, but it feels like it has lost its momentum.

I played with Scala 2 a bit before Scala 3 came out, so I understand why Scala didn't catch on. Most of what I think is written in the following article, but for those trying Scala, some obvious perspectives seem missing.

Collecting the reasons Scala is difficult from the internet - Lambda Cocktail

I like Scala itself. C is annoying because of memory management, Java has a lot of non-essential boilerplate, and Kotlin is now used on the server side, but in the early days it felt like an Android-only language and not suitable for general use. Back then, functional programming was a new paradigm to me and very attractive. For some reason I accepted that paradigm easily at the time, but its difficulty still remains today.

If I add one more reason it didn't catch on, it would be immutability at the core of coding style.

What? Writing immutable code to improve maintainability is common sense, right? If you think that, modern languages and functional programming may have influenced you. Even today, beginners learn languages that assume mutable data. Python, Java, JavaScript, C, Go, PHP, Ruby, etc., are often written with mutable values in mind. Of course, these languages can be written without reassignment, but they generally accept mutable variables, so tutorials, books, and code in the wild often assume variables can change.

But what about Scala?

What happens when people used to such code start using Scala? You can use var in Scala, but val is used in many places. In other words, the default is to write code without reassignment. If you aren't used to reading or writing such code, this becomes the first barrier.

In modern times, ES6 has spread and people tend to avoid reassignment by using const, so perhaps immutability isn't as big a barrier as I think for beginners.

Anyway.

Let's set up the environment to start learning Scala 3.

##Environment setup

In the past, installing just sbt was enough, but now it seems common to use a tool called Coursier. After installation, cs list shows the commands it manages.

1
$ cs list
2
amm
3
coursier
4
cs
5
metals
6
sbt
7
sbtn
8
scala
9
scala-cli
10
scalac
11
scalafmt

I manage Coursier with Home Manager. If you do not use Home Manager, follow the official installation instructions.

1
{ pkgs, ...}:
2

3
{
4
  home.packages = with pkgs; [
5
    coursier
6
  ];
7
}

You can also manage sbt, the Scala compiler, and Metals with Home Manager, but I will manage those with Coursier.

Coursier is installed as the cs command. First, run the following to install basic commands like sbt, scala, and scalac.

1
$ cs setup

This installs sbt, but there is a problem.

The PATH is not set. Depending on your environment, zsh may not read .profile or .zprofile (as in my case), so I added this to .zshrc.

1
case ${OSTYPE} in
2
    darwin*)
3
        export PATH="$PATH:/Users/${USER}/Library/Application Support/Coursier/bin"
4
        ;;
5
    *)
6
        # setting for linux
7
        ;;
8
esac

This configuration only works on macOS. If you use Windows or Linux, adjust it as needed.

Now that sbt works, generate a basic project. For a minimal setup, run sbt new scala/scala3.g8.

1
$ sbt new scala/scala3.g8
2
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
3
SLF4J: Defaulting to no-operation (NOP) logger implementation
4
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
5
A template to demonstrate a minimal Scala 3 application
6

7
name [Scala 3 Project Template]: sample
8

9
Template applied in /private/tmp/./sample

This creates a folder containing code that only prints "Hello, World".

The directory structure looks like this.

1
tree sample
2
sample
3
├── README.md
4
├── build.sbt
5
├── project
6
│   └── build.properties
7
└── src
8
    ├── main
9
    │   └── scala
10
    │       └── Main.scala
11
    └── test
12
        └── scala
13
            └── MySuite.scala
14

15
7 directories, 5 files

The contents of Main.scala are very simple.

1
$ cat sample/src/main/scala/Main.scala
2
───────┬────────────────────────────────────────────
3
       │ File: sample/src/main/scala/Main.scala
4
───────┼────────────────────────────────────────────
5
   1   │ @main def hello(): Unit =
6
   2   │   println("Hello world!")
7
   3   │   println(msg)
8
   4   │
9
   5   │ def msg = "I was compiled by Scala 3. :)"
10
───────┴────────────────────────────────────────────

Let's run it. Move into the sample directory and run sbt run.

1
$ cd sample
2
$ sbt run
3
[info] welcome to sbt 1.10.5 (Azul Systems, Inc. Java 17.0.13)
4
[info] loading project definition from /private/tmp/sample/project
5
[info] loading settings for project root from build.sbt ...
6
[info] set current project to sample (in build file:/private/tmp/sample/)
7
[info] compiling 1 Scala source to /private/tmp/sample/target/scala-3.5.2/classes ...
8
[info] running hello
9
Hello world!
10
I was compiled by Scala 3. :)
11
[success] Total time: 1 s, completed 2024/11/17 19:24:17

We ran Hello, World, so I fully understand Scala now.

##Emacs

I want to develop in Emacs. I pay for JetBrains, so I could use IntelliJ, but Emacs is blazing fast on the new Mac mini, so I'll see how far I can go with Emacs.

In modern development, a Language Server is essential, so install Metals. Follow the official instructions to install Metals.

1
(setup scala-mode
2
  (:elpaca t))
3

4
(setup sbt-mode
5
  (:elpaca t)
6
  (:opt sbt:program-options '("-Dsbt.supershell=false"))
7
  ;; WORKAROUND: https://github.com/ensime/emacs-sbt-mode/issues/31
8
  ;; allows using SPACE when in the minibuffer
9
  (substitute-key-definition
10
   'minibuffer-complete-word
11
   'self-insert-command
12
   minibuffer-local-completion-map))
13

14
(setup lsp-metals
15
  (:elpaca t))
16

17
(setup dap-mode
18
  (:elpaca t)
19
  (:with-mode scala-mode
20
    (:hook dap-mode
21
           dap-ui-mode))
22
  (dap-auto-configure-mode))

I omitted the installation of lsp-mode.

When you open a .scala file, Metals installation is prompted, but following the prompt freezes Emacs. I couldn't tell if it was an environment issue, but installing Metals via Coursier avoided it.

1
$ cs install metals

After that, opening Scala source files makes Metals available, avoiding the freeze during installation.

Now you can view types.

##Conclusion

Environment setup for Scala 3 is done. I'll keep learning while writing blog posts.