Building Declarative Apps using Functional Javascript
0.0 (0 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
4 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Building Declarative Apps using Functional Javascript to your Wishlist.

Add to Wishlist

Building Declarative Apps using Functional Javascript

In-depth guide for developers wishing to create powerful web apps using functional JavaScript
0.0 (0 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
4 students enrolled
Created by Packt Publishing
Last updated 7/2017
Curiosity Sale
Current price: $10 Original price: $125 Discount: 92% off
30-Day Money-Back Guarantee
  • 4.5 hours on-demand video
  • 1 Supplemental Resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Compose functional JavaScript
  • Explore Ramda JS
  • Isolate impurities and work with I/O in a functional way
  • Understand how basic functional programming concepts are woven into rich declarative JavaScript
  • Build a web app with JSX and Virtual-DOM
View Curriculum
  • Developers should have a GitHub account. An understanding of basic JSX is beneficial

Declarative Webapps with Functional JavaScript teaches intermediate functional programmers the skills to write JavaScript apps with FP by building and connecting various components of a front-end webapp.

Completion of this course should be your next step after learning the basics of functional programming. In a few hours you’ll learn what many functional programming articles and tutorials fail to capture; how should one begin to connect all these FP concepts into an application?

You will learn how to create compositions of functional code, handle impurities and I/O, along with how to understand that funky syntax found in so many functional programming articles and documentation.

About the Author :

Michael Rosata has been a professional Javascript Developer for 4 years now, he started building web pages. He started building web pages, widges and then Web Apps. He has worked on a couple of large webapps using Javascript as well as Apache cordova. He loves the javascript ecosystem and the web community and adopted Functional Programming as his passion. He is the founder of MA Web Dev Meetup group and they are currently building a web app for non profits.

Who is the target audience?
  • This course was designed for intermediate JavaScript developers who have recently begun their journey into functional programming. It expects that you understand what a pure function is, how to curry functions and use higher-order function maps, filter, and reduce.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
16 Lectures
Composition Pipelines
5 Lectures 01:07:53

This video provides an overview of the entire course.

Preview 04:09

When we call other functions inside pure functions, the pure function becomes dependent on those other functions. Compose can create new functions by passing the results from applying one function into another function implicitly, decoupling this logic from inside the function bodies.

Connecting Functions with Basic Composition

The compose we’ve used is dependent on taking a specific number of functions as input. We’ll often need to refactor compositions by adding or removing functions, so we’d be better with a compose utility that could create compositions that use any number of functions we happen to pass into it.

Implementing N-length Composition with Reduce

Composition creates functions without points, meaning no explicitly written parameters or returned values. This obfuscates the type of data a function expects from the programmer. A proven type system could help us document function types and give inference to their correctness when combined within compositions.

Formalizing Types with Hilney-Milner

At the root of functional programming is well proven math. Composition isn’t a creation; it’s a discovery. The benefits of functional programming come from understanding that our programs are going to operate predictably, that they will run properly. These laws will help us to continue growing the complexity of our web app.

Refactoring Using Laws of Compositionality
Combinators, What and Why?
4 Lectures 01:17:13

We’ve learned about pure functions and why they are so valuable in functional programming. Now, we’ll look at a type of pure function called a combinators. Combinators encapsulate common patterns, allowing us to perform much more complex and interesting operations inside compositions by combining logic.

Preview 14:53

Composition is great, but it makes it difficult to debug functions properly because we’re not explicitly writing functions for each composition. Console logging inside a function might cast too wide a net and using console.log directly would break the compositions output.

Tap to Inspect Composition

Composition is fairly linear; the input goes in one function and then out into the next. This makes it difficult to do meaningful operations in a point-free way because, eventually, values from multiple operations will need to be merged.

Non-linear Composition Using Join Combinators

We don’t yet have any way to deal with unknown or unexpected values within a composition. Once a value is passed into a composition, it will be beneficial to be able to determine the next function to apply on the fly

Using Combinators with Partially Applied Higher-order Functions
Generic Containers for Isolating Impure Logic
3 Lectures 46:59

Impure actions are not important to the pure functions that process their information. All that is important from impure actions are the end results. We’ll create containers that keep impurities in a box, run them in a box, and give us back only the results.

Preview 12:33

The generic container that we created has a special quality to it, we give it a function to hold and that code doesn’t run immediately. This behavior is like a lazy promise. We have control over when it runs, saving resources delaying work until it needs to be done.

Lazy Evaluation Using Generic Containers

Now that we’re able to hide away our impurities and still work with the results, we’ll load slides for a presentation into our webapp using a containerized API, sort them with pure functions in a composition, and then display the slides using the JSX Virtual DOM suite built in Volume One.

Connecting Impure Code to Pure Composition
Building State Management Inside Your Functional App
4 Lectures 01:16:10

State is a critical part of our applications. Over the history of the Web, sites have evolved into complex applications, but only recently have most of us come to understand why state in a web app would benefit from patterns such as Flux or Redux. These patterns make state predictable.

Preview 15:10

We’ve discussed the various troubles that working with state can bring. We even discussed the benefits to working with a single object data store. Now we’ll create a data store like Redux

Build a Functional Data Store Like Redux

Debugging applications can be tricky. Functional programming teaches us that pure/deterministic code shouldn’t have funky, hard to track bugs, but how can we easily track bugs that occur at different points in time, over changes to our apps state?

Create a History of Changed State to Rewind/Fast-forward The App

Now that we can use the Redux-ish store in our app, it’s time that we allow the user to interact with our application. This will require us to integrate events that dispatch actions from our JSX to our Redux-ish store

Link Events in App to Actions on the Data Store
About the Instructor
Packt Publishing
3.9 Average rating
7,297 Reviews
52,228 Students
616 Courses
Tech Knowledge in Motion

Packt has been committed to developer learning since 2004. A lot has changed in software since then - but Packt has remained responsive to these changes, continuing to look forward at the trends and tools defining the way we work and live. And how to put them to work.

With an extensive library of content - more than 4000 books and video courses -Packt's mission is to help developers stay relevant in a rapidly changing world. From new web frameworks and programming languages, to cutting edge data analytics, and DevOps, Packt takes software professionals in every field to what's important to them now.

From skills that will help you to develop and future proof your career to immediate solutions to every day tech challenges, Packt is a go-to resource to make you a better, smarter developer.

Packt Udemy courses continue this tradition, bringing you comprehensive yet concise video courses straight from the experts.