<p>In this chapter we will cover to set up Scala locally and will try to understand how Scala works with JVM.</p><p>Most of the learners come from Java background, we will try to compare steps along with Java perspective as well.</p><h2>Install Scala and Set Up the JVM<br></h2><h3><br></h3><h3>Understand the tools you need</h3><p>​Before installing Scala, understand the role of each component.</p><table><thead><tr><th><div>Component</div></th><th><div>Purpose</div></th></tr></thead><tbody><tr><td><div><strong>JDK</strong></div></td><td><div>Provides Java development tools and the JVM runtime.</div></td></tr><tr><td><div><strong>JVM</strong></div></td><td><div>Executes JVM bytecode produced by Scala and Java compilers.</div></td></tr><tr><td><div><strong>Scala compiler</strong></div></td><td><div>Compiles Scala source code into JVM bytecode.</div></td></tr><tr><td><div><strong>Scala CLI</strong></div></td><td><div>Runs, compiles, and tests Scala programs from the command line.</div></td></tr><tr><td><div><strong>IntelliJ IDEA</strong></div></td><td><div>Provides an IDE for writing, running, and debugging Scala code.</div></td></tr></tbody></table><p><br></p><p>The basic execution flow is:</p><blockquote><p><strong>Scala source code → Scala compiler → JVM bytecode → JVM → Program output</strong></p></blockquote><div class="se-component se-image-container __se__float-none" style="width: 100%"><figure style="width: 100%;"><img src="https://api.cstechie.com/upload/editor-image/2026/56834c7e-077a-469d-ac1c-7befdbd06492.webp" alt="scala Execution Flow" data-rotate="" data-proportion="true" data-size="100%," data-align="none" data-percentage="100," data-file-name="Scala Execution Flow Infographic.png" data-file-size="1550730" data-origin="," style="width: 100%;"></figure></div><p><br></p><p>For example, when you write:<br></p><pre class="__se__code-scala">println("Hello, Scala!")<br>​​<br></pre><p class="__se__code-scala"><br></p><p>The Scala compiler translates your code into JVM bytecode. The JVM executes that bytecode and displays the output.</p><p><strong>Important:</strong> The JDK includes the JVM, so you generally do not need to install the JVM separately.</p><p><br></p><h2>Install an IDE (Optional)</h2><p>You can write Scala in any text editor, but an IDE makes development easier.</p><p>A common choice is<span class="__se__t-shadow"> </span><a href="https://www.jetbrains.com/idea/?utm_source=chatgpt.com"><span class="__se__t-shadow">IntelliJ IDEA</span></a> with the Scala plugin.</p><p>The basic setup is:</p><ol><li>Install IntelliJ IDEA.</li><li>Install the Scala plugin through the IDE's plugin settings.</li><li>Open or create a Scala project.</li><li>Configure the JDK.</li><li>Select the Scala version required by the project.</li><li>Run your program.</li></ol><p>The Scala version configured in the project is more important than the globally installed default. Existing projects may use Scala 2.12, Scala 2.13, or Scala 3.</p><p><br></p><h2>Troubleshooting Common Issues<br></h2><table><thead><tr><th><div>Problem</div></th><th><div>What to check</div></th></tr></thead><tbody><tr><td><div><code>java: command not found</code></div></td><td><div>Install the JDK and configure <code>PATH</code>.</div></td></tr><tr><td><div><code>javac: command not found</code></div></td><td><div>Verify that a JDK, rather than only a runtime, is installed.</div></td></tr><tr><td><div><code>scala: command not found</code></div></td><td><div>Complete the Scala installation and reopen the terminal.</div></td></tr><tr><td><div>Wrong Scala version</div></td><td><div>Specify the required version in the command or project configuration.</div></td></tr><tr><td><div>Compilation error</div></td><td><div>Check the Scala syntax and compiler version.</div></td></tr><tr><td><div>IDE cannot find the JDK</div></td><td><div>Configure the project JDK in the IDE settings.</div></td></tr></tbody></table><p><br></p><h2>Lesson Summary</h2><p>You now know how to prepare a local Scala development environment.</p><ul><li>Install a compatible JDK.</li><li>Understand the relationship between Scala, the compiler, bytecode, and the JVM.</li><li>Install Scala tools using Coursier.</li><li>Check your installed versions.</li><li>Run a Scala 2 program using Scala CLI.</li><li>Prepare an IDE for larger projects.</li></ul><p>​<br></p>

