Scala Fundamentals
This course covers the Scala programming language and some of its more important APIs. This course focuses on the core parts of Scala, especially its functional programming on the one hand and on its OOP capabilities on the other. The course provides its participants with the required knowledge and practical experience required for using this relatively new programming language in a practical way.
This course was developed for people with basic knowledge of software development and a background in object-oriented programming. It can be either a programming course that was taken in the past or practical experience.
This course includes 70 academic hours delivered in 14 weekly meetings. The training material (slides, video clips, assignments, solutions, and code samples) for the entire course is organized on the e-learning platform we use during the course. Each meeting includes a theoretical lecture together with practical practice (at least 25% of each meeting). The practical practice includes coding by the instructor, followed by the students, and coding by the students with the instructor's assistance. Each meeting is captured on video in order to allow the students an effective learning process at home.
The course includes lots of relatively small assignments and a final project the students will develop as an open-source project and place it on GitHub in order to allow other Scala developers to use it.
Meeting | Date | Topic | Sub Topics |
1 |
| Introduction
What is Scala? Scala Advantages Scala History Installation Hello World The Scala Interpreter IDE Plugin
Scala Basics
Define Variables Variables Types Inference Specifying Variable Type Define Functions The Unit Type Writing Scripts The while Loop The if Statement The foreach Loop The for Loop Scala Basic Types Parameterize Arrays Arrays Implementation Arrays Short Syntax The List Type The ::: Operator The :: Operator The Nil Value The Tuple Type The Set Type The Map Type File Reading Two Dimensions Arrays Blocks in Scala Multiple Lines Expressions Lazy Evaluation
|
|
2 |
| Classes
Class Definition Visibility Modifiers Method Parameters Shorter Syntax The Semicolon Static Members The this Keyword Defining Constructors Standalone Application The fsc Compiler Overriding Methods The require Function Methods Overloading Anonymous Inner Class
Objects
Singleton Objects
|
|
3 |
| Operators
Operatos & Methods Arithmetic Operators Relational Operators Logical Operators Bitwise Operators Objects Comparison Operators Precedence Operators Associative Operators Overloading The unary_ Operator
Control Statements
The Returned Value
The if Expression The while Loop The do..while Loop The for Expression The for yield ExpressionX The match Expression Variables Scope The break & continue Keywords
|
|
4 |
| Functions
Introduction Methods Local Functions Anonymous Functions Repeated Parameters Tail Recursion Functions Function Type By Names Parameters Function Values are Objects Anonymous Class Syntax
Closures
Introduction
What is a Closure? Changes
Unit Testing
Introduction
The FunSuite Class
Inheritance
Introduction
Abstract Class Parameter-less Methods Extending Classes Inheritance Meaning Overriding Methods & Fields Parametric Fields Invoking Super Class Constructors The override Keyword Polymoprphism Final Class Final Method
|
|
5 |
| Traits
Introduction Traits Definition Traits Multiple Inheritance
Packages
Introduction
The Java Global Hierarchy The Default Package The Package Statement Reverse Domain Name Convention Nested Packages Packages Hiding The import Statement The import Selector Clause Automatic Imports
Assertions
Introduction The assert Method The @elidable Annotation
Exceptions
Introduction Throwing Exceptions Catching Exceptions The finally Block
|
|
6 |
| Patterns Matching
Introduction The match Statement Logical Operators Typed Pattern Functional Patterns Matching Case Classes Patterns Matching Case Classes
|
|
7 |
| Scala Hierarchy
The Scala.Any Class The Scala.AnyRef Class The Scala.AnyVal Class The Hierarchy Primitive Type Values The Nothing Type The Nil Object The Null Type The Option Type The None Object The Nothing Class The Some Class The Map Collection
Collection
Introduction The Iterable Trait The Iterator Trait Sequences Lists Sets Maps Range Tuples Options
|
|
8 |
| Lists
Introduction List Literals List of Lists Empty List The List Type List Operations List Transformations List Filtering List Reduce List Folding Simple List Generating
Sets Introduction The ++ Operators The min and max Methods The & Operator The + and - Operators
| |
9 |
| Tuples
Introduction The Tuple Class Different Types Accessing Elements The productIterator Method The swap Method Using Tuples
Maps
Introduction
The += Operator The keys Method The values Method The isEmpty Method The ++ Operatpor Treating Map as Arrauys The contains Method The - Operator The size Methos
| |
10 |
| Ranges
Introduction Jump Start The toList Method
Options
Introduction The None Object The Nothing Type The Some Class Code Samples The getOrElse Method The isEmpty Method
|
|
11 |
| Types Parameterization
Introduction Code Sample Generic Functions Type Bounds Covariance Generic Wild Card
Abstract Members
Introduction Abstract Types Abstract Vals Abstract Vars Abstract Method
Properties
Introduction Object Properties Code Samples
|
|
12 |
| Types Conversions
Introduction Implicit Casting Explicit Casting Structural Types
Annotations
Introduction
The @deprecated Annotation The @throws Annotation The @SerialVersionUID Annotation The @Cloneable Annotation The @Native Annotation The @Serializable Annotation The @Transient Annotation The @Volatile Annotation The @BeanProperty Annotation The @BooleanBeanProperty Annotation The @Uncheck Annotation The @varargs Annotation
Scala & XML
Introducion XLM Serialization XML Generating XML Parsing
|
|
13 |
| Objects Comparisons
Introduction The eq Operator The ne Operator The equals Method Case Classes Comparing Strings Comparing Value Type Values The hashCode Function The == Operator
Java Integration
Introduction
Using Scala from Java
Class Variables
Beans Properties
Using Java from Scala
Traits are Interfaces
Exceptions Handling
Static Members
Closures
Annotations
Varied Number of Arguments
|
|
14 |
| Concurrency
Introduction
The Runnable Trait
The Executors Object
The Future Trait
Synchronization
|
|