TTSCL2104: Fast Track to Scala Programming Essentials for OO / Java Developers
About this Course
Scala is a modern programming language known for its power, flexibility, and ability to support both object-oriented and functional styles of development. It is used by companies building everything from high-performance backend systems to data-intensive applications, and it is gaining traction in machine learning and AI workflows due to its strong type system, expressiveness, and integration with tools like Apache Spark. If you are looking to build reliable, scalable software or expand your programming toolkit with skills that apply to real-world systems, Scala is a smart choice.
This expert-led course is designed for developers, engineers, and technical professionals who have some basic experience with OO languages, such as Java, and want to build practical Scala skills they can use right away. You will get hands-on with key concepts like higher-order functions, pattern matching, traits, mixins, for-comprehensions, and persistent data structures. You will apply what you learn by building projects such as functional web applications using the Play Framework, database-connected systems using Slick, and modular software using dependency injection and type classes. Each concept is introduced through clear explanations followed by hands-on labs, making sure you can use these skills in your own work.
Throughout the course, you will also practice building reliable, concurrent applications using Akka and Scala Futures, and strengthen your code quality with testing strategies like property-based testing and test-driven development. You will even explore how generative AI tools like GPT can be integrated into your Scala programs to create smarter, more dynamic applications. About fifty percent of your time will be spent working through hands-on exercises, giving you the chance to explore ideas, get feedback, and leave the class ready to apply everything you learned.
Audience Profile
This course is geared for experienced skilled Java developers, software developers, data scientists, machine learning experts or others who wish to transtion their coding skills to Scala, learning how to code in Scala and apply it in a practical way. This is not a basic class.
At Course Completion
The goal of this course is to help you build real, job-ready Scala skills by giving you plenty of chances to learn by doing. Through expert guidance and hands-on projects, you will gain practical experience that you can carry into your own work right away. By the end of the course, you will be able to:
Write clear and expressive Scala code using both object-oriented and functional programming techniques to build flexible, modern applications.
Use traits, mixins, and companion objects to structure code in a way that supports reuse, modularity, and maintainability.
Work confidently with functional programming concepts like pure functions, higher-order functions, immutability, and pattern matching in real-world projects.
Build functional web applications using the Play Framework and integrate them with databases using Slick for smooth, scalable data access.
Create reliable concurrent programs using the Akka framework and Scala’s Futures and Promises to handle messaging and parallel processing.
Apply modern testing strategies such as unit testing and property-based testing using ScalaTest and ScalaCheck to write safer, more dependable code.
If your team requires different topics, additional skills or a custom approach, our team will collaborate with you to adjust the course to focus on your specific learning objectives and goals.
Outline
Please note that this list of topics is based on our standard course offering, evolved from typical industry uses and trends. We'll work with you to tune this course and level of coverage to target the skills you need most. Topics, agenda and labs are subject to change, and may adjust during live delivery based on audience skill level, interests and participation.
Introduction to Scala
Scala features and benefits
Comparing Scala with Java and other OO languages
Installing Scala and setting up the development environment
Lab: Setting up Scala Environment & Exploring Basic Features; create a simple Scala project.
Object-Oriented Programming in Scala
Classes and objects
Traits, mixins, and inheritance
Companion objects and factories
Encapsulation and polymorphism
Lab: Building a Simple OOP Application in Scala
Functional Programming Basics
Pure functions and referential transparency
Higher-order functions and currying
Immutability and persistent data structures
Pattern matching and recursion
Lab: Implementing Functional Programming Concepts in Scala: Develop a small application that uses functional programming concepts such as higher-order functions and pattern matching.
Having Fun with Functional Data Structures
Lists, sets, and maps in Scala
Folding and reducing operations
Stream processing and lazy evaluation
For-comprehensions
Lab: Create an application that uses Scala's functional data structures and common operations like map, filter, and reduce.
Building Web Applications in Functional Style
Introduction to Play Framework
Functional web routing and request handling
JSON handling with Play-JSON
Middleware and functional composition
Lab: Developing a Functional Web Application with Play
Connecting to a Database
Introduction to Slick library
Database configuration and setup
Querying and updating with Slick
Transactions and error handling
Lab: Integrating a Database with a Scala Application
Building Scalable and Extensible Components
Modular architecture and design patterns
Dependency injection with MacWire
Type classes and type-level programming
Implicit parameters and conversions
Lab: Develop a modular and scalable Scala application using dependency injection, type classes, and other design patterns.
Concurrency Programming & Akka
Introduction to Akka framework and Actor model
Actor systems and message passing
Futures and Promises
Supervision and fault tolerance Lab: Create a concurrent application using the Akka framework, Actor model, and Scala's Futures and Promises.
Building Confidence with Testing
Introduction to ScalaTest and ScalaCheck
Unit testing and property-based testing
Test-driven development in Scala
Mocking and integration testing
Lab: Write unit tests and property-based tests for a Scala application using ScalaTest and ScalaCheck.
Interoperability between Scala and Java
Calling Java code from Scala
Using Java libraries in Scala projects
Converting Java collections to Scala collections
Writing Scala code that can be called from Java
Lab: Integrating Java and Scala in a Project
Using Generative AI and GPT Technologies in Scala Programming
Overview of GPT and generative AI
Integrating GPT with Scala applications
Use cases and practical examples
Lab: Implementing a GPT-Integrated Scala Application
Prerequisites
In order to be successful in this course you should possess:
Familiarity with object-oriented programming concepts: Attendees should have a basic understanding of object-oriented programming principles, such as inheritance, encapsulation, and polymorphism, as the course builds upon these concepts while introducing Scala and functional programming.
Experience in at least one programming language: Participants should have experience working with at least one programming language (preferably Java) to ensure they can grasp Scala's syntax and features more quickly.
Basic understanding of data structures and algorithms: Participants should have a foundational knowledge of data structures (e.g., arrays, lists, and trees) and algorithms (e.g., searching and sorting) to better comprehend Scala's functional data structures and programming techniques.