Installation & Verification

Run Your First Scala 2 Program

Scala Setup And Installation Locally

Hello Scala

<blockquote class="__se__format__range_quote_note"><p><br></p><h2>Course Objectives</h2><p>By the end of this course, you will be able to:</p><ul><li><p><strong>Understand Scala from the basics:</strong> Learn Scala step by step, from basic syntax to advanced programming concepts.</p></li><li><p><strong>Learn Scala 2 and Scala 3:</strong> Understand both versions and compare their syntax, features, and key differences through side-by-side examples.</p></li><li><p><strong>Practice while learning:</strong> Write, run, and experiment with Scala code using interactive examples and coding exercises.</p></li><li><p><strong>Master object-oriented and functional programming:</strong> Understand classes, objects, traits, case classes, higher-order functions, and other important concepts.</p></li><li><p><strong>Understand how things work:</strong> Go beyond syntax to learn why a feature exists, how it works, and when to use it.</p></li><li><p><strong>Write clean and efficient code:</strong> Learn best practices, common mistakes, debugging techniques, and performance considerations.</p></li><li><p><strong>Apply Scala to real-world problems:</strong> Work with collections, error handling, asynchronous programming, and other concepts used in backend development.</p></li><li><p><strong>Build practical applications:</strong> Gain hands-on experience by developing projects using Scala and the Play Framework.</p></li><li><p><strong>Prepare for technical interviews:</strong> Strengthen your understanding through coding challenges, conceptual questions, and practical problem-solving exercises.</p></li><li><p><strong>Become a confident Scala developer:</strong> Develop the skills to read, understand, write, and maintain Scala applications in real-world projects.</p></li></ul><p>​<br></p></blockquote>

Objective of This Course

<h2>What is Scala?</h2><p>Scala is a general-purpose programming language that combines <strong>object-oriented programming (OOP)</strong> and <strong>functional programming (FP)</strong>.</p><p>It runs on the Java Virtual Machine (JVM), allowing Scala applications to use Java libraries and integrate with the Java ecosystem.</p><p>Scala is commonly used for backend services, data processing, distributed systems, and applications that benefit from expressive abstractions and functional programming.</p><p><br></p><h2>2. Why Learn Scala?</h2><h3>​Object-Oriented Programming​​</h3><p>​Scala supports classes, objects, inheritance, and traits.</p><pre class="__se__code-scala"><br>class Developer(val name: String) {<br>  def introduce(): Unit =<br>    println(s"Hi, I'm $name")<br>}<br><br>val developer = new Developer("Deepak")<br>developer.introduce()<br>​<br><br></pre><h3 class="__se__code-scala">Functional Programming</h3><p>Scala supports functions as values, immutable data, and collection operations such as <code>map</code>, <code>filter</code>, and <code>reduce</code>.</p><pre class="__se__code-scala">val numbers = List(1, 2, 3, 4, 5)<br><br>val doubled = numbers.map(_ * 2)<br><br>println(doubled)<br>​​<br></pre><h3 class="__se__code-scala">Java Ecosystem</h3><p>Scala runs on the JVM and can interoperate with Java libraries.</p><p>This is particularly useful for developers who already work with Java, Spring Boot, or JVM-based applications.</p><p><br></p><h3>Modern Backend Development</h3><p>Scala is used in backend systems, data processing, and distributed computing.</p>

Scala 2 vs. Scala 3

Play With Code to understand Context parameter and values

Introduction to Scala

