Programming with Scala – Foundations and Functional Concepts

Description:

This intensive 3-day training provides a practical and comprehensive introduction to programming with Scala, a powerful, expressive, and type-safe language that runs on the Java Virtual Machine (JVM). Participants will explore Scala’s modern language features including immutability, functional programming, pattern matching, higher-order functions, and collections API, along with object-oriented constructs like traits, case classes, and inheritance.

Through interactive labs and real-world code examples, learners will understand how Scala merges functional and object-oriented paradigms, making it ideal for scalable, concise, and reliable application development. This training is ideal for developers coming from Java or other OOP backgrounds who want to transition into functional or distributed computing environments (e.g., Spark, Akka, Play).

Duration: 3 Days

Course Code: BDT 506

Learning Objectives:

By the end of this course, participants will be able to:

1. Understand Scala’s type system, variable mutability, and control structures.
2. Define and work with functions, higher-order constructs, and anonymous functions.
3. Manipulate collections using map, filter, reduce, fold, and scan operations.
4. Apply pattern matching and immutability principles in real programs.
5. Build object-oriented and functional applications using traits, classes, and case classes

This course is ideal for:

• Java/OO programmers transitioning to Scala or functional programming
• Engineers building Spark applications
• Developers looking for concise, expressive alternatives to Java

• Familiarity with programming basics (Java, Python, or similar)
• Understanding of OOP concepts (e.g., classes, inheritance)

Course Outline:

Module 1: Introduction to Scala

• What is Scala and why Scala?
• Scala vs. Java: Similarities and differences
• Installing Scala and Scala REPL
• Writing your first Scala program

Module 2: Variables and Type System

• Mutable vs. Immutable variables (val vs var)
• Type inference and explicit typing
• Unified type hierarchy: Any, AnyVal, AnyRef, Unit, Nothing, Null
• Handling emptiness and null safety

Module 3: Expressions and Control Flow

• Expressions vs. Statements
• Nested scopes, expression blocks
• If/Else as expressions
• match expressions and pattern guards
• Using match with pattern variables and downcasting

Module 4: Loops and Iteration Constructs

• for loops as expressions
• for with iterators and pattern guards
• while / do-while as pure statements

Module 5: Working with Functions

• First-class functions vs. methods
• Declaring and calling functions
• Functions as values, default parameters, named arguments
• Tuples as parameters, varargs, parametric polymorphism
• Nested functions and procedures
• Functions with no inputs

Module 6: Higher-Order Functions

• Defining higher-order functions
• Anonymous functions (function literals)
• Placeholder syntax
• Partially applied functions

Module 7: Collections and Functional Programming

• Tuples and List creation
• Map, filter, foreach, and basic list operations
• Mutable vs. immutable collections
• Arrays, Sets, and Maps (mutable and immutable)
• Option types and Try for safe error handling

Module 8: Functional Patterns with Collections

• Using map, flatMap, filter, foreach
• fold, reduce, scan variations
• Choosing between left/right variants
• Combining higher-order methods in workflows

Module 9: Classes and Constructors

• Defining classes in Scala
• Primary vs. auxiliary constructors
• Fields, access modifiers, default parameters
• Inheritance and method overriding
• Lazy values and apply methods

Module 10: Traits and Case Classes

• Traits and mixing behaviors
• Abstract classes vs. traits
• Singleton and companion objects
• Operator overloading in Scala
• Case classes and pattern matching
• Self-types and advanced trait patterns

Module 11: Integrating Concepts – Mini Project

• Build a functional + OO Scala app
• Use match, map, flatMap, and collections
• Combine case classes, higher-order functions, and trait-based design

Training Material Provided:

Course slides and reference guides