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:

1. Write clear and expressive Scala code using both object-oriented and functional programming techniques to build flexible, modern applications.
2. Use traits, mixins, and companion objects to structure code in a way that supports reuse, modularity, and maintainability.
3. Work confidently with functional programming concepts like pure functions, higher-order functions, immutability, and pattern matching in real-world projects.
4. Build functional web applications using the Play Framework and integrate them with databases using Slick for smooth, scalable data access.
5. Create reliable concurrent programs using the Akka framework and Scala’s Futures and Promises to handle messaging and parallel processing.
6. 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. 

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.  

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