<p><br></p><h2>1. Introduction</h2><p>In the previous lesson, we installed the JDK, configured the Scala environment, and executed our first Scala program.</p><p>Now let's understand how Scala projects are structured in real-world development.</p><p>When you work with a small Scala program, you can write code in a single file and execute it directly. However, enterprise applications usually contain multiple source files, external libraries, test cases, and configuration files.</p><p>Managing all these components manually would quickly become difficult.</p><p>This is where <strong>sbt (Scala Build Tool)</strong> comes in.</p><p>By the end of this lesson, you will understand:</p><ul><li><p>What sbt is and why Scala developers use it.</p></li><li><p>How a typical Scala project is structured.</p></li><li><p>What the <code>build.sbt</code> file does.</p></li><li><p>How to create a Scala 2 project.</p></li><li><p>How to compile and run a Scala application using sbt.</p></li><li><p>How to add external dependencies.</p></li><li><p>How to execute basic sbt commands.</p></li></ul><div><hr></div><h2>2. What Is sbt?</h2><p><strong>sbt stands for Scala Build Tool.</strong></p><p>It is a build automation tool primarily used for Scala and Java projects.</p><p>Think of sbt as a tool that automates common development tasks.</p><p>For example, instead of manually compiling Scala files, managing JAR dependencies, and executing your application, you can use sbt commands.</p><h3>What can sbt do?</h3><table><tbody><tr><th>Feature</th><th>Purpose</th></tr><tr><td>Compilation</td><td>Compiles Scala source files into JVM bytecode.</td></tr><tr><td>Dependency management</td><td>Downloads and manages external libraries.</td></tr><tr><td>Testing</td><td>Executes automated test cases.</td></tr><tr><td>Application execution</td><td>Runs your Scala application.</td></tr><tr><td>Build automation</td><td>Automates repetitive build tasks.</td></tr><tr><td>Project configuration</td><td>Manages Scala versions and build settings.</td></tr></tbody></table><h3>Java vs Scala Build Tools</h3><p>If you have worked with Java, you may already know Maven or Gradle.</p><p>Scala developers commonly use sbt.</p><table><tbody><tr><th>Java Ecosystem</th><th>Scala Ecosystem</th></tr><tr><td>Maven</td><td>sbt</td></tr><tr><td>Gradle</td><td>sbt</td></tr><tr><td><code>pom.xml</code></td><td><code>build.sbt</code></td></tr><tr><td><code>mvn compile</code></td><td><code>sbt compile</code></td></tr><tr><td><code>mvn test</code></td><td><code>sbt test</code></td></tr><tr><td><code>mvn package</code></td><td><code>sbt package</code></td></tr></tbody></table><p><strong>Remember:</strong> sbt is not a programming language. It is a build tool used to manage and automate your Scala project.</p><div><hr></div><h2>3. Create Your First Scala Project</h2><p>Let's create a simple Scala 2 project.</p><h3>Step 1: Create a project directory</h3><p>Open your terminal and execute:</p><pre><code>mkdir scala-learningcd scala-learning</code></pre><p>Step 2: Create the project structure<br></p><p>Create the following directories:</p><pre><code>mkdir -p src/main/scalamkdir -p src/test/scala</code></pre><p>Your project should look like this:</p><div class="se-component se-image-container __se__float-none" style="width: 100%"><figure style="width: 100%;"><img src="https://api.cstechie.com/upload/editor-image/2026/44c7e00f-f6f7-44a3-9bed-96cb1c5a2035.webp" alt="Scala Learning project directory" data-rotate="" data-proportion="true" data-size="100%," data-align="none" data-percentage="100," data-file-name="scala-learn-directory.png" data-file-size="195919" data-origin="," style="width: 100%;"></figure></div><p><br></p><p>Understanding the directories</p><table><tbody><tr><th>Directory/File</th><th>Description</th></tr><tr><td><code>build.sbt</code></td><td>Contains project configuration and dependencies.</td></tr><tr><td><code>project/</code></td><td>Contains sbt build configuration and plugins.</td></tr><tr><td><code>src/main/scala/</code></td><td>Contains application source code.</td></tr><tr><td><code>src/test/scala/</code></td><td>Contains automated test code.</td></tr></tbody></table><p>You don't need to create every directory manually. sbt and your IDE can help manage the project structure.</p><div><hr></div><h2>4. Understanding build.sbt</h2><p>The <code>build.sbt</code> file is one of the most important files in an sbt project.</p><p>It defines the project name, Scala version, dependencies, and other build settings.</p><p>Create a file named <code>build.sbt</code> in your project root.</p><p>Add the following configuration:</p><pre><code>name := "scala-learning"version := "1.0.0"scalaVersion := "2.13.18"</code></pre><p>Understanding the configuration<br></p><p><strong>1. Project name</strong></p><pre><code>name := "scala-learning"</code></pre><p>Defines the name of your project.<br></p><p><strong>2. Project version</strong></p><pre><code>version := "1.0.0"</code></pre><p>Defines the current project version.<br></p><p><strong>3. Scala version</strong></p><pre><code>scalaVersion := "2.13.18"</code></pre><p>Specifies the Scala compiler version used by the project.<br></p><p>For this course, we will primarily use Scala 2.13.</p><p><strong>Important:</strong> The Scala version specified in <code>build.sbt</code> controls the version used to compile the project. It is separate from the JDK version installed on your machine.</p><div><hr></div><h2>5. Write Your First sbt Application</h2><p>Create a file named <code>Main.scala</code> inside:</p><p><code>src/main/scala/</code></p><p>Add the following code:</p><pre><code>object Main {  def main(args: Array[String]): Unit = {    println("Welcome to Scala!")    println("Learning Scala with sbt.")  }}</code></pre><p>Understanding the code<br></p><ul><li><p><code>object Main</code>: Defines a Scala singleton object.</p></li><li><p><code>def main(args: Array[String])</code>: Defines the application's entry point.</p></li><li><p><code>Array[String]</code>: Represents command-line arguments.</p></li><li><p><code>Unit</code>: Indicates that the method does not return a meaningful value.</p></li><li><p><code>println()</code>: Prints text to the console.</p></li></ul><p>Your project structure should now look like this:</p><pre><code>scala-learning/<br>│<br>├── build.sbt<br>│<br>├── project/<br>│<br>└── src/    <br>├── main/    <br>│   └── scala/    <br>│       └── Main.scala    <br>│    └── test/        <br>└── scala/</code></pre><hr><p><br></p><h2>6. Execute Your Scala Application Using sbt</h2><p>Open the terminal from your project root directory.</p><p>First, verify that sbt is installed:</p><pre><code>sbt --version</code></pre><p>Now execute the application:<br></p><pre><code>sbt run</code></pre><p>Expected output:<br></p><pre><code>Welcome to Scala!Learning Scala with sbt.</code></pre><p>Congratulations! You have successfully created and executed a Scala 2 application using sbt.<br></p><h3>How does sbt work internally?</h3><p>When you execute:</p><pre><code>sbt run</code></pre><p>The build tool performs several operations:<br></p><ol><li><p>Reads the project configuration from <code>build.sbt</code>.</p></li><li><p>Resolves the required dependencies.</p></li><li><p>Compiles Scala source files.</p></li><li><p>Generates JVM bytecode.</p></li><li><p>Starts the application on the JVM.</p></li><li><p>Displays the program output.</p></li></ol><p>Conceptually:</p><p><strong>Scala Source Code → sbt → Scala Compiler → JVM Bytecode → JVM → Output</strong></p><div><hr></div><h2>7. Important sbt Commands</h2><p>As a Scala developer, you will frequently use the following commands.</p><table><tbody><tr><th>Command</th><th>Description</th></tr><tr><td><code>sbt</code></td><td>Starts the sbt interactive shell.</td></tr><tr><td><code>sbt compile</code></td><td>Compiles the project.</td></tr><tr><td><code>sbt run</code></td><td>Runs the application.</td></tr><tr><td><code>sbt test</code></td><td>Executes automated tests.</td></tr><tr><td><code>sbt clean</code></td><td>Removes generated build files.</td></tr><tr><td><code>sbt package</code></td><td>Creates a packaged JAR.</td></tr><tr><td><code>sbt console</code></td><td>Opens the Scala REPL with the project classpath.</td></tr><tr><td><code>sbt reload</code></td><td>Reloads the build configuration.</td></tr></tbody></table><h3>Interactive sbt shell</h3><p>Instead of running a separate command every time, you can start the sbt shell:</p><pre><code>sbt</code></pre><p>You will get an interactive prompt.<br></p><p>Now execute commands directly:</p><pre><code>&gt; compile&gt; run&gt; test&gt; clean&gt; exit</code></pre><p>This is particularly useful when working on larger projects.<br></p><div><hr></div><h2>8. Understanding Dependencies in Scala</h2><p>Real-world applications rarely work without external libraries.</p><p>For example, you may need libraries for:</p><ul><li><p>JSON processing.</p></li><li><p>Database connectivity.</p></li><li><p>Logging.</p></li><li><p>HTTP clients.</p></li><li><p>Testing.</p></li><li><p>Web development.</p></li></ul><p>sbt makes dependency management straightforward.</p><p>Let's understand this with an example.</p><p>Suppose you want to use the ScalaTest library for unit testing.</p><p>Add the following dependency to your <code>build.sbt</code> file:</p><pre><code>libraryDependencies +=  "org.scalatest" %% "scalatest" % "3.2.19" % Test</code></pre><p>Understanding the dependency declaration<br></p><table><tbody><tr><th>Component</th><th>Meaning</th></tr><tr><td><code>org.scalatest</code></td><td>Library organization</td></tr><tr><td><code>scalatest</code></td><td>Library name</td></tr><tr><td><code>3.2.19</code></td><td>Library version</td></tr><tr><td><code>%%</code></td><td>Selects the artifact compatible with the project's Scala binary version</td></tr><tr><td><code>Test</code></td><td>Makes the dependency available in the test scope</td></tr></tbody></table><p>After adding the dependency, execute:</p><pre><code>sbt update</code></pre><p>sbt resolves and downloads the required library and its transitive dependencies.<br></p><p><strong>Note:</strong> Dependency versions should be checked for compatibility with your Scala version and project requirements.</p><div><hr></div><h2>9. Understanding the target Directory</h2><p>After compiling your project, you will notice a new directory:</p><pre><code>target/</code></pre><p>This directory contains generated build artifacts.<br></p><p>For example:</p><pre><code>target/<br> └── scala-2.13/    <br>├── classes/    <br>├── test-classes/    <br>└── ...</code></pre><p>What is stored inside target?<br></p><table><tbody><tr><th>Directory</th><th>Purpose</th></tr><tr><td><code>classes/</code></td><td>Compiled application classes.</td></tr><tr><td><code>test-classes/</code></td><td>Compiled test classes.</td></tr><tr><td>Other build output</td><td>Generated files and intermediate build artifacts.</td></tr></tbody></table><p>You generally do not need to modify anything inside <code>target</code> manually.</p><p>The directory can be regenerated by sbt.</p><div><hr></div><h2>10. Scala Project Structure: Complete View</h2><p>A typical Scala application may have the following structure:</p><pre><code>scala-learning/<br>│<br>├── build.sbt<br>│<br>├── project/<br>│   └── build.properties<br>│├── src/<br>│   ├── main/<br>│   │   ├── scala/<br>│   │   │   ├── Main.scala<br>│   │   │   ├── service/<br>│   │   │   └── model/<br>│   │   ││   <br>│   └── resources/<br>│   │<br>│   └── test/<br>│       ├── scala/<br>│       └── resources/<br>│└── target/</code></pre><p>Additional directories<br></p><p><strong>src/main/resources</strong></p><p>Stores application resources such as:</p><ul><li><p>Configuration files.</p></li><li><p>Application properties.</p></li><li><p>JSON files.</p></li><li><p>XML files.</p></li></ul><p><strong>src/test/resources</strong></p><p>Stores resources required by automated tests.</p><p><strong>project/build.properties</strong></p><p>Can be used to specify the sbt version.</p><p>Example:</p><pre><code>sbt.version=1.11.7</code></pre><p>Use the sbt version selected for your project rather than treating this example as a mandatory version.<br></p><div><hr></div><h2><span style="font-size: 24px">Key Takeaways</span></h2><p>In this lesson, you learned:</p><ul><li><p>sbt is the primary build automation tool used in many Scala projects.</p></li><li><p><code>build.sbt</code> contains project configuration.</p></li><li><p>Scala source code is generally stored in <code>src/main/scala</code>.</p></li><li><p>Test source code is generally stored in <code>src/test/scala</code>.</p></li><li><p>External libraries are managed through <code>libraryDependencies</code>.</p></li><li><p>sbt can compile, test, package, and execute Scala applications.</p></li><li><p>Compiled output and other generated artifacts are stored under <code>target</code>.</p></li></ul><p>You now have a working foundation for developing Scala applications using sbt.</p><div><hr></div><h2><br></h2>

