A Practical Guide to App Development with Scala

Name: A Practical Guide to App Development with Scala
Rating: 3.7 (46 reviews)

Build Scala apps using concurrency and message passing in an Akka framework using Play framework for web developments

Created byPackt Publishing

Last updated 6/2019

English

What you'll learn

Explore OOP concepts for Scala programming.
See how functional programming changes your Scala code.
Build microservices with Reactive programming.
Perform database operation using a Slick-JDBC connection with Play.
Implement features of Akka such as futures, await, timeouts, and ask patterns.
Design and develop an Akka adaptation of the famous 'dining-philosophers' problem.
Master the type system to create scalable type-safe applications while cutting down your time spent debugging.
Understand how you can work with advanced data structures via built-in features such as the Collections library.
Use classes, objects, and traits to transform a trivial chatbot program into a useful assistant.

Course content

2 sections • 42 lectures • 6h 8m 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

The Course Overview3:51
This video provides an overview of the entire course.
Define Controller4:04
In this video, we will start with introducing Play Framework, the play-scala-seed library, and a quick implementation of controller.
Introduce play-framework/play-scala-seed
Add the controller methods
Add Custom Routes2:38
In this video, we will learn different ways/patterns of routes and add custom routes for application implementation.
Explain the routes
Add custom routes
Run the application to showcase successful compilation
Design the Model for Product Catalogue2:33
In this video, we will define models as required for the product listing application.
Explain the concepts of domain modeling
Define the model as per the product schema
Create Views/Templates4:51
In this video, we will learn to create templates/views using HTML with Scala syntax.
Explain the template engine being used
Describe views
Integrate Controllers, Models, and Views6:36
This video will conclude the application implementation with integration of custom model(s), view, and controller.
Complete the implementation and integrate all three components
Run the application to showcase the final implementation
Adding Controllers with Custom Routes4:13
In this video, we will learn about post methods handling in a controller and how routes can be defined to handle post requests.
Implement controller methods for post requests
Add routes for controller navigation
Designing Models for Customers’ Data4:05
In this video, we will describe customer data in terms of models, which can be stored in the database.
Design models for customer data
Creating Form-Based Views and Templates6:39
In this video, we will implement form-based views using Scala and HTML to record input data from a customer/user.
Discuss form templates
Implement views to accept customer data
Configuring Slick- JDBC Connection9:52
In this video, we will learn to establish a Slick-JDBC connection to write or read from a database.
Discuss Slick-JDBC
Write connection properties
Understand queries/APIs to write or read from the database
Integrate Controllers, Models, and Views with Database7:45
This video concludes the application implementation with integration of controller, models, and views, with the input data stored in database.
Complete the implementation and integrate all three components.
Run the application. Input customer data in form-based views.
Check the data that is being stored in the database.
Defining String Processing and Word Counter Actors4:26
In this video, we will learn to set up our Akka application, and add the actor model for our string processing application.
Set up the actor-based Akka application framework
Define string processing and word counter actors
Designing String Processing Messages3:09
In this video, we will learn about string processing messages to establish communication between actors.
Add case class representation for string processing messages
Adding Receive Methods in a String Processing Actor3:23
In this video, we will add further implementation with the string processing actor to handle any received messages.
Discuss the receive method needed within actors
Customize the receive method implementation for processing the messages received by the actor
Implementing Receive Methods in Word Counter Actors6:34
In this video, we will add implementation to process strings and provide word count based on the message received by the word-counter actor.
Discuss messaging architecture with respect to string processing application
Add implementation to trigger string processing
Add implementation to provide word count when the required message is received
Using Await, Futures, Timeout, and Ask Pattern to Complete the Application6:39
We will conclude the application implementation with the showcasing of the running actor system and the messages being passed between actors in runtime.
Add a RunExample object to provide a runnable application
Use await, futures, timeout, and ask pattern to establish interaction between actors
Run the application and discuss message logging in runtime
Preparing the build.sbt File3:33
In this video, we will learn to set up our Akka application in IntelliJ IDE, and add the akka-actor dependency for our application.
Set up a scala-sbt project
Configure dependencies in build.sbt
Defining Ping Actor and Pong Actor2:47
In this video, we learn to add ping and pong actors with empty receive methods implementation.
Add ping and pong actors
Designing Messages4:54
In this video, we will talk about actor system messages to establish communication between actors.
Add case objects representation for ping pong messages
Discuss the actor system hierarchy
Updating the Ping Actor to Define a Receive Method5:37
In this video, we will add further implementation to the ping actor.
Discuss context within the actor system
Add an implementation to respond to messages received within the ping actor
Add methods to customize the implementation
Creating Methods to Receive Messages in the Pong Actor6:45
Conclude the application implementation with the showcasing of the running actor system and the messages being passed between actors in runtime.
Add an implementation within the pong actor
Create a PingPongTest object to provide a runner for the app
Run the application and discuss message logging in runtime
Model Each Philosopher as an Actor4:29
In this video, we will learn about the famous dining philosophers’ problem and, based on that, model each philosopher as an actor.
Understand the problem
Describe the need for a solution to the concurrency issue
Model the philosopher(s) as actor(s) in the Akka-based solution
Defining Methods for a Philosopher’s Behaviour9:05
This video will provide details about the different states/behaviour(s) of each philosopher actor.
Describe the states/behaviour of the philosophers
Model each behavior as a receive type method
Start Eating and Thinking Cycle Using Message Passing Pattern6:14
In this video, we will add actor system messages to reflect on the eating and thinking cycle of the philosopher(s).
Add `thinking` as a state
Add `eating` as another state
Define `Become` to Alternate Each Philosopher Actor between States9:12
This video includes a discussion on state transition diagram and how the “become” construct helps to alternate between different states.
Introduce state transition diagram
Based on the transition needed, add “become” within the philosopher actor behavior(s)
Further add implementation for “startThinking” as the initial state
Modelling Contention for Available Forks11:45
In this video, we will model the contention for available forks and run the application showcase concurrency.
Add states within the `fork` actor as a receive type
Add the runner class/object and then trigger the actor system
Walk through the application logs to explain state transition and no-starvation/non-blocking cycle of eating-thinking
Test Your Knowledge

