How To Use Scala for Data Science (2023)

Scala's name implies that it is a scalable programming language. It was created in 2003 by Martin Odersky and his research team. These days we widely useScala in Data ScienceandMachine Learningfields. Scala is a small, fast, and efficient multi-paradigm programming language built on a compiler. TheJVM(Java Virtual Machine)is Scala's main advantage . Scala code is first compiled by a Scala compiler, which generates bytecode, which is then transported to the JVM for output generation.

Scala is a high-level programming language that mixes object-oriented and functional programming.Data Science with Python tutorialis a great choice to start learning, andScala programming for data scienceproblem-solving is an excellent skill to have in your arsenal. Scala was built to implement scalable solutions to crunch big data in order to produce actionable insights. Scala's static types help complicated applications avoid problems, and its JVM and JavaScript runtimes allow you to construct high-performance systems with simple access to a vast library ecosystem.

Why we learn Scala for Data Science:

How To Use Scala for Data Science (1)

  • Scala has the ability to interact with data that is stored in a distributed manner. It takes advantage of all available resources and allows for parallel data processing.
  • It's a language designed to take advantage of big data processing. This language is designed to construct scalable solutions for digesting and grouping large amounts of data in order to generate actionable insights.
  • Scala allows you to work with immutable data and higher-order functions, just like we use those concepts frequently in thePython programmingparadigm. You can learn more about this fromknowledgehut data science with python tutorial.
  • Scala is an improved version of Java that was created with the goal of removing redundant code. It supports a variety of libraries and APIs, allowing the programmer to work with less downtime.
  • Scala provides various types of Constructs, allowing programmers to easily interact with wrappers and container types.

Here is an article onmeasures of dispersion.

Scala: A Quick Guide:

Scala programming for data science was created to describe common programming patterns in a concise, expressive, and type-safe manner. It combines the best of object-oriented and functional programming languages.

How To Use Scala for Data Science (2)

  • Scala is object-oriented:

In the sense that every value in Scala is an object, it is a pure object-oriented language. Classes and characteristics explain the types and behavior of objects. Subclassing and a flexiblemixing-based composition technique can be used to expand classes as a clean replacement for multiple inheritances.

  • Scala is functional:

In the sense that every function is a value, Scala is also a functional language. Scala has a lightweight syntax for defining anonymous functions, as well as support for higher-order functions, nested functions, and currying. The functionality of algebraic types, which are utilized in many functional languages, is provided via Scala's case classes and built-in support for pattern matching. Singleton objects are a simple way to group functions that aren't class members.

  • Statically Typed Programming Language:

Scala's expressive type system ensures that abstractions are employed safely and consistently at compile time. The type system, in particular, supports:

  1. Classes that are generic
  2. Annotations on variance
  3. Type bounds (upper and lower)
  4. As object members, inner classes, and abstract type members
  5. Types of compounds
  6. Self-references typed explicitly
  7. Conversions and implicit parameters
  8. Methods that are polymorphic
  • Scala is extensible:

In practice, domain-specific language extensions are frequently required when developing domain-specific applications. Scala offers a unique set of language tools that make adding new language constructs in the form of libraries a breeze. In many cases, this can be accomplished without the use of meta-programming tools like macros. Consider the following scenario:

  1. Implicit classes enable extension methods to be added to existing types.
  2. With custom interpolators, string interpolation can be extended by the user.
  • Interoperability:

Scala is built to work well with the widely usedJava Runtime Environment (JRE). The connection with the popular object-oriented Java programming language, in particular, is as frictionless as feasible.Scala has direct counterpartsfor newer Java features like SAMs, lambdas, annotations, and generics.

Scala features that don't have Java equivalents, such as default and named parameters, compile as close to Java as possible. Scala uses the same compilation methodology as Java (separate compilation, dynamic class loading) and provides access to hundreds of high-quality libraries already available.

Scala As A Data Science Tool:

Scala is a sophisticated programming language with the ability to support a wide range of tools. At KnowledgeHut, theData science course durationwould be 20+ hours and you will get hands-on experience with more than 100 datasets from real companies. After acquiring this learning experience, Scala programming can be quite beneficial when working with large amounts of data. The following are some of Scala's most important Data Science applications:

  • Scala is used by the Spark Framework to handle real-time data streaming. In data analytics, the Spark Framework makes use of Scala.
  • Apache SparkMLliband ML are the libraries for Machine Learning tasks
  • Scala has some excellent natural language processing libraries, such asScalaNLP, Epic, and Puck
  • DeepLearning.scalais a great toolkit to do Deep Learning related tasks
  • Breeze, Saddle,Scalalabare the data analysis tools available
  • Breeze-viz and Vegas are the plotting library on visualization for Data Scientist
  • Akka for distributed applications
  • Spray and Slick Web Application and web services