Scala Project Structure and Build Tools (sbt)

<p><br></p><p><strong>Goal:</strong> Understand expressions, variables, types, and type inference in Scala 2.</p><h2>1. Expressions</h2><p>An expression produces a value.</p><pre class="__se__code-scala"><code>println(10 + 20)<br>println("Hello, Scala!")</code><br>​​<br></pre><p>Output</p><p><strong></strong><br></p><pre>30<br>Hello, Scala!</pre><p><strong></strong></p><blockquote class="__se__format__range_quote_note"><p><strong>Remember:Arithmetic operations, method calls, and string values can all be expressions.</strong></p></blockquote><p></p><h2><br></h2><h2>2. <code>val</code> vs <code>var</code></h2><p>Use <code>val</code> for a value that cannot be reassigned. Use <code>var</code> when reassignment is required.</p><pre class="__se__code-scala"><code>val name = "Deepak"<br>var age = 30<br>age = 31<br>println(name)<br>println(age)</code><br>​<br></pre><p>Output</p><p><strong></strong></p><pre>Deepak<br>31</pre><p><code>val</code> prevents reassignment of the variable; it does not automatically make every referenced object immutable.<br></p><p><strong>Best practice:</strong> Prefer <code>val</code> unless you specifically need reassignment.</p><h2><br></h2><h2>3. Type Inference</h2><p>Scala can infer a variable's type from its initial value.</p><pre class="__se__code-scala"><code>val name = "Deepak" // String<br>val age = 30        // Int<br>val salary = 50000.0 // Double</code><br>​<br></pre><p></p><p>You can also declare the type explicitly:<br></p><pre>val age: Int = 30</pre><p>Both approaches are valid.<br></p><p><strong>Remember:</strong> Scala is statically typed, even when you omit explicit type declarations.</p><h2>4. Functions</h2><p>A function accepts input and produces a result.</p><pre class="__se__code-scala">val add = (a: Int, b: Int) =&gt; a + b<br>println(add(10, 20))<br>​<br></pre><p></p><p><strong>Output</strong><br></p><pre>30</pre><p><code>a: Int</code> and <code>b: Int</code> are parameters.<br><br><code>=&gt;</code> separates the parameters from the function body.<br><br><code>a + b</code> is the result.<br><br></p><h2>5. Methods</h2><p>Define a named method using <code>def</code>.</p><pre class="__se__code-scala"><code>def multiply(a: Int, b: Int): Int = {  a * b}<br>println(multiply(4, 5))</code><br>​<br></pre><p></p><p><strong>Output</strong><br></p><pre>20</pre><p><strong>Key difference:</strong> A method is defined with <code>def</code>. A function is a value that can be stored in a variable, passed to another function, or returned.<br></p><h2>Key Takeaways</h2><blockquote class="__se__format__range_quote_tip"><p>​</p><ul><li><p style="line-height: 2em">Expressions produce values.</p></li><li><p style="line-height: 2em">Use <code>val</code> by default and <code>var</code> when reassignment is necessary.</p></li><li><p style="line-height: 2em">Scala infers types without sacrificing static type checking.</p></li><li><p style="line-height: 2em">Use <code>def</code> to define methods.</p></li><li><p style="line-height: 2em">Functions can be stored in values and passed around as data.</p></li></ul></blockquote><p></p>

