Scala Advanced Part 3 Functional Programming Performance

Scala Advanced Part 3 Functional Programming Performance

What you’ll learn

Advanced Functional Programming, Tail Calls, Trampolines, Functors, Monads, Applicative Functors, Different Monad Patterns
Macros, Scala Compiler Phases, Abstract Syntax Trees, Quasiquotes, When and how to use macros
Parser Combinators, External DSLs, Grammar Translation, Transformers, Parsing, Packrat Parsers
Performance Optimization, JVM Performance Tricks, Profiling, Visual VM

Requirements

You should be a developer with day to day working experience of Scala
It is recommended that you complete Parts 1 and 2 of the Escalate Scala Advanced course
You may also wish to consider following parts 1-3 of the Escalate Applied Scala course if you have trouble following these concepts
You will need a sufficiently powerful computer and to follow the included setup instructions to run the hands-on exercises

Description

The Escalate Software Scala Advanced course is intended for experienced Scala developers looking to improve their skills, particularly for library and API design and development. It covers topics needed to be effective in producing high quality, correct, powerful and flexible Scala libraries that are still easy to use by others.This course assumes you have day-to-day Scala development skills equivalent to having taken the Scala Advanced course parts  1  and 2 from Escalate Software. If you have trouble understanding or following the concepts in this course because some of the concepts being presented are assuming something you are unfamiliar with, then we would recommend you check out the Applied courses as these will answer many of your questions.Part 3 covers advanced functional programming concepts and patterns, use of Macros, how to write external DSLs with the parser-combinator library, and how to effectively optimize code by analyzing performance:Functional Programming Building Blocks: ADTs, trampolines, recursion, functionsFunctional Programming Patterns: Functors, Monads, Applicative FunctorsCommon Functional Patterns: IO, Reader, Writer, State, FreeMacros and QuasiquotesExternal DSLs and Scala’s Parser-Combinator LibraryProfiling and OptimizationCode Performance ConsiderationsIt is recommended that you complete Scala Advanced parts 1 and 2 before taking this part. While not strictly necessary, we may assume knowledge from parts 1 and 2 in some of the explanations that could be hard to follow unless you know the material.This is the final part of the Advanced Scala course. We hope you enjoyed the course and that the material proves useful.

Overview

Section 1: Setup Instructions

Lecture 1 Introduction

Section 2: Module 12 – FP part 1, Tail Calls, Trampolines, ADTs

Lecture 2 Module 12 – 01 – Introduction

Lecture 3 Module 12 – 02 – Agenda

Lecture 4 Module 12 – 03 – Recursion vs Loops

Lecture 5 Module 12 – 04 – Recursive Factorial

Lecture 6 Module 12 – 05 – Tail Recursive Factorial

Lecture 7 Module 12 – 06 – Puzzler – Fibonacci

Lecture 8 Module 12 – 07 – Mutual Calling Functions

Lecture 9 Module 12 – 08 – Recursive Even/Odd

Lecture 10 Module 12 – 09 – ADTs Recap

Lecture 11 Module 12 – 10 – First Trampoline

Lecture 12 Module 12 – 11 – Even/Odd Trampoline

Lecture 13 Module 12 – 12 – Using Trampolines

Lecture 14 Module 12 – 13 – Scala TailCalls

Lecture 15 Module 12 – 14 – Higher Order Functions Recap

Section 3: Module 13 – Functors, Monads, Applicative Functors

Lecture 16 Module 13 – 01 – Introduction

Lecture 17 Module 13 – 02 – Agenda

Lecture 18 Module 13 – 03 – Options Recap

Lecture 19 Module 13 – 04 – Implementing Option

Lecture 20 Module 13 – 05 – A Functor

Lecture 21 Module 13 – 06 – A Monad

Lecture 22 Module 13 – 07 – Optional In Use

Lecture 23 Module 13 – 08 – Guards, withFilter

Lecture 24 Module 13 – 09 – Testing the Guard

Lecture 25 Module 13 – 10 – Functor Laws

Lecture 26 Module 13 – 11 – Monad Laws

Lecture 27 Module 13 – 12 – Applicative Functors

Lecture 28 Module 13 – 13 – Applicative Functors with Functions

Lecture 29 Module 13 – 14 – Cartesian Syntax and Alternatives

Lecture 30 Module 13 – 15 – Functor/Monad Patterns

Lecture 31 Module 13 – 16 – IO

Lecture 32 Module 13 – 17 – Composing IO

Lecture 33 Module 13 – 18 – Reader

