DASVM’s Scala Developer training offers an in-depth understanding of all the essentials of Scala programming language from scratch. It will enable you to master object-oriented aspects of Scala, trait methods, XML, etc. with practical executions and examples. By the end of the training, you’ll gain a solid working knowledge of Scala and will be able to implement this knowledge in real-world.

Scala language is built on top of JVM (Java Virtual Machine) and offers all the features of an Object Oriented Programming (Oop).  It has the expressive power of a dynamic programming language without compromising on type safety. Scala is described as a multi-paradigm programming language that can express common programming patterns in a concise, elegant, and type-safe way. Scala plays a significant role in Big Data, as the language is used to develop Apache Spark.

Course Objectives:

The core skills that you will gain are as follows:

• Understand Storm Architecture and basic distributed concepts
• Understand Logic Dynamics and Components in Storm
• Understand Legacy architecture of real-time systems
• Understand the difference between Apache Spark and Hadoop
• Learn Scala and its programming implementation
• Build Spark Applications using Java, Scala, and Python
• Implement Spark on a cluster
• Gain insight into the functioning of Scala
• Develop Real-life Storm Projects

Course content

Scala Basics

• IntelliJ Installation
• Valls and Vars
• Hiding a Val with another Val
• Scala and Types
• Defining a Method
• Functions, Classes, objects
• Constructors
• Singleton object, Companion Classes and Objects and Case Classes and Others
• Strings operation in Scala

Pattern match          

• Pattern Matching
• ALL the Patterns!
• Patterns Everywhere
• Braceless Syntax
• Pattern Matching and Regex
• Assignment

Building Scala project using IntelliJ

• Scala projects in IntelliJ
• IntelliJ Worksheets
• Method Parameters and Return Types
• Methods with no return types
• Expressions and Statements
• Assignments and Unit
• Tuples
• Tuples continued
• Re-writing Rules: Infix
• Re-writing Rules: Appl
• e-writing Rules: Update
• General Notes on Re-writing
• Assignment

Control Structure

• Expressions and Statements Recap
• Unit and Side Effects
• Alternatives to Returning Unit
• If, ternary and types
• val and var, IDE tricks
• ..catch…finally and type inference
• While loop statement, and @tailrec
• For Statements and Expressions
• ..Yield
• The Four Gs of For
• For – more than just loops
• Match expressions
• Match Guards
• More Matching
• String Interpolation
• Assignment9-10-11-12

Methods

• Private Methods
• Nested Methods
• Scoping of Nested Methods
• Function Literals
• Passing Function Literals
• How Functions Work
• Other Methods on Function
• Higher Order Functions
• Writing a Higher Order Function
• Placeholder Syntax
• Placeholders with Types
• Partial Application
• Partial Application continued
• Closures
• Partial Functions
• Partial Functions continued
• Partial Functions, map vs collect
• Var Args
• Using Var Args
• Var Args, Expansion
• Default and Named Parameters
• Using the Contents of a File
• Using Generics and Higher Order Functions
• Calling the Generic Method
• Currying Method Parameters
• Curried Generic Loan
• Function Arity
• Writing Our Own While Loop
• By-name Functions
• Assignment

Inheritance

• Classes and Abstract Classes
• Abstract Classes
• Anonymous Classes and Overrides
• Uniform Access
• val, def and lazy val
• Inheriting and Extends
• Invoking Superclasses
• Ex: Alternative Car Definition
• override keyword
• override keyword continued
• final keyword
• final keyword continued
• final classes
• Ex: case classes
• Domain Models
• Cars and Vehicles Parking Structure
• Composition and inheritance
• Top Classes
• Top Types Example
• Organization From the Top
• Bottom Classes
• Null and Nothing
• Even More Nothing
• Scala Type Calculus
• Scala Type Inference Tricks
• Primitives and Implicit Conversions
• Rich Wrappers
• @specialized
• @specialized generation
• Extension Methods and Implicit Classes
• Value Class
• Nil, Null, Nothing, None
• Option
• Working with Option
• Option continued
• equals and hashCode
• Generate with IDEA
• Follow this formula
• Sub classes
• Just use case classes
• Product Types
• Product Type Features
• Assignment

Traits

• Introduction
• Multiple Inheritance
• Traits Compared to Interfaces
• Creating a Trait
• Using a Trait in a Class
• Polymorphism and Rich Interfaces
• Multiple Traits
• How’d it do that?
• Stacking Traits
• Stacking Traits 1
• Stacking Traits 2
• Stacking Traits 3
• Construction Composition
• Traits vs Classes
• Trait Initialization
• Trait Initialization Fixes
• abstract override
• Implementing the Abstract
• Traits with Type Parameters
• Another CompareAge class
• Package Structure Alternatives
• Testing in Scala
• Namespace Notation
• More Parts of the Model
• Package Visibility
• wine package
• The PairWine object
• Package Objects
• Importing from an object
• Importing from an instance
• Importing Fu: Renaming
• Selective Importing
• Companion Objects
• Assignment

Collection in Scala

• Collections Intro
• List Initialization and Cons
• The Immutable Linked List
• List Properties
• Initializing Lists
• Converting to Lists
• List is Covariant
• Constant Time Operations
• Linear Time Operations
• Operations that Depend on Position
• Higher Order Functions
• Predicate Based Functions
• Folds
• Fold Alternatives
• Sorting
• Even More Functions
• Indices, zip, unzip in List
• Sequences
• Sequences Performance
• Sets
• Maps
• Sets and Maps Performance
• Mutable vs Immutable
• LinearSeq vs IndexedSeq
• mutable vs immutable
• The -> Extension Method
• Simple Map Iteration
• More Functional Style
• Array & Vector
• map, flatMap, filter and for-comprehensions
• Opening and Reading a File
• Consistent API
• Other Sequences
• The Mighty Vector
• Vector (continued)
• Immutable Sets
• Sorted and Mutable Sets
• Sorted and Mutable Maps
• Key and Value Operations
• Views
• Streams
• Exercises (and how to run them in IntelliJ)
• Assignment

Advance Functions

• Dark Sugar syntax
• Advance pattern matching -1
• Advance pattern matching – 2
• Partial Functions
• Functional Collections: A functional Set
• Enhancing A Functional Set
• Currying and Partially Applied Functions
• Lazy Evaluation
• Lazy Evaluation Exercise: A Potentially Infinite Stream
• Infinite Streams Proficiency: More Exercises
• Monads
• Monads: Exercises
• A Type Class End-to-End example: JSON Serialization
• HOFs and Curries (Exercises)
• Tuples and Maps (Exercises)

Scala Project Building Tools: SBT

• Into SBT
• Using SBT
• SBT Project Source Layout
• sbt
• Example build.sbt
• Example plugins.sbt
• Making a Custom Setting
• Multiple Project Support
• Mixing Scala and Java
• Scala/Java Compile Cycle
• Calling Java from Scala
• Scala 2.12 and Java 8
• Scala/Java Function Compatibility
• Handling Nulls
• Options to Nulls

Test in Scala

• Pre and Post Conditions
• Eliding
• Requirements
• Testing
• Scalatest
• FunSuite
• FunSpec
• Matchers
• Matchers 2
• Matchers 3
• Unit vs Integration Testing
• Scala mock
• Unit Testing with Mocks
• Advantages of Mocks
• Mocks vs Stubs
• Fakes
• Property Driven Testing
• Custom Property Generators
• Testing with Futures
• Waiting for the Future
• Full Async Suites
• Building Scala, SBT, Java Compatibility
• Assignment

Conclusion

• Project Guidance
• Core Scala based project code flow explanation for tracing any industry project

To see the full course content Download now