Lab 01 - Scala & Sbt Basics

Organizational notes

Each lab, starting from the next one, you receive a practice task. Every practice has a one-week deadline.
In total labs cost 20% of the final grade
Labs submissions will be organized using Github Classroom, where you will get assigments in individual repos. DO NOT PUSH ALL CODE TO MASTER. You should create a new branch, push all code into it and open pull request onto master. Only in this case Github Action job with autotests will run.

Integrated Development Environment

You can use any editor to write Scala code. But there are two of the most comfortable IDE:

Intellij IDEA
VS Code

Both requires specific Scala plugins to correctly work with Scala code

Intellij IDEA

Pros:

Best code navigation
Everything works out of the box

Cons:

High memory consumption

VS Code

Pros:

Lightweight
Fast incremental compilation

Cons:

Requires additional build tools like Metals to get rich functionality
Sometimes unstable having navigation bugs as the tool is a new one

It is up to you to choose IDE you like, but I recommend to use Intellij due to its ease of use

SBT: Scala build tool

Most popular and mature build tool for Scala used in most of the projects

Uses Scala to write build specification code

Intellij Idea automatically includes sbt for every project that uses it and has interactive sbt shell

Requires user to have JDK 8/11/16, but Scala does not take much advantage from jdk 8+ features

## Sbt
					### Basic commands
					```console [1-9|1|2|3-4|5|6-7|8|9]
					user@mac example % sbt
					sbt:example> compile
					sbt:example> projects # list all project modules
					sbt:example> project moduleName
					sbt:example> reload # Reloads the build definition
					sbt:example> moduleName/run # run main app
					sbt:example> moduleName/test # run all tests
					sbt:example> clean # Deletes all generated files
					sbt:example> help
					```
					---
					### Build files

- Main build file for every project is `build.sbt`
					- Also there are auxiliary files under project folder: `plugins.sbt`, `build.properties` (here sbt version is specified)
					- Example of simple `build.sbt` file:

```scala [1-6|1|2-4|6]
					scalaVersion := "2.13.3"
					name := "hello-world"
					organization := "kek.shrek"
					version := "1.0"

libraryDependencies ++= Seq("org.scala-lang.modules" %% "scala-parser-combinators" % "1.1.2")
					```
					---
					- More modular structure:

```scala
					import Dependencies._

ThisBuild / scalaVersion := "2.13.3"
					ThisBuild / version := "1.0"

lazy val root = (project in file("."))
						.settings(
							name := "example",
							libraryDependencies ++= Seq(parser.combinators)
						)
					```
					- project/Dependencies.scala:

```scala
					import sbt._

object Dependencies {
						object parser {
							val version = "1.1.2"
							val combinators = "org.scala-lang.modules" %% "scala-parser-combinators" % version
						}
					}
					```
					---
                    ### Dependencies management
                    To add new dependencies to project one should use sbt settings key `libraryDependencies`.

A dependency value consists of:
                    * groupId (organization)
                    * artifactId
                    * revision (version)
                    * configuration (optional), e.g. Test which adds only code from dependency test module

And a full value looks like `"groupId % artifactId % revision"`.
					---
                    You can add Maven dependencies like this, but a problem arises with Scala specific dependencies.

Since Scala has different version, most of which dont have backward compatability, library publisher should provide sources for each scala major version: 2.12, 2.13

Sbt can automatically fetch dependency for your project's Scala version by specifying a dependency value like:
                    `libraryDependency += "groupId % artifactId %% revision"`
					---
                    Remember that dependencies are transitive meaning that a dependency can add its own dependencies to your project
                    and they can potentially override some libraries versions if they are older than transitive ones

<img src="https://gcdnb.pbrd.co/images/omJw810kjdpc.png?o=1" width="600" height="400"/>
					---
                    Not all packages live on the same server; sbt uses the standard Maven2 repository by default.

If your dependency isn’t on one of the default repositories, you’ll have to add a resolver to help sbt find it.

To add an additional repository, use sbt key `resolvers`:
                    ```
                    resolvers += name at location
                    ```

e.g.
                    ```
                    resolvers += "Sonatype OSS Snapshots" at "https://oss.sonatype.org/content/repositories/snapshots"
                    ```
					---
					### Plugins
					* Plugins define a sequence of sbt settings that are automatically added to all projects or that are explicitly declared for selected projects. Plugins should be added to project/plugins.sbt file
					* Two useful plugins are:
						1. scalafmt - allows to specify code formatting settings as a configuration file
						2. dependencyTree - allows to browse dependency graph of the project and find deps which version conflicts and overrides one another
					---
                    Some plugins are universal ones which are helpful for every project, e.g. `dependencyTree`.

To use them automatically in every project you can add them as a global sbt plugin in `$HOME/.sbt/1.0/plugins/build.sbt`
                    ```
                    addSbtPlugin("net.virtual-void" % "sbt-dependency-graph" % "0.10.0-RC1")
                    ```

Organizational notes

Integrated Development Environment

Intellij IDEA

VS Code

SBT: Scala build tool

Practice time