Requirements

No prior knowledge of Scala programming is required for this course.

Description

Are you willing to build real-world Scala applications & contribute to Scala programs, recognizing common patterns and techniques used with the language? Then this course is for you! Scala is a functional programming language that supports OOP principles and it’s quite challenging to develop scalable and reactive applications without any framework/library support.

With this practical & hands-on course, you will begin learning basic of scala such as strings, classes, types, methods, & arrays, functional programming techniques & how to handle files and processes—before getting into concepts such as Object-Oriented Programming. Once you are comfortable with basics you will learn to build real-world applications such as building a customer data entry application, a string processing application to get a word count & much more. Then you will also learn Scala REPL to achieve a better feedback mechanism.

By the end of the course, you will not only be empowered by knowing the ins and outs of Scala, but you will also be able to apply them to solve a variety of problems.

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 starts with recipes that explore core language principles—covering topics such as strings, classes, types, methods, and arrays—before getting into concepts such as Object Oriented Programming. 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, 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 Projects you will learn various features of the Play and Akka frameworks by building 5 real-world applications with increasing complexity. Beginning with a simple project, a product catalog-listing application, the course will take you through building a customer data entry application, a string processing application to get a word count, a message passing app like Ping pong actors example and Dining-philosophers problem-in humus. Each project will help you master the programming and data capabilities of Scala. By the end of the course, you will not only be empowered by knowing the ins and outs of Scala, but you will also be able to apply them to solve a variety of problems.

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.
Kapil Sanghvi is a postgraduate with an MSc in Business Information Technology from Middlesex University, London. He has worked on Java and Scala projects with different multinational organizations for the last, years in India and UK. His passion is to learn new things and share his expertise with the programming community out there. Currently, he works as a Scala Developer in a UK-based organization developing an in-house product.

Who this course is for:

This course targets 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.

A Practical Guide to App Development with Scala

What you'll learn

Explore related topics

Course content

Scala Beginner Programming Recipes16 lectures • 3hr 43min

Scala Projects26 lectures • 2hr 26min

Requirements

Description

Who this course is for: