{"id":11679,"date":"2018-03-24T09:33:13","date_gmt":"2018-03-24T09:33:13","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=11679"},"modified":"2021-12-04T10:16:46","modified_gmt":"2021-12-04T04:46:46","slug":"scala-tutorial","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/scala-tutorial\/","title":{"rendered":"What is Scala? | A Comprehensive Scala Tutorial"},"content":{"rendered":"

We feel immense pleasure in welcoming you to yet another series of tutorials- Scala. What is Scala? What can you do with it? and What does it look like? These are some of the questions we will answer today in our comprehensive Scala tutorial.<\/p>\n

We will discuss what is Scala programming, Scala for beginners, history of Scala, Features of Scala, Frameworks of Scala, Applications of Scala, Companies that use Scala, and technologies that are built on Scala.<\/p>\n

So, let’s begin with the Scala Tutorial.<\/p>\n

What is Scala Programming?<\/h3>\n

Scala is a portmanteau of \u2018scalable\u2019 and \u2018language\u2019. It is designed to grow with user demand.<\/p>\n

A general-purpose programming language, Scala provides support for functional programming and a strong static type system.<\/p>\n

Being much like Java Programming<\/strong><\/a>, Scala\u2019s source code compiles into Java bytecode. The resulting executable code runs on a JVM (Java Virtual Machine)<\/a><\/strong>. Actually, it supports language interoperability with Java. So, you can reference libraries written in both languages, in both of them. Other similarities between Java and Scala include an object-oriented nature and a curly-brace syntax.<\/p>\n

However, unlike Java, Scala supports features of functional programming- like currying, type-inference, immutability, lazy evaluation, pattern matching, and nested functions. It also supports higher-order functions, where a function can return another, or take it as a parameter.<\/p>\n

Scala also has an advanced type system that supports algebraic data types, higher-order types, anonymous types, and covariance and contravariance.<\/p>\n

Finally, Scala also allows functionality like operator overloading, raw strings, optional parameters, and named parameters. However, it doesn\u2019t support checked exceptions, like Java does.<\/p>\n

Hope now you are clear with reasons to why learn Scala<\/a><\/strong>. Let us see a topic of Scala Tutorial: Scala History.<\/p>\n

Scala Tutorial – History<\/h3>\n

Scala emerged on 20 January 2004, 14 years from now. While its design began in 2001 at the \u00c9cole Polytechnique F\u00e9d\u00e9rale de Lausanne (EPFL) (in Lausanne, Switzerland) by Martin Odersky, it saw an internal release in late 2003. In 2004, it released to the public on the Java platform. Further, a second version followed in the March of 2006.<\/p>\n

While Java adopted lambda expressions only in 2014, with Java, Scala always supported functional programming fully. On January 17th of 2011, the team for Scala bagged a five-year research grant of over \u20ac2.3 million from the European Research Council.<\/p>\n

Then, on May 12th of 2011, Odersky and collaborators launched Typesafe Inc., which they later renamed to Lightbend Inc. This was to provide commercial support, training, and services for Scala. In 2011, Greylock Partners invested $3 million in Typesafe.<\/p>\n

Scala Tutorial – Features of Scala<\/h3>\n

Every language has some unique features<\/a><\/strong> which make them the best convenience of a particular type of Project.<\/p>\n

In this Scala Tutorial, we have mentioned 14 such features of Scala Programming Language.<\/p>\n

\"Features<\/a>

Features of Scala<\/p><\/div>\n

a. Type Inference<\/h4>\n

Type inference means Scala automatically detects(infers) an expression\u2019s data type fully or partially. We don\u2019t need to declare it ourselves, and this also lets developers omit type annotations. This has no effect on the type checking.<\/p>\n

The compiler checks the types of the subexpressions, or of atomic values like 42(Integer), and true(Bool). It aggregates this information to decide the type for the entire expression.<\/p>\n

b. Singleton Object<\/h4>\n

In Scala, you will see a singleton object<\/a><\/strong> instead of static variables and methods. A singleton object is a class with a single object in the source file. To declare this, we use the \u2018object\u2019 keyword:<\/p>\n

object Main extends App {\r\nprintln(\"Hello, World!\")\r\n}<\/pre>\n
c. Immutability<\/h4>\n
Every time you declare a variable in Scala, it is immutable by default. This means you cannot modify it. But if you want, you may declare it as mutable. Then, it is possible to change its value.
\nThis property of Scala helps us with concurrency control.<\/p>\n
d. Lazy Evaluation<\/h4>\n
If declared lazy using the \u2018lazy\u2019 keyword, Scala delays complex computation with evaluating an expression until it absolutely needs it. We also call it call-by-need.<\/p>\n
This avoids repeated evaluations. And these are the benefits of the same:<\/p>\n
    \n
  1. Lazy Evaluation, lets us define control flow as abstractions instead of primitives.<\/li>\n
  2. It lets us define potentially infinite data structures.<\/li>\n
  3. It also improves performance.<\/li>\n<\/ol>\n
    Take an example:<\/p>\n
    lazy val images=getImages()<\/pre>\n
    e. Case Classes and Pattern Matching<\/h4>\n
    A regular class that is immutable by default, and is decomposable via pattern matching, is a case class. Its parameters are public and immutable by default. We define a case class with the keywords \u2018case class\u2019, an identifier, and a parameter list which can be empty.<\/p>\n
    case class Book(isbn: String)\r\nval frankenstein = Book(\"978-0486282114\")<\/pre>\n
    Scala Pattern matching<\/a><\/strong> allows us to compare a value against a pattern. This is like a switch-statement or a series of if-else statements in Java.<\/p>\n
    import scala.util.Random\r\nval x: Int = Random.nextInt(10)\r\nx match\r\n{\r\ncase 0 => \"zero\"\r\ncase 1 => \"one\"\r\ncase 2 => \"two\"\r\ncase _ => \"many\"\r\n}<\/pre>\n
    Any doubt yet in Scala Programming Tutorial? Please Comment.<\/p>\n
    f. Concurrency Control<\/h4>\n
    The Actor model from Scala\u2019s standard library lets us implement concurrency in code. Scala also has a platform\/tool, Akka, which is a separate, open-source framework for Actor-based concurrency. It is possible to combine\/distribute Akka\u2019s actors with software transactional memory.<\/p>\n
    g. String Interpolation<\/h4>\n
    Scala String Interpolation<\/strong><\/a>\u00a0is a form of template-processing. To interpolate a string is to evaluate a string literal consisting of one or more placeholders to yield a result. The corresponding values replace these placeholders.<\/p>\n
    String interpolation is observed in Scala since version 2.10.0. Three methods it offers for this are- s, f, and raw.<\/p>\n
    h. Higher-Order Functions<\/h4>\n
    Such functions can return another function, or take it as a parameter. Scala makes it possible by treating its functions as first-class citizens.<\/p>\n
    val salaries = Seq(20000, 70000, 40000)\r\nval doubleSalary = (x: Int) => x * 2\r\nval newSalaries = salaries.map(doubleSalary) \/\/ List(40000, 140000, 80000)<\/pre>\n
    Here, map is a higher-order function.<\/p>\n
    Higher-order functions also let us implement function compositions and lambdas.<\/p>\n
    i. Traits<\/h4>\n
    A trait is a type holding certain fields and methods. We define traits using the \u2018trait\u2019 keyword:<\/p>\n
    trait Greeter\r\n{\r\ndef greet(name: String): Unit\r\n}<\/pre>\n
    You can think of it like a partially implemented interface. You can create a trait with abstract, and optionally, non-abstract methods, and can also combine multiple traits.<\/p>\n
    j. Rich Set of Collections<\/h4>\n
    The Scala library has a huge set of collection<\/a><\/strong>s with classes and traits to help collect data into an immutable or a mutable collection. The scala.collection.immutable package holds all immutable collections. They don\u2019t allow us to modify data. Likewise, the scala.collection.mutable package holds all the mutable ones.<\/p>\n
    k. Functional<\/h4>\n
    Scala is a functional language and treats its functions as first-class citizens. It will let you create higher-order functions like we\u2019ve discussed twice earlier in this article. Other than that, it also supports nested functions and methods and carrying.<\/p>\n
    Currying is the act of translating the evaluation of a function that takes multiple arguments, into evaluating a sequence of functions, each with a single argument.<\/p>\n
    l. Object-Oriented<\/h4>\n
    Scala is object-oriented<\/a> <\/strong>while also being functional. In it, every value is an object.<\/p>\n
    m. Statically-typed<\/h4>\n
    You usually won\u2019t need to declare redundant type information in your code. Scala will decide that based on the types of subexpressions, or of atomic values. This is in pertinence to type inference.<\/p>\n
    n. Extensibility<\/h4>\n
    When you\u2019re building domain-specific applications, you need domain-specific language extensions too. Scala delivers a combination of language mechanisms. Overall, it makes it easy to smoothly add new language constructs as libraries. Constructs like implicit classes and string interpolation help us do this; we don\u2019t need meta-programming features like macros.<\/p>\n
    o. Scala Runs on the JVM<\/h4>\n
    Scala\u2019s compiler converts the source into Java bytecode that runs on the JVM (Java Virtual Machine).<\/p>\n
    Next topic in Scala Tutorial is Frameworks for Scala.<\/p>\n
    Scala Tutorial – Frameworks for Scala<\/h3>\n
    Which frameworks and development tools do we have with Scala? Let\u2019s see.<\/p>\n
    \"Scala<\/a>
    Scala Tutorial: Scala Frameworks<\/p><\/div>\n
    a. Akka<\/h4>\n
    https:\/\/akka.io\/<\/p>\n
    A free and open-source toolkit and runtime, Akka simplifies constructing concurrent and distributed applications on the JVM. Akka is good with distributed processing.<\/p>\n
    b. Apache Kafka<\/h4>\n
    https:\/\/kafka.apache.org\/<\/p>\n
    Kafka is an open-source stream processing software platform by the Apache Software Foundation. It is written in Scala and Java. From Kafka, you can expect a unified, high-throughput, low-latency platform for handling real-time data feeds. Kafka is good with distributed processing too.<\/p>\n
    Follow this link to know about Apache Kafka Tutorial<\/a><\/strong><\/p>\n
    c. ScalaQuery<\/h4>\n
    scalaquery.org\/<\/p>\n
    ScalaQuery is a low-level Scala API for database access, composable non-leaky abstractions, and compile-time checking and type-safety. The JDBC API is powerful but verbose.<\/p>\n
    d. Squeryl<\/h4>\n
    squeryl.org\/<\/p>\n
    Squeryl is a DSL for manipulating database objects from within Scala. It is strongly-typed, declarative, and SQL-like.<\/p>\n
    e. Lift<\/h4>\n
    https:\/\/liftweb.net\/<\/a><\/p>\n
    Lift is a free and open-source web framework for Scala. David Pollak created it because he was dissatisfied with some aspects of Ruby on Rails.<\/p>\n
    f. Play!<\/h4>\n
    https:\/\/www.playframework.com\/<\/a><\/p>\n
    An open-source web-application framework, Play! is written in Scala.<\/p>\n
    g. Scalatra<\/h4>\n
    scalatra.org\/<\/p>\n
    Scalatra is yet another free and open-source web application framework that was written in Scala. It is an alternative to the Lift, Play!, and Unfiltered frameworks, and is a port of the Sinatra framework.<\/p>\n
    Next topic in Scala Tutorial is Applications of Scala.<\/p>\n
    Scala Tutorial – Applications of Scala<\/h3>\n
    So, what can we do with Scala? The following are just some of the things you can build with Scala:<\/p>\n
      \n
    1. Android applications<\/li>\n
    2. Desktop applications<\/li>\n
    3. Concurrency and distributed data processing, for instance, Spark<\/li>\n
    4. Front and back ends of web applications with scala.js<\/li>\n
    5. Highly concurrent things, like messaging apps, with Akka<\/li>\n
    6. Distributed computing; because of its concurrency capabilities<\/li>\n
    7. Scala is used with Hadoop<\/strong><\/a>; Map\/Reduce programs<\/li>\n
    8. Big Data<\/a> <\/strong>and data analysis with Apache Spark<\/li>\n
    9. Data streaming with Akka<\/li>\n
    10. Parallel batch processing<\/li>\n
    11. AWS lambda<\/a> <\/strong>expression<\/li>\n
    12. Ad hoc scripting in REPL<\/li>\n<\/ol>\n
      What Companies Use Scala?<\/h3>\n
      \"Scala<\/a>
      Scala Tutorial – Companies using Scala<\/p><\/div>\n