Effective Programming in Scala

  • 4.8
Approx. 49 hours to complete

Course Summary

Effective Scala is a course designed to sharpen your Scala skills and improve your code quality. This course will teach you how to write Scala code that is concise, expressive, and performant.

Key Learning Points

  • Learn how to write concise and expressive Scala code
  • Improve your code quality through best practices and techniques
  • Gain insight into advanced Scala concepts like implicits and type classes

Job Positions & Salaries of people who have taken this course might have

    • USA: $100,000 - $150,000
    • India: INR 12-15 LPA
    • Spain: €35,000 - €55,000
    • USA: $100,000 - $150,000
    • India: INR 12-15 LPA
    • Spain: €35,000 - €55,000

    • USA: $90,000 - $140,000
    • India: INR 8-13 LPA
    • Spain: €30,000 - €50,000
    • USA: $100,000 - $150,000
    • India: INR 12-15 LPA
    • Spain: €35,000 - €55,000

    • USA: $90,000 - $140,000
    • India: INR 8-13 LPA
    • Spain: €30,000 - €50,000

    • USA: $80,000 - $120,000
    • India: INR 6-10 LPA
    • Spain: €25,000 - €40,000

Related Topics for further study


Learning Outcomes

  • Write concise and expressive Scala code
  • Apply best practices to improve code quality
  • Understand and apply advanced Scala concepts

Prerequisites or good to have knowledge before taking this course

  • Basic knowledge of Scala syntax and functional programming concepts
  • Access to a computer with an internet connection

Course Difficulty Level

Intermediate

Course Format

  • Online Course
  • Self-paced
  • Video Lectures
  • Hands-on Exercises

Similar Courses

  • Scala Fundamentals
  • Applied Scala
  • Functional Programming Principles in Scala

Related Education Paths


Related Books

Description

Scala is an expressive, versatile, and safe programming language.

Knowledge

  • Leverage Scala idioms to model business domains and implement business logic
  • Fundamental concepts of the language, allowing you to read and understand Scala codebases
  • Best practices and common patterns used in the real world
  • Be comfortable working with asynchronous computations, handling failures, and manipulating recursive data structures

Outline

  • Getting Started, Basics, Domain Modeling
  • Introduction
  • Elements of Programs
  • Types
  • Methods and Parameters
  • Conditions
  • Evaluating Definitions
  • Domain Modeling
  • Case Classes
  • Sealed Traits
  • Enumerations
  • Business Logic
  • Working on Assignments
  • Tools Setup (Please Read)
  • Getting Started with Scala
  • Types
  • Methods and Parameters
  • Conditions
  • Case Classes
  • Sealed Traits
  • Domain Modeling
  • Standard Library, Loops
  • First Steps With Lists
  • Functions
  • More Operations on Lists
  • Introducing Collections
  • Constructing Collections
  • Querying Collections
  • Transforming Collections
  • Sequences and Maps
  • Option
  • Introducing Loops
  • More Loop Examples
  • Tail Recursion
  • “for” Syntax
  • Collections Extra
  • Functions
  • More Operations on Lists
  • Constructing Collections
  • Querying Collections
  • Transforming Collections
  • Collections
  • Option
  • Loops
  • “for” Syntax
  • Build Tools, Modules
  • Organize Code
  • Build Tools
  • Introduction to the sbt Build Tool
  • sbt, Keys, and Scopes
  • Program Entry Point
  • Encapsulation
  • Extending and Refining Classes
  • Case Classes vs Simple Classes
  • Opaque Types
  • Extension Methods
  • Organize Code
  • Program Entry Point
  • Encapsulation
  • Extending and Refining Classes
  • Case Classes vs Simple Classes
  • Opaque Types
  • Extension Methods
  • Reasoning About Code
  • Reasoning About Code
  • Refactoring-Proof Programs
  • A Case for Side-Effects
  • Mutable Objects
  • Unit Testing
  • Property-Based Testing
  • Mocking
  • Integration Testing
  • Testing the Tests
  • Debugging Programs
  • Refactoring-Proof Programs
  • Unit Testing
  • Property-Based Testing
  • Testing
  • Type-Directed Programming
  • Motivation
  • Context Parameters
  • Given Definitions
  • Priorities Between Given Definitions
  • Type Classes
  • Conditional Given Definitions
  • Type Classes and Extension Methods
  • Implicit Conversions
  • Type-Directed Programming in Scala 2
  • Context Parameters
  • Given Definitions
  • Priorities Between Given Definitions
  • Conditional Given Definitions
  • Implicit Conversions
  • Error Handling, Concurrent Programming
  • Error Handling
  • Error Handling with Try
  • Manipulating Try Values
  • Validating Data
  • Manipulating Validated Values
  • Combining Try and Either
  • Concurrent Programming
  • Operations on Type Future
  • Examples with Future
  • Execution Context
  • Exceptions
  • Try and Either
  • Futures

Summary of User Reviews

Key Aspect Users Liked About This Course

The course is well-structured and easy to understand.

Pros from User Reviews

  • The course content is well-organized and covers a wide range of topics.
  • The instructors are knowledgeable and provide clear explanations.
  • The assignments and quizzes are challenging but helpful in reinforcing the concepts.
  • The course is suitable for both beginners and experienced Scala developers.
  • The course provides real-world examples and scenarios to apply the concepts learned.

Cons from User Reviews

  • Some users found the pace of the course too fast and difficult to keep up with.
  • Some users felt that the course material was too basic and not in-depth enough.
  • Some users experienced technical issues with the platform and course materials.
  • Some users would have preferred more interactive elements such as live sessions or forums.
  • Some users found the language used in the course to be too technical and difficult to understand.
English
Available now
Approx. 49 hours to complete
Julien Richard-Foy, Noel Welsh
École Polytechnique Fédérale de Lausanne
Coursera

Instructor

Julien Richard-Foy

  • 4.8 Raiting
Share
Saved Course list
Cancel
Get Course Update
Computer Courses