Scala Basics

<p><strong>Learning objective:</strong> Understand Scala's type hierarchy, distinguish value and reference types, and learn the purpose of <code>Any</code>, <code>Nothing</code>, and <code>Null</code>.</p><h2>1. What Are Unified Types?</h2><p>In Scala, every value has a type, including numbers, strings, objects, and functions.</p><p>Scala organizes these types into a common hierarchy.</p><p><br></p><p><strong>Remember:</strong> <code>Any</code> is the common supertype of all Scala types. <code>AnyVal</code> represents value types, while <code>AnyRef</code> represents reference types.<br></p><h2>2. Understanding Any</h2><p><code>Any</code> is the top type in Scala's type hierarchy.</p><p>It allows you to store values of different types in a single collection.</p><pre><code>val values: List[Any] = List(  "Scala",  100,  25.5,  true)values.foreach(println)</code></pre><p><strong>Output:</strong><br></p><pre><code>Scala10025.5true</code></pre><p><strong>Key takeaway:</strong> Use <code>Any</code> when values of different types must share a common type. Prefer more specific types when possible.<br></p><h2>3. Understanding AnyVal</h2><p><code>AnyVal</code> is the parent type of Scala's built-in value types.</p><p>Common examples include:</p><table><tbody><tr><th>Type</th><th>Example</th><th>Purpose</th></tr><tr><td><code>Int</code></td><td><code>val age = 30</code></td><td>Integers</td></tr><tr><td><code>Long</code></td><td><code>val id = 1000L</code></td><td>Larger integers</td></tr><tr><td><code>Double</code></td><td><code>val salary = 50000.50</code></td><td>Decimal numbers</td></tr><tr><td><code>Float</code></td><td><code>val rate = 2.5F</code></td><td>Single-precision numbers</td></tr><tr><td><code>Boolean</code></td><td><code>val active = true</code></td><td>True or false</td></tr><tr><td><code>Char</code></td><td><code>val grade = 'A'</code></td><td>A character</td></tr><tr><td><code>Unit</code></td><td><code>()</code></td><td>No meaningful result</td></tr></tbody></table><p>Other built-in value types are <code>Byte</code> and <code>Short</code>.</p><p>Example:</p><pre><code>val age: Int = 30val active: Boolean = trueprintln(age)println(active)</code></pre><p><strong>Remember:</strong> <code>Unit</code> is similar to <code>void</code> in Java. Its single value is written <code>()</code>.<br></p><h2>4. Understanding AnyRef</h2><p><code>AnyRef</code> is the parent type of reference types, including strings, collections, and user-defined classes.</p><pre><code>class Developer(val name: String)val developer = new Developer("Deepak")val technology = "Scala"println(developer.name)println(technology)</code></pre><p><strong>Output:</strong><br></p><pre><code>DeepakScala</code></pre><p><strong>Remember:</strong> In Scala on the JVM, <code>AnyRef</code> corresponds to <code>java.lang.Object</code>.<br></p><h2>5. Understanding Type Conversion</h2><p>Type conversion changes a value from one type to another.</p><p>For supported numeric conversions, Scala provides methods such as <code>.toInt</code>, <code>.toLong</code>, and <code>.toFloat</code>.</p><pre><code>val number: Int = 100val decimal: Double = number.toDoubleprintln(decimal)</code></pre><p><strong>Output:</strong><br></p><pre><code>100.0</code></pre><p>Conversions can lose information.<br></p><pre><code>val original: Long = 987654321Lval converted: Float = original.toFloatprintln(converted)</code></pre><p>A <code>Float</code> cannot represent every integer exactly, so precision may be lost.<br></p><p><strong>Important:</strong> Converting a value to another type is not always reversible without losing information.</p><h2>6. Understanding Nothing</h2><p><code>Nothing</code> is the bottom type in Scala's type hierarchy. It has no values, and it is a subtype of every type.</p><p>A common use is representing an expression that does not complete normally, such as throwing an exception.</p><pre><code>def fail(message: String): Nothing =  throw new RuntimeException(message)</code></pre><p>Because <code>fail</code> never returns normally, its return type is <code>Nothing</code>.<br></p><p><strong>Remember:</strong> You generally won't declare ordinary variables of type <code>Nothing</code>. You will encounter it in exception handling and type inference.</p><h2>7. Understanding Null</h2><p><code>Null</code> represents the <code>null</code> reference and is primarily relevant when interoperating with Java or other JVM libraries.</p><pre><code>val name: String = null</code></pre><p>This assignment is permitted under standard Scala 2 typing rules and Scala 3's default nullability mode.<br></p><p>However, accessing methods on a null reference can cause a <code>NullPointerException</code>.</p><p><strong>Best practice:</strong> Avoid using <code>null</code> in normal Scala application code. Use safer alternatives such as <code>Option[String]</code> when a value may be absent.</p><pre><code>val name: Option[String] = None</code></pre><p><code>None</code> represents the absence of a value without requiring a null reference.<br></p><h2>8. Quick Knowledge Check</h2><p><strong>Question 1:</strong> Which type is the common supertype of all Scala types?</p><ul><li><p>A. <code>AnyVal</code></p></li><li><p>B. <code>AnyRef</code></p></li><li><p>C. <code>Any</code></p></li></ul><p><strong>Answer:</strong> C — <code>Any</code></p><p><strong>Question 2:</strong> Which type is commonly used for integers?</p><ul><li><p>A. <code>Int</code></p></li><li><p>B. <code>String</code></p></li><li><p>C. <code>Boolean</code></p></li></ul><p><strong>Answer:</strong> A — <code>Int</code></p><p><strong>Question 3:</strong> What does <code>Nothing</code> represent?</p><ul><li><p>A. An empty string</p></li><li><p>B. A type with no values that is a subtype of every type</p></li><li><p>C. The same thing as <code>Unit</code></p></li></ul><p><strong>Answer:</strong> B</p><p><strong>Question 4:</strong> Which is the safer approach when a string value may be absent?</p><ul><li><p>A. Always use <code>null</code></p></li><li><p>B. Use <code>Option[String]</code></p></li><li><p>C. Use <code>AnyRef</code></p></li></ul><p><strong>Answer:</strong> B — <code>Option[String]</code></p><h2>Key Takeaways</h2><ul><li><p><code>Any</code> is the top type in Scala's type hierarchy.</p></li><li><p><code>AnyVal</code> represents built-in value types.</p></li><li><p><code>AnyRef</code> represents reference types.</p></li><li><p>Type conversions may lose information.</p></li><li><p><code>Unit</code> represents the absence of a meaningful return value.</p></li><li><p><code>Nothing</code> has no values and is a subtype of every type.</p></li><li><p><code>Null</code> represents a null reference; prefer safer alternatives such as <code>Option</code>.</p></li></ul>

Component	Purpose
JDK	Provides Java development tools and the JVM runtime.
JVM	Executes JVM bytecode produced by Scala and Java compilers.
Scala compiler	Compiles Scala source code into JVM bytecode.
Scala CLI	Runs, compiles, and tests Scala programs from the command line.
IntelliJ IDEA	Provides an IDE for writing, running, and debugging Scala code.

Problem	What to check
`java: command not found`	Install the JDK and configure `PATH`.
`javac: command not found`	Verify that a JDK, rather than only a runtime, is installed.
`scala: command not found`	Complete the Scala installation and reopen the terminal.
Wrong Scala version	Specify the required version in the command or project configuration.
Compilation error	Check the Scala syntax and compiler version.
IDE cannot find the JDK	Configure the project JDK in the IDE settings.

Comments

Install Scala and Set Up the JVM

Understand the tools you need

Install an IDE (Optional)

Troubleshooting Common Issues

Lesson Summary