Learn Clojurescript, Greensock and Mobx

Animations attract the eye and add a higher level of engagement for your users. But they’re not easy to set up, and they don’t always look the way they should on every browser. 

Greensock is the best platform available for creating performant, highly-customizable animations. This course will walk you through the features of Greensock, including how to:

- animate an element
- manually control an animation
- animate between CSS classes

…and more, with cross-browser support to ensure your animations look sharp everywhere.

Ultra high-performance, professional-grade HTML5 animation for the modern web

greensock

Create Amazing Animations with GreenSock

Developing logic-rich applications is a key skill to have.

The TypeScript–React combination helps you unlock that skill, and it’s a great developer experience in terms of writing understandable and refactorable HTML. But the default state management for React has a long way to go to feel simple and maintainable — and that’s where MobX makes your life so much easier. MobX keeps things simple without using complicated setups like `provider` and `connect` that provide way too little value for all the mental overhead. 

In this course, you’ll see how to model your React application logic using simple JavaScript classes — and with the help of MobX, make those classes the beating heart of your React applications. You’ll learn:

- that you don't need advanced annotations and TypeScript features to use MobX
- how to easily refactor code through TypeScript
- how to use TypeScript to track the flow of state as properties change

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

Develop React Applications with Mobx and TypeScript

MobX State Tree (MST) is a library that helps you organize your application states in a very structured manner. It allows you to create a component model, but for your data!

Course instructor Michel Weststrate—creator of Mobx—will teach you to model application state after your problem domain with MST. You will get hands-on practice and see how MST lets you solve problems with its out-of-the-box support for asynchronous actions, patches, snapshots, and middleware.

Over the 17 lessons, you’ll build a little bookshop application using React, MST, and create-react-app, while learning how to manage the lifecycle of your data by describing data models. 

Join Michel in one of the most popular courses on egghead!

Manage Application State with Mobx-state-tree

MobX is designed to enable building web applications with a complex data model in an intuitive and very performant manner. Using React and MobX is currently the simplest way to build component based web applications.

"Half the code, twice the fun" is how people describe MobX, or "So simple, I cannot believe it just works". 



Manage Complex State in React Apps with MobX

Applications are driven by state. Many things, like the user interface, should always be consistent with that state.
[MobX](https://mobxjs.github.io/mobx) is a general purpose FRP library that provides the means to derive, for example, a React based user interface automatically from the state and keep it synchronized.

The net result of this approach is that writing applications becomes really straight-forward and boilerplate free.

Sync the UI with the app state using MobX observable and observer in React

This lesson explains how you can build larger trees of react component and how they are managed efficiently by MobX. You will learn how to pass observable data structures around in props and how the Devtools can be used to analyze the performance of your UI.

Pass observable data through props in MobX

This lesson explains how actions can be used to control and modify the state of your application. They help you to structure your code base and integrate well with the MobX React Devtools. Actions automatically create transactions, which group changes together.

Use MobX actions to change and guard state

Derivations form the backbone of MobX and come in two flavors: computed values are values that can be derived from the state automatically. And reactions can be used to manage side effects, such as drawing the user interface. In this lesson you will learn how these concepts relate to each other and how they are optimized automatically by MobX.

Derive computed values and manage side effects with MobX reactions

In this lesson we will finally do something useful with our temperatures. We extend it into a small app in which users can enter a location, which is used as input for an external API to fetch weather data. In the mean time MobX keeps our UI in sync with the current state of the request.

Handle user input and asynchronous actions with MobX

Passing down stores through each layer of components can be a tedious job. This lesson demonstrates how Provider can be used to automatically connect observer based components to stores, by leveraging React's context mechanism in the background.

Connect MobX observer components to the store with the React Provider

So far we have been talking briefly about reactions. In this lesson you will learn how reactions can be used to observe state until some condition is met. After that you will see how autorun can be used to automatically trigger side effects. This is used internally by observer as well. We will test this by replacing React with our own handcrafted rendering which is still kept in sync with the state by MobX!

Write custom MobX reactions with when and autorun

So far we have used the observable decorator extensively. Let's take a closer look on what it does and see how the extendObservable and observable functions can be used to create observable objects, arrays and maps.

Use observable objects, arrays, and maps to store state in MobX

The MobX React devtools can be used to analyze when and why React components are re-rendered. They offer three features: 1) visualize when components re-render, 2) show the dependency tree of a component, to see which data it's rendering depends upon, and 3) log in detail which data is changed by your actions, and how these changes propagate through the application.

