Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Subscribe
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Navigating Mars Using TypeScript and Functional Programming!
Rating: 5.0 out of 5(3 ratings)
15 students

Navigating Mars Using TypeScript and Functional Programming!

Let's learn about immutability, functions, and composition while solving the Mars Rover kata in TypeScript.
Created byCameron Presley
Last updated 11/2024
English

What you'll learn

  • How to identify domain models from a problem statement
  • How to build types that make sense using primitive, sum, and product types
  • How to use immutability to remove complexity from your code
  • How to create easily testable functions using purity
  • How to create bigger functions by re-using other functions through composition
  • How to maintain and update state when using immutable types

Course content

5 sections • 19 lectures • 3h 0m total length

  • Intro to the course4:27

    In this lecture, I'll show you the main concepts behind functional programming, why it matters and what skills you should already have in order to take this course.

  • What we'll be building3:04
  • Prerequisites for setting up your environment0:10
  • Setting up your environment7:36

Requirements

  • Basic experience with Node and TypeScript (installing packages, running scripts)

Description

Over the past five years, functional programming paradigms have entered the development mainstream. Whether its Elm that introduced the Model View Update pattern which inspired React's Redux and  Angular's ngrx architecture or Haskell that introduced us to Maybe and Either which influenced Rust, functional concepts are becoming more common.


However, in order to understand these advanced concepts, you need a solid foundation to build upon which is what we'll be tackling in this course. By tackling the Mars Rover kata, you'll get hands-experience with the three core concepts of functional programming.


  1. Immutability - Removing complexity by reducing where data can change

  2. Functions - Removing complexity by reducing what functions can do, ensuring that they're easier to understand

  3. Composition - Building new functions by composing existing functions

By learning immutability, you learn how to arrange your code so that you don't have to track as much state in your application, reducing your troubleshooting time.

By learning what functions are, you'll learn how to spot pure functions (e.g., those that are easy to test/troubleshoot) and how to minimize the amount of business rules in the impure functions (e.g., those that are hard to test)

With these two concepts in hand, you'll learn how you can take existing functions and combine them into new functions, gaining re-usability.


If you're interested in functional programming but not sure where to start, then this course is for you!

Who this course is for:

  • Beginner to intermediate developers who have some experience with TypeScript, but want to learn more about functional programming

Report abuse