Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Subscribe
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Scala: Master Scala Programming: 2-in-1
Rating: 3.9 out of 5(17 ratings)
168 students

Scala: Master Scala Programming: 2-in-1

Become a Scala programming expert.Two complete courses in one comprehensive training program.
Created byPackt Publishing
Last updated 4/2018
English

What you'll learn

  • Master core language principles such as strings, classes, and types to write better Scala code
  • Use concurrency to enhance your Scala coding with the Akka framework
  • Build microservices with Reactive programming
  • Create advanced functionalities in your code using patterns
  • Learn to test your code using the spec2 library
  • Incorporate Functional Programming in your code

Course content

2 sections • 35 lectures • 7h 47m total length

  • The Course Overview2:53

    This video provides an overview of the entire course.

  • Setting Up Ammonite-REPL7:29

    Get set up with ammonite REPL and understand the basics of interacting with Scala there.

    • Download and run ammonite REPL
    • Run basic commands in the REPL
    • Import third-party libraries in the REPL 
  • Getting a Basic Scala Project Set Up on the Command Line16:40

    Set up a basic sbt project with some source files and understand basic sbt commands.

    • Download and run sbt
    • Build and run a simple project with sbt
    • Experiment with some of sbt’s commands 
  • Setting Up Dependencies and Publishing in sbt18:02

    Set up dependencies to third-party libraries and publishing to a repository using sbt.

    • Update build.sbt to reference third-party libraries
    • Build a project that uses those third-party libraries
    • Explore options for publishing a packaged project using sbt 
  • Setting Up a Multi-Module sbt Project16:55

    Set up a project that contains and depends on multiple subprojects with functionality that can be reused.

    • Split a project up until multiple subdirectories
    • Set up interproject dependencies
    • Split build.sbt into builds for each subdirectory 
  • Importing an sbt Project Into IntelliJ IDEA15:27

    Import an existing sbt project from 1.4 into IntelliJ IDEA and interact with it, seeing some of the similarities and differences.

    • Download and set up IntelliJ IDEA for Scala development
    • Import the sbt project from 1.4 into IDEA
    • Explore the various tools that IntelliJ provides for interacting with a project 
  • Scala Philosophy: Everything is an Expression9:43

    Understand what it means for everything to be an expression in the Scala language.

    • Look at val as a data holder
    • Look at how if/else can be used as an expression
    • Look at how functions with side effects and no return are represented 
  • Basic Data Types: Strings and Numbers15:04

    Understand the basic functionality of strings and numbers in Scala and compare to Java.

    • Investigate basic strings and interpolation
    • Explore numbers and math helpers in Scala
    • Compare Scala and Java handling of strings and numbers 
  • Functions and Match Statements8:26

    Understand how to define functions and how match statements interact with function definitions.

    • Define a simple function
    • Explore how arguments, return types, and varargs work
    • Use a match statement inside a function body 
  • Scala Philosophy: Null Allergies and Option9:34

    Understand what it means to avoid null and how the option type allows one to avoid nulls wherever possible.

    • Explore the two forms of the option data type: some and none
    • Use option as an alternative to null
    • Investigate functionality provided for interacting with options easily 
  • Collection Basics15:58

    Explore the basics of collections, including Scala’s idioms for iteration and per-element actions.

    • Use simple iteration with foreach
    • Use map, filter, and find for more complex targeted iteration tasks
    • Pair map with a match statement for advanced idiomatic filtering 
  • Basic for Comprehensions16:27

    Gain an acquaintance with the for comprehension and how it simplifies and streamlines the operations discussed in section 2.5.

    • Understand how flatMap works
    • Look at for as an alternative to map, flatMap, and filter
    • Explore different types and how they interact with for comprehensions 
  • Generic Collection Operations21:30

    Explore the operations that collapse collections into single values of a different type and their variations.

    • Use reduce for simple combining operations
    • Understand foldLeft as a more flexible alternative to reduce
    • Understand foldRight and how it differs from foldLeft 
  • Quick Introduction to Object-Oriented Scala17:06

    Map basic object-oriented concepts to their Scala equivalents/implementations.

    • Create classes with private and public instance variables
    • Explore Scala’s advanced visibility modifiers
    • Understand how to use traits as interfaces and how abstract classes work in Scala 
  • Additional Trait Features18:06

    Understand more complex trait use cases and how they allow for multiple inheritance.

    • Create a multiple inheritance tree with Scala traits
    • Understand how trait linearization works to address multiple inheritance complexities
    • Understand the idiomatic usage of def and val in traits 
  • Singletons13:39

    Explore Scala’s first-class support for singletons and some of their use cases.

    • Create a basic singleton in Scala
    • Create a companion object and understand how it compares to Java statics
    • Use a singleton to define a main entry point for a Scala program 

Requirements

  • You should have working knowledge of Scala

Description

Scala is a powerful multi-purpose programming language with a simple object-oriented, functional style. Scala enables you to deconstruct data in intuitive and readable ways, letting you write safely in a few lines of code what other languages can take tens of buggy lines to get across. This 2-in-1 comprehensive course will help you master various concepts in Scala programming. Save time and trouble by using Scala to build object-oriented, functional, reactive, and concurrent applications.

Contents and Overview

This training program includes 2 complete courses, carefully chosen to give you the most comprehensive training possible.

The first course, Scala Beginner Programming Recipes, shows core language principles covering topics such as strings, classes, types, methods, and arrays. From there, you'll learn about functional programming techniques and how to handle files and processes. You'll go on to master concurrency in Scala by making use of the Akka framework. You'll learn about working with databases, and then about Reactive programming in Scala and how to use it to build robust microservices and distributed systems. You'll also use the Scala REPL to achieve a better feedback mechanism.

The second course, Scala Intermediate Recipes, you’ll get a quick tour into testing will introduce the specs2 library and how to use it to do behavior-driven development in Scala. Then we'll dig into Scala's collections some more; Scala's collections library is vast, and holds many powerful tools for dealing with data. Finally, we'll go through a few tricks that let you get readable and type-safe frameworks in place to describe your domain.

By the end of this training program, you will be well versed with the concepts of Scala and will be able to build highly scalable and distributed, microservice based applications.

About the Authors

Antonio Salazar Cardozo is a developer who has led small teams from his classes at Georgia Tech and

through each company he has contributed to. He is a software pragmatist and perfectionist who values

great software that is written for humans first, and loves to help teams find the development and interaction styles that make them deliver the best software to solve the problems they are solving. Between startups and larger companies, he has worked on most aspects of web and non-web systems, and loves to see how each piece of software is received and how it can improve. When he's not leaving honest, extensive code review, he's been known to travel and enjoys visiting both new and old places far from home.

Who this course is for:

  • Java developers who are comfortable in working with Scala, budding data scientists, and web developers, who want to learn how to overcome various obstacles in their quest to build robust applications in Scala.

Report abuse