Analyze React components with MobX-React devtools

In this lesson, we will look at Greensock's Draggable API. We will implement a scrollable `<div>` container and explore some options available.

Create scrollable DOM elements with Greensock

In this lesson, we introduce the running example of this course, a wishlist app. We will take a look at the core of mobx-state-tree (MST), models. Models describe the shape of your state and perform type validation. 

You will learn:
* Defining models using types.Model
* Instantiating models from JSON using Model.create
* Primitive types: types.string & types.number
* Type inference for primitive types
* types.array
* types.optional
* Composing models into a model tree
* Testing models using jest

Describe Your Application Domain Using mobx-state-tree(MST) Models

We will expand our UI, and give the user the possibility to edit his wishlist. We will use the earlier defined actions. We also will use model clones only to modify data temporarily, and after approving the changes, apply them back to the original model. 

In this lesson you will learn: 
* How to call model actions from a component
* Using `clone` to create a full, deep clone of any model instance
* Using `applySnapshot` to update the state of a model instance given a snapshot.

Build Forms with React to Edit mobx-state-tree Models

mobx-state-tree uses Mobx behind the scenes, making it super straightforward to render MST models in React. By using the `observer` wrapper, React components will automatically react to any relevant updates of the rendered models in the future.

In this lesson you will learn:
* How `observer` from the 'mobx-react' package is enough to render data in React components, and get notified of updates
* That using models in components keeps components dumb so that components can often be stateless function components
* The mobx devtools can be used to visualize that mobx-react finds the minimal sets of components to re-render after each change automatically for you

Render mobx-state-tree Models in React

Models are not just a nifty feature for type checking. They enable you to attach behavior to your actions in a straightforward and highly discoverable way

In this lesson, you will learn:
* How to define actions on models
* How to avoid `this` issues by using self
* Models can only be modified using actions, and are further read-only from the outside

To learn more about TypeScript check out John Lindquist's wonderful course, [Up and Running with TypeScript](https://egghead.io/courses/up-and-running-with-typescript).


Attach Behavior to mobx-state-tree Models Using Actions

Redundant data or caching data is a constant source of bugs. MST adheres to the philosophy that no data that can be derived should ever get stored. In this lesson, you will learn how to introduce views that declaratively derive data and which cache data smartly.

In this lesson you will learn:
* How to introduce views on models
* That computed properties are powered by Mobx computed fields
* How to combine MST with Mobx utilities like `reaction`

To learn more about MobX basics check out my course, [Manage Complex State in React Apps with MobX](https://egghead.io/courses/manage-complex-state-in-react-apps-with-mobx)

Derive Information from Models Using Views

Testing models is straightforward. Especially because MST provides powerful tools to track exactly how your state changes over time. Track snapshots, action invocations or even patches to verify the correctness of your actions!

In this lesson you will learn:
* To obtain immutable snapshots of the state using `getSnapshot`
* To record snapshots using `onSnapshot`
* To store and test modifications over time using `onPatch`
* Using Jest's snapshot test feature to verify snapshots and patches
* That MST can infer the type of a snapshot for you

Test mobx-state-tree Models by Recording Snapshots or Patches

In this lesson we will dive a bit more into the tree semantics of MST. 

In this lesson you will learn:
* Actions can only modify their own subtree
* The use of `getParent` to find the parent of a model instance
* Using `destroy` to remove an instance entirely from the tree


Topics

Instructors

Content Type

Free or Pro