Lecture 34 Module 13 – 19 – Writer

Lecture 35 Module 13 – 20 – State

Lecture 36 Module 13 – 21 – Free

Lecture 37 Module 13 – 22 – Free ADT

Lecture 38 Module 13 – 23 – Free Composition

Lecture 39 Module 13 – 24 – Free – A Full Program

Lecture 40 Module 13 – 25 – Free, the Interpreter

Lecture 41 Module 13 – 26 – Running Free

Section 4: Module 14 – Macros

Lecture 42 Module 14 – 01 – Introduction

Lecture 43 Module 14 – 02 – Agenda

Lecture 44 Module 14 – 03 – First Rule of Macros

Lecture 45 Module 14 – 04 – Scala Compiler Phases

Lecture 46 Module 14 – 05 – Abstract Syntax Trees

Lecture 47 Module 14 – 06 – Macro Overview

Lecture 48 Module 14 – 07 – A Demo Macro

Lecture 49 Module 14 – 08 – Setting Up the Pieces

Lecture 50 Module 14 – 09 – A Macro That Does Nothing

Lecture 51 Module 14 – 10 – Macro With Generic Type Parameters

Lecture 52 Module 14 – 11 – Quasiquotes

Lecture 53 Module 14 – 12 – Doing More with Quasiquotes

Lecture 54 Module 14 – 13 – A Function Describing Macro

Lecture 55 Module 14 – 14 – Narrowing the Return Type

Lecture 56 Module 14 – 15 – Compiler Warnings and Errors

Lecture 57 Module 14 – 16 – Creating a Compiler Warning

Lecture 58 Module 14 – 17 – Macro Limitations

Lecture 59 Module 14 – 18 – Final Words

Section 5: Module 15 – Parser Combinators

Lecture 60 Module 15 – 01 – Introduction

Lecture 61 Module 15 – 02 – Agenda

Lecture 62 Module 15 – 03 – External DSLs

Lecture 63 Module 15 – 04 – A Basic Grammar

Lecture 64 Module 15 – 05 – Simple Parser Combinators

Lecture 65 Module 15 – 06 – Token Parsers

Lecture 66 Module 15 – 07 – Types and Transformers

Lecture 67 Module 15 – 08 – Richer Types

Lecture 68 Module 15 – 09 – StatementLine ADT

Lecture 69 Module 15 – 10 – Next and Goto

Lecture 70 Module 15 – 11 – BNF Translation

Lecture 71 Module 15 – 12 – The Print Statement

Lecture 72 Module 15 – 13 – The For Statement

Lecture 73 Module 15 – 14 – Complete Line, and Parsing

Lecture 74 Module 15 – 15 – Trying It Out

Lecture 75 Module 15 – 16 – Packrat Parsers

Section 6: Module 16 – Performance and Optimization

Lecture 76 Module 16 – 01 – Introduction

Lecture 77 Module 16 – 02 – Agenda

Lecture 78 Module 16 – 03 – When and Where to Optimize

Lecture 79 Module 16 – 04 – First Things First

Lecture 80 Module 16 – 05 – Collections

Lecture 81 Module 16 – 06 – Vector vs List

Lecture 82 Module 16 – 07 – List Head vs Tail Operations

Lecture 83 Module 16 – 08 – Arrays

Lecture 84 Module 16 – 09 – Register Based Arithmetic

Lecture 85 Module 16 – 10 – Timing Runs

Lecture 86 Module 16 – 11 – Bitwise Operations

Lecture 87 Module 16 – 12 – While Loops and Tail Calls

Lecture 88 Module 16 – 13 – While vs TailRec

Lecture 89 Module 16 – 14 – Library Calls

Lecture 90 Module 16 – 15 – sqrt, Trancendentals

Lecture 91 Module 16 – 16 – Other Performance Gotchas

Lecture 92 Module 16 – 17 – Find the Hot Spots

Lecture 93 Module 16 – 18 – VisualVM

Lecture 94 Module 16 – 19 – Using VisualVM

Lecture 95 Module 16 – 20 – Profiling Demo

Lecture 96 Module 16 – 21 – Caching

Scala developers looking to improve their skills, write libraries and APIs for others,Developers wanting to improve their knowledge of more advanced functional programming concepts,Developers wishing to learn how to save time and money by profiling and optimizing applications,Anyone who wants to be able to parse and use external DSLs in Scala

Course Information:

Udemy | English | 4h 54m | 1.72 GB
Created by: Dick Wall

You Can See More Courses in the Developer >> Greetings from CourseDown.com