Data Types In Scala:

All values in Scala, including numerical values and functions, have a type. A portion of the type hierarchy is depicted in the diagram below -

How To Use Scala for Data Science (3)

(Video) Introduction: Spark and Scala for Data Science

  • Scala Type Hierarchy:

Any, often known as the top type, is the supertype of all kinds.equals, hashCode, andtoStringare some of the universal methods defined in it.AnyValandAnyRefare direct subclasses ofAny.

AnyValis the root class of all value types. There are nine non-nullable predefined value types:Double, Float, Long, Int, Short, Byte, Char, Unit,andBoolean.Unitis a value type that contains no information. There is only one instance of I that can be declared in this way:().Because all functions must return something,Unitis occasionally a useful return type.

AnyRefis a class that represents reference types. All reference types are declared as non-value types.AnyRefis a subtype of every user-defined type in Scala.AnyRefrefers tojava.lang.Objectwhen Scala is used in a Java runtime environment. Here's an example of how strings, integers, characters, boolean values, and functions, like everything else, are of the typeAny-

val list: List[Any] = List("This is a string",548,// an integer'c',// a character true, // a boolean value () =>"an anonymous function returning a string")list.foreach(element => println(element))


Thisisa string548ctrue<function>
  • Type Casting:

The following is how value types can be cast:

How To Use Scala for Data Science (4)

For instance:

val x: Long = 6496349val y: Float = x // 6.4963493E7 (note that some precision is lost in this caval face: Char = 'val number: Int = face // 97

Casting is a one-way process. This isn't going to work:

val x: Long =649634925val y: Float = x //6.4963493E7val z: Long = y // Does not conform

A reference type can also be cast to a subtype.

Nothing and Null:

Nothing, commonly known as the bottom type, is a subtype of all kinds. There isn't a value of type Nothing. Non-termination, such as a thrown exception, program exit, or an infinite loop, is a typical usage (i.e., it is the type of an expression that does not evaluate a value or a method that does not return normally).

All reference types have a subtype called Null (i.e. any subtype of AnyRef). It only has one value, which is denoted by the keyword literal null. Null is primarily given for interoperability with other JVM languages and should be avoided at all costs in Scala programs.

Expressions In Scala:

Expressions are statements that can be computed:


You can use println to output the results of expressions:

println(7) // 7println(2+2) //4println("Hello Universe!") // Hello Universe!println("Hello," + " Universe!") // Hello, Universe!


The val keyword can be used to name the results of expressions:

val x = 3 + 2println(x) // 5

Values are named results, such as x in this case. A value is not re-computed when it is referenced.

(Video) Scala Programming | Data Science

Re-assigning values is not possible:

x = 7 // This does not compile.A value's type can be omitted and inferred, or it can be declared explicitly:val x: Int = 3 + 2


var x = 3 + 2x = 7 // This compiles because x is declared with the var keyword.println(x * x) // 49

The type of a variable can be ignored and inferred, just like the type of a value, or it can be expressed explicitly:

var x: Int = 3 + 2


You can combine expressions by putting a {} around them. This is referred to as a block.

println({ val x = 3 + 2 x + 5}) // 10

Functions and Methods In Scala:


A function is a collection of statements that work together to complete a task. A Scala function declaration has the following form:

def functionName ([list of parameters]) : [return type]

You can write an anonymous function (i.e., a function with no name) that returns a given number plus one :

(x: Int) => x + 1

A list of parameters appears to the left of =>. An expression involving the parameters is shown on the right.

You can also give functions names, such as:

val addOne = (x: Int) => x + 1println(addOne(1)) // 2

Multiple parameters can be used in a function:

val add = (x: Int, y: Int) => x + yprintln(add(3, 2)) // 5

It can also have no parameters:

val getTheAnswer = () => 75println(getTheAnswer()) // 75


Methods and functions are fairly similar in appearance and behavior, but there are a few major differences.

The def keyword is used to define methods. A name, parameter list(s), return type, and body are all followed by def:

def add(x: Int, y: Int): Int = x + yprintln(add(3, 2)) // 5

Multiple argument lists can be passed to a method:

def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplierprintln(addThenMultiply(3, 2)(5)) // 25

Alternatively, there are no parameter lists at all:

def name: String = System.getProperty("")println("Hello, " + name + "!")

Methods can also have multiple-line expressions:

(Video) Building a Data Science Platform in Scala

def getSquareString(input: Double): String = { val square = input * input square.toString}println(getSquareString(3)) // 9

Main Method:

In a Scala program, the main method is its starting point. The Java Virtual Machine requires a single-parameter main method named main, which takes an array of strings as an input.

The primary focus of modular programming is that it allows us to separate components and partition software into layers in order to create quick, scalable programs that can be readily adjusted later in the development life cycle. You can define the main method using an object like follows:

object Main { def main(args: Array[String]): Unit = println("Hello, Scala Learner!")}

Classes And Objects In Scala


The class keyword, followed by the class's name and constructor parameters, can be used to define classes

class Greeter(prefix: String, suffix: String) { def greet(name: String): Unit = println(prefix + name + suffix)}

The method named greet return type is Unit, indicating that there is nothing useful to return. In Java and C, it is similar to void. (There is one difference: because every Scala expression must have a value, there is a singleton value of type Unit, written as (). It doesn't include any information.)

The new keyword can be used to create a class instance:

val greeter = new Greeter("Hello, ", "!")greeter.greet("Scala Learner") // Hello, Scala Learner!

Case Classes:

A "case" class is a specific sort of class in Scala. Case class objects are immutable by default, and they are compared by value (unlike classes, whose instances are compared by reference). As a result, they're even more beneficial for pattern matching.

The case class keywords can be used to define case classes:

case class Point(x: Int, y: Int)

Case classes can be created without using the new keyword:

val point = Point(1, 2)val anotherPoint = Point(1, 2)val yetAnotherPoint = Point(2, 2)


Objects are one-of-a-kind manifestations of their own definitions. They can be thought of as singletons in their own classes

The object keyword can be used to define objects:

object IdFactory { private var counter = 0 def create(): Int = { counter += 1 counter }}

You may find out more about an object by looking up its name:

val newId: Int = IdFactory.create()println(newId) // 1val newerId: Int = IdFactory.create()println(newerId) // 2

Packages And Imports:

Creating a Package:

Scala creates namespaces with packages, allowing you to modularize your programs. Packages are defined at the top of a Scala file by stating one or more package names.

package usersclass User

One convention is to name the package after the directory in which the Scala file is located. Scala, on the other hand, is unconcerned about file layout. An sbt project's directory structure for package users might look like this:

- ExampleProject - build.sbt - project - src - main - scala - users User.scala UserProfile.scala UserPreferences.scala - test

Notice how the users directory is contained within the scala directory, and how the package contains numerous Scala files. The package declaration could be the same in every Scala file in the package. The other way to declare packages is by using braces:

package users { package administrators { class NormalUser } package normalusers { class NormalUser }}

As you can see, this enables package nesting and gives you more scope and encapsulation control.

(Video) Should you learn Scala or Python?

If the code is being created within an organization that has a website, the package name should be all lower case, and the format convention should be <top-level-domain>.<domain-name>.<project-name>. If Google had a project called SelfDrivingCar, for example, the package name would be:

package class Lens

This could be equivalent to the directory structure below:



Import clauses are used to get access to other packages' members (classes, traits, functions, and so on). When accessing members of the same package, an import clause is not necessary. Import clauses are limited in scope:

import users._ // import everything from the users packageimport users.User // import the class Userimport users.{User, UserPreferences} // Only imports selected membersimport users.{UserPreferences => UPrefs} // import and rename for convenience

Imports can be used everywhere in Scala, which is one of the ways it differs from Java:

def sqrtplus1(x: Int) = { import scala.math.sqrt sqrt(x) + 1.0}

If you need to import something from the project's root because of a naming issue, prefix the package name with _root_:
package accounts

import _root_.users._

To summarize imports and packages in one example:

package com.acme.myapp.model class Person ... import users.* // import everything from the `users` package import users.User // import only the `User` class import users.{User, UserPreferences} // import only two selected members import users.{UserPreferences as UPrefs} // rename a member as you import it 

Note: By default, the scala and java.lang packages, as well as object Predef, are imported.

Parallel Collection In Scala:

Parallel collections are intended to be utilized in the same way that sequential collections are. The only difference being how a parallel collection is obtained. In general, there are two ways to make a parallel collection. To begin, use the new term in conjunction with a correct

import statement:import scala.collection.parallel.immutable.ParVectorval pv = new ParVector[Int]

Second, by converting from a sequential collection:

val pv = Vector(1,2,3,4,5,6,7,8,9).par

These conversion methods are worth elaborating on: sequential collections can be converted to parallel collections by invoking the par method of the sequential collection, and parallel collections can be converted to sequential collections by invoking the seq method of the parallel collection.


While the parallel collections abstraction resembles typical sequential collections in appearance, it's crucial to note that its semantics differ, particularly in terms of side effects and non-associative operations. Parallel collections' concurrent and "out-of-order" semantics have two implications:

1. Side-effecting operations can lead to non-determinism: Given the parallel collections framework's concurrent execution semantics, operations on a collection that create side-effects should be avoided in order to maintain determinism. For instance, using an accessor method like foreach to increment a var declared outside of the closure and supplied to foreach is a basic example.

scala> var sum = 0sum: Int = 0scala> val list = (1 to 1000).toList.parlist: scala.collection.parallel.immutable.ParSeq[Int] = ParVector(1, 2, 3,...scala> list.foreach(sum += _); sumres01: Int = 524896scala> var sum = 0sum: Int = 0scala> list.foreach(sum += _); sumres02: Int = 365489scala> var sum = 0sum: Int = 0scala> list.foreach(sum += _); sumres03: Int = 756821

2. Non-associative operations lead to non-determinism: Because of the "out-of-order" semantics, it's also important to avoid non-determinism by only performing associative operations. That is, when invoking a higher-order function on pcoll, such as pcoll.reduce(func), the order in which func is applied to the items of pcoll should be random. A non-associative operation like subtraction is a simple yet apparent example:

scala> val list = (1 to 1000).toList.parlist: scala.collection.parallel.immutable.ParSeq[Int] = ParVector(1, 2, 3,...scala> list.reduce(_-_)res01: Int = -546589scala> list.reduce(_-_)res02: Int = -51357scala> list.reduce(_-_)res03: Int = -651278

In the example above, we take a ParVector[Int], call reduce, and pass it_-_, which simply takes two unnamed items and subtracts one from the other. The outcome of two runs of reduce( _-_) on the same collection will not be the same because the parallel collections framework creates threads that, in effect, perform reduce( _-_) on separate regions of the collection independently.

(Video) Data Science in Scala with ScalaPy - Shadaj Laddad

Scala’s Benefits:

  • In Data Science perspective, Scala is nearly ten times faster than Python in terms of performance.
  • Most JVM libraries can be used with Scala, allowing it to become firmly ingrained in enterprise programming.
  • This language combines functions within class declarations and shares some legible syntax aspects with popular languages like Ruby.
  • It has several functional features including string comparison advances and pattern matching, among others.

Scala’s Drawbacks:

  • Because of the combination of functional and object-oriented characteristics of this language, type-information can be difficult to comprehend at times.
  • The community of developers for this language is relatively small.

More than a Small Wonder

Scala is a multi-stream wonder of the twentieth century. It has experienced phenomenal growth since its inception, and it is without a doubt one of the most in-demand programming languages. So that brings us to the end of this article. I hope this article has shed some light on Scala, its characteristics, and the numerous types of operations that may be conducted with it.


How is Scala used in data science? ›

Scala provides you with the ability to develop strong data pipelines thanks to its rich functional libraries for interfacing with databases and building scalable frameworks. Many high-performance data science frameworks developed on top of Hadoop are typically implemented in Scala or Java.

Can Scala be used for machine learning? ›

Feature scaling in machine learning is one of the most critical steps during the pre-processing of data before creating a machine learning model. Scaling can make a difference between a weak machine learning model and a better one. The most common techniques of feature scaling are Normalization and Standardization.

Is Scala faster than Pyspark? ›

Scala programming language is 10 times faster than Python for data analysis and processing due to JVM. The performance is mediocre when Python programming code is used to make calls to Spark libraries but if there is lot of processing involved than Python code becomes much slower than the Scala equivalent code.

Should I learn Scala or Python? ›

If you want to work on a smaller project with less experienced programmers, then Python is the smart choice. However, if you have a massive project that needs many resources and parallel processing, then Scala is the best way to go.

Is Scala an ETL tool? ›

You can automatically generate a Scala extract, transform, and load (ETL) program using the AWS Glue console, and modify it as needed before assigning it to a job. Or, you can write your own program from scratch.

Why Scala is faster than Python? ›

When it comes to performance, Scala is almost ten times faster than Python. Scala's reliance on the Java Virtual Machine (JVM) during runtime imparts speed to it. Generally, compiled languages perform faster than interpreted languages. Since Python is dynamically typed, the development speed reduces.

Do data scientists use Scala? ›

It is particularly good at analyzing large sets of data without any significant impact on performance and thus Scala is being adopted by many developers and data scientists.

Can Scala replace Java? ›

Although Scala programming is slightly more complicated than Java, one line of Scala code can easily replace twenty lines of “simple” Java code. Thus, Scala allows developers to write concise and compact code. However, Java is more beginner-friendly with an easy learning curve as compared to Java.

Should I learn Scala after Python? ›

Scala is a scalable language with access to Java libraries. Hence it is better than Python in terms of scalability and efficiency.

Why is Scala so difficult? ›

Because Scala, being based on the JVM – which was built for Java, one of the canonical OO languages – has to resort to certain tricks to achieve some of the key aspects of functional programming: the ability to pass functions as arguments and to return them as results.

Why is Scala not more popular? ›

It is believed that Scala is bit harder to learn due to it's conciseness and tricky/confusing syntax. Thus, comparing it to Java, Java is pretty easy to learn. As, Scala is more concise, nested code and have confusing syntax, makes it less readable whereas Java has fine readability.

Should I learn Spark or Scala? ›

Apache Spark is written in Scala. Hence, many if not most data engineers adopting Spark are also adopting Scala, while Python and R remain popular with data scientists. Fortunately, you don't need to master Scala to use Spark effectively.

Is Scala harder than Python? ›

Scala is not a difficult language to get started with, but it is considered a complicated programming language to master. The static-typing makes Scala more challenging to use compared to Python.

Should I use PySpark or Scala? ›

PySpark is more popular because Python is the most popular language in the data community. PySpark is a well supported, first class Spark API, and is a great choice for most organizations. Scala is a powerful programming language that offers developer friendly features that aren't available in Python.

Is Scala OOP or functional? ›

Scala is a pure object-oriented language in the sense that every value is an object.

What big companies use Scala? ›

Top 10 Startups using Scala
  • 2.1 Twitter.
  • 2.2 Nubank.
  • 2.3 DeliveryHero.
  • 2.4 Coursera.
  • 2.5 Asana.
  • 2.6 Zalando.
  • 2.7 Monzo.
  • 2.8 Klarna.

Is Scala better than SQL? ›

Native/SQL is generally the fastest as it has the most optimized code. Scala/Java does very well, narrowly beating SQL for the numeric UDF. The Scala DataSet API has some overhead however it's not large. Python is slow and while the vectorized UDF alleviates some of this there is still a large gap compared to Scala or ...

How long does it take to learn Scala? ›

How long will it take to learn Scala? It takes around two to three months to learn Scala if you don't know Java. If you have used Java, you can learn Scala in a month.

Is Scala good for big data? ›

Scala has a simple structure which makes it suitable for big data processors. The Scala Library Index (Scaladex) is a representation of a map of all published Scala libraries. A developer can query more than 175,000 releases of Scala libraries.

Should I learn Scala or R? ›

Scala is more popular and broadly used, and has a larger job market especially for data engineering. Both are functional but Scala is more interoperable with Java libraries, probably a big factor in its popularity. I prefer Scala for a number of reasons, but in terms of jobs Scala is the clear leader.

Is Scala still used today? ›

Before the luxurious, full-featured ecosystems and programming languages of today, things like Data Science used to be significantly different. One language that has been used a lot in the past and is still used today is Scala.

Should I learn Scala for data engineering? ›

Yes, Scala is good for data engineering. Features like type safety, conciseness, customizability, and high production performance make it easier for data engineers to build efficient pipelines using Scala. Even popular frameworks like Spark and Databricks leverage Scala.

Should I learn Scala or Julia? ›

In the question“What is the best programming language to learn first?” Julia is ranked 16th while Scala is ranked 27th. The most important reason people chose Julia is: Julia runs almost as fast as (and in fact in some cases faster than) C code.

Is Scala worth learning in 2023? ›

Therefore, high-level languages are prevalent among developers. Functional languages such as Elixir and Scala can be challenging to learn, but they are well worth the effort — Scala is even one of the most highly-paid languages.

Is Scala still in demand? ›

Not only are Scala developers in high demand, but developers can use Scala to build scalable applications for data processing, distributed computing and web development. This is all possible because Scala is a unique combination of functional and object-oriented programming paradigms.

Is Scala frontend or backend? ›

You can use Scala for frontend development, but you're no longer forced to work with Node. js for the backend because you want to maintain shared code between your server and your frontend.

Is Scala a dead language? ›

Scala is a dying language with no future

No, it's not true. The need for Scala developers is higher than ever before. Scala is still one of the top languages for distributed computing using Apache Spark and processing pipelines when using Akka.

Is Scala high paying? ›

As of Mar 6, 2023, the average annual pay for a Scala Developer in the United States is $141,390 a year. Just in case you need a simple salary calculator, that works out to be approximately $67.98 an hour. This is the equivalent of $2,719/week or $11,782/month.

What is Scala best used for? ›

Scala Is Used for Building Data-Intensive, Distributed Applications and Systems. Scala is a general-purpose programming language built on the Java virtual machine. What's that mean? It means you can use Scala to build web applications and services, write back-end code for mobile apps, or create big data systems.

Is Scala worth learning data science? ›

Yes, Scala is good for data engineering. Features like type safety, conciseness, customizability, and high production performance make it easier for data engineers to build efficient pipelines using Scala. Even popular frameworks like Spark and Databricks leverage Scala.

Why is Scala used for data? ›

Scala Is Used for Building Data-Intensive, Distributed Applications and Systems. Scala is a general-purpose programming language built on the Java virtual machine. What's that mean? It means you can use Scala to build web applications and services, write back-end code for mobile apps, or create big data systems.

What is the advantage of using Scala? ›

The Advantages of Scala

Scala has an exact syntax, eliminating boilerplate code. Programs written in Scala require less code than similar programs written in Java. It is both an object-oriented language and a functional language. This combination makes Scala the right choice for web development.

Why Scala is highest salary? ›

Companies mostly hire Scala developers who can help them in creating highly scalable applications, and performing regular updates. In a nutshell, Scala professionals are some of the most well-paid professionals as it supports a wide range of development solutions.

Why are Scala developers paid so much? ›

Secondly, Scala is applied in a number of the most demanded areas (i.e., big data), the type of projects that require Scala are usually complex and high-value tasks, and there are fewer Scala developers in the market, which makes employees pay more to hire the developer.

Why does Netflix use Scala? ›

Netflix. The streaming giant uses Scala for search algorithms, restful APIs and recommendations. Now, we could debate how well those recommendations actually work but the company is clearly satisfied. There's an hour-long talk on the specifics of Scala use at Netflix with plenty of fascinating code examples.

What is the main drawback of Scala language? ›

The Disadvantages of Scala Programming Language

As a complex language, it has a more difficult learning curve than some other programming languages, especially if you are not familiar with functional programming concepts.

Is it hard to learn Scala? ›

Despite popular opinions on the Internet, Scala is not a difficult language to try. It's mainly because of its seamless compatibility with Java and the kind of dual nature (Functional Programming vs Object-Oriented Programming). You can get your hands dirty just by starting to write Java-like code in Scala.

What is replacing Scala? ›

Kotlin, Python, Clojure, Java, and Golang are the most popular alternatives and competitors to Scala. scala_lang.

How many days it will take to learn Scala? ›

How long will it take to learn Scala? It takes around two to three months to learn Scala if you don't know Java. If you have used Java, you can learn Scala in a month.


1. Setting up Scala for Data Science in VS Code and IntelliJ
2. What is Scala for Data Science - TechTablet - Varun Rao
(Varun Rao - Tech Tablet)
3. Spark Scala | Spark Tutorial | Scala Tutorial | Spark Scala Full Course | Intellipaat
4. Scala: What is it and should you learn it? [in 7 minutes]
(Code First with Hala)
5. Getting to Know Scala For Data Science
(Michael Malak)
6. Should Data Engineers learn Scala?
(Data with Zach)
Top Articles
Latest Posts
Article information

Author: Prof. An Powlowski

Last Updated: 12/30/2022

Views: 6235

Rating: 4.3 / 5 (44 voted)

Reviews: 83% of readers found this page helpful

Author information

Name: Prof. An Powlowski

Birthday: 1992-09-29

Address: Apt. 994 8891 Orval Hill, Brittnyburgh, AZ 41023-0398

Phone: +26417467956738

Job: District Marketing Strategist

Hobby: Embroidery, Bodybuilding, Motor sports, Amateur radio, Wood carving, Whittling, Air sports

Introduction: My name is Prof. An Powlowski, I am a charming, helpful, attractive, good, graceful, thoughtful, vast person who loves writing and wants to share my knowledge and understanding with you.