Scala Introduction - Synerzip

https://in.linkedin.com/in/sujithsudhakaran
An Introduction
to
By
Sujith Sudhakaran

Agenda
● Imperative Programming
● Renaissance of Functional Programming
● Scala Intro
● Concepts
● Popular frameworks

Agenda
– Understanding our usual style
– Bottle neck – Moore's Law
– Concurrency and Parallel Programming
● Scala Intro
● Concepts

Imperative Programming...

Imperative clichés...

Imperative clichés...
WHY?

Moore’s Law

Concurrency

Parallel programming

Concurrency & Parallel
programming
Really HARD
to get it RIGHT

Agenda
– Non determinism and side effects
– Functional programming
● Scala Intro
● Concepts

Non-determinism
var x = 0
async { x = x + 3; println(x)}
async { x = x * 5; println(x)}

What's happenning here?

What's happenning here?
Side effects

Resolving the side effect...

What we learnt so far...
● Immutability
● Pure functions

What is Functional
Programming?

OOPs!!

Agenda
● Scala Intro
– Scala as unifier
– Class hierarchy
– Keywords used
– Scala being concise
● Concepts

Scale Language - Introduction

Scala – Class Hierarchy

Scala – keywords used in the
examples
● val: to declare a immutable variable
● var: to declare a mutable variable
● def: to define a function
● println: to print out line
● trait: similar to interfaces in java
● sealed: keyword used to specific classes locally only
● object: keyword used to instantiate a singleton object
● extends: used for inheritence
● with: used while doing multiple inheritence
● match: keyword for pattern matching
● case: used for pattern matching
● override: used to override a behavior of an interface
● =>: used to show the some input mapping to output

Scala being concise...
Type inference

High-level

Less boiler plate

Scala being OO...
Every value is an object
– Eg: 1 // Yes, its an object
– 1.toString // method can be called
– 1 + 2 + 3 is equivaled to (1).+(2).+(3)

Agenda
● Scala Intro
● Concepts
– Call by value/Call by name
– Higher order functions
– Tail recursion
– Traits
– Abstract Types
– Partial functions
– Pattern matching

Call by value/Call by name
Call by value

The problem we may face...

Call by name

Functions
● First class values
● Function type S => T is
trait Function1[-S, +T] {
def apply(x: S): T
}
● def sum(x: Int, y: Int) = x + y
● sum(1, 2)
● (x: Int, y: Int) => x + y // What is the use of this function?

Higher order functions
What’s common in this two programs?

● Examples: map, filter, reduce etc.

Tail recursion
What's the difference in these programs?
> f (21 == 0) 14 else gcd(21, 14 %21)
> if (false) 14 else gcd(21, 14 %14)
> gcd(21, 14 %21)
> gcd(21, 14)
> if (14 == 0) 21 else gcd(14, 21 %14)
> gcd(14, 7)
> gcd(7, 0)
> 7
> if (5 == 0) 1 else 5 * fact(5-1)
> 5 * fact(4)
> 5 * (4 * fact(3))
> 5 * (4 * (3 * (fact(2))))
> 5 * (4 * (3 * (2 * fact(1))))
> 5 * (4 * (3 * (2 * (1 * fact(0))))))
> 5 * (4 * (3 * (2 * (1 * 1)))))
> 120

Tail recursion
What's the difference in these two example?
> f (21 == 0) 14 else gcd(21, 14 %21)
> if (false) 14 else gcd(21, 14 %14)
> gcd(21, 14 %21)
> gcd(21, 14)
> if (14 == 0) 21 else gcd(14, 21 %14)
> gcd(14, 7)
> gcd(7, 0)
> 7
> if (5 == 0) 1 else 5 * fact(5-1)
> 5 * fact(4)
> 5 * (4 * fact(3))
> 5 * (4 * (3 * (fact(2))))
> 5 * (4 * (3 * (2 * fact(1))))
> 5 * (4 * (3 * (2 * (1 * fact(0))))))
> 5 * (4 * (3 * (2 * (1 * 1)))))
> 120

Tail recursion
The Problem!!

Tail recursion
The Problem!!
StackOverflowError Exception

Tail recursion - Solution

Traits - Mixin class composition
● Share interfaces and fields between classes
● Can be extended but NOT instantiated
● Use the keyword with to extend from multiple traits
● Traits with code are known as Mixins
● Abstract and concrete fields

Traits – Multiple Inheritence(Diamond
Problem)
Diamond Problem
Staff
Person
Student Teacher
Student
Teacher

Traits – Solving Diamond Problem
Linearization

Linearization
Derived
B
C
Base
AnyRef
Any
A
Base
AnyRef
Any

Linearization
ABCDerived Base AnyRef Any

Abstract Types
The Problem

Abstract Types
The solution

Pattern matching
● How we used switch statements?
● Generalization of switches

Pattern matching – More
examples

Partial functions
● In FP, Input => Output
● Form:
val divide = new PartialFunction[Int, Int] {
def apply(x: Int, y: Int) = x / y
def isDefinedAt(x: Int, y: Int) = y != 0
}
● def collect[B](pf: PartialFunction[A, B])

Partial functions - Example
Guess the type

Partial functions - Example

Pattern matching & Partial
Funtion
More examples

To summarize...
● Compatible
● OOP
● Functional
● Concise
● High level abstractions over data structures
● Compose functions
● Statically typed
● Extensible

Popular frameworks
● Apache Spark
● Akka
● Play Framework
● Other trending projects in scala

Who is using Scala?

References
● Martin Odersky, "Working Hard to Keep It Simple" -
OSCON Java 2011
● Martin Odersky: Scala with style
● DSL: Writing web framework router
● State you're doing it wrong
● Origin of scala

Questions!!

Thank You!

Scala Introduction - Synerzip

More Related Content

Similar to Scala Introduction - Synerzip

More from Synerzip

Recently uploaded

Scala Introduction - Synerzip

Editor's Notes