Introducing Immer: Immutability the easy way – Hacker Noon

  • The producer function receives one argument, the draft, which is a proxy to the current state you passed in.
  • The currentState will be untouched during this process.Because immer uses structural sharing, and our example producer above didn’t modify anything, the next state above is simply the state we started with.Let’s take look at what happens when we start modifying the draft in our producer.
  • It is not too bad in this simple case, but this process has to be repeated for every action, and on every level in which we want modify something.We have to make sure to return the existing state if the reducer doesn’t do anythingWith Immer, we only need to reason…
  • Both the original reducer and the new one behave exactly the same.No strings attachedThe idea to produce the next immutable state by modifying a temporarily draft isn’t new.
  • This will create a new function that will execute the producer when it’s passed in a state.

Immutable, structurally shared data structures are a great paradigm for storing state. Especially when combined with an event-sourcing architecture. However, there is a cost to pay. In a language…
Continue reading “Introducing Immer: Immutability the easy way – Hacker Noon”

Playing with React Native Animations – Hacker Noon

Play with React Native animations:  #ReactJS #JavaScript

  • For the delay we’re using the delay that was passed to the component.
  • We want to actually use these files in our app – to do so replace index.ios.js and index.android.js with the following.
  • We’ll keep this very simple and create 10 data elements with a width between 0 and the screen width – this will all take place in app/index.js
  • In app/AnimatedBar.js we’ll just set some static styles and apply them to our view.
  • Then create an app/index.js and app/AnimatedBar.js and copy and paste the following into them to get started.

For my first post of the year I wanted to keep it light and experiment a little bit with the React Native Animated API. We’ll create a few bars that animate in and constantly change their size. Here…
Continue reading “Playing with React Native Animations – Hacker Noon”

React.js pure render performance anti-pattern – Esa-Matti Suuronen – Medium

#ReactJS pure render performance anti-pattern:  by @EsaMatti #JavaScript

  • The Cell component was even more complicated and the app rendered multiple cells for each user.
  • const default = []; class Table extends PureComponent { render() { return (
    {this.props.items.map(i => )}

    ); } }

  • Originally I didn’t think that Reselect , library which is even mentioned in the official Redux docs, would be that important because I would rarely write that expensive map state functions for Redux connect() .
  • A new function is created with a new identity.
  • Pure render optimized React components can be extremely performant but it requires users to treat their data as immutable for it to work properly.

“React.js pure render performance anti-pattern” is published by Esa-Matti Suuronen
Continue reading “React.js pure render performance anti-pattern – Esa-Matti Suuronen – Medium”

Functional Components with React stateless functions and Ramda – Medium

Functional Components with React stateless functions and #Ramda:  #JavaScript #ReactJS

  • Finally create a main.js file and start rendering!
  • The components must not retain internal state, do not have backing instances, and do not have the component lifecycle methods.
  • The first time I read about react stateless components I wondered if I could R.compose such functions.
  • For now the only explanation needed is that, since we are using stateless components that are pure functions to their props , state must be managed elsewhere.
  • The simplified component API is intended for components that are pure functions of their props.

What you need to know:
Continue reading “Functional Components with React stateless functions and Ramda – Medium”

React.js pure render performance anti-pattern – Medium

React.js pure render performance anti-pattern:  by @EsaMatti #JavaScript #reactjs

  • The Cell component was even more complicated and the app rendered multiple cells for each user.
  • const default = []; class Table extends PureComponent { render() { return (
    {this.props.items.map(i => )}

    ); } }

  • Originally I didn’t think that Reselect , library which is even mentioned in the official Redux docs, would be that important because I would rarely write that expensive map state functions for Redux connect() .
  • A new function is created with a new identity.
  • Pure render optimized React components can be extremely performant but it requires users to treat their data as immutable for it to work properly.

Pure render optimized React components can be extremely performant but it requires users to treat their data as immutable for it to work…
Continue reading “React.js pure render performance anti-pattern – Medium”

Why The Hipsters Recompose Everything – JavaScript Inside – Medium

Why the hipsters recompose everything:  #ReactJS

  • It’s important to note that these functions are catered towards function components but should work for class components none the less.
  • High order components are functions that expect a component and return a new component.
  • After creating the factory we return a new function which applies the mapping function with the passed in props.
  • mapProps expects a mapping function which returns a new function that itself awaits a component.
  • const enhance = mapProps(props => omit ([‘foo’] , props))

Building a Utility Library for React
Continue reading “Why The Hipsters Recompose Everything – JavaScript Inside – Medium”

Higher Order Components: A React Application Design Pattern

Higher order components: A #ReactJS app design pattern

  • Because higher order components often wrap an existing component you’ll often find you can define them as a functional component.
  • You need some of your React components to be able to access this information, but rather than blindly making it accessible for every component you want to be more strict about which components receive the information.
  • We’ll discuss how pure functions keep code clean and how these same principles can be applied to React components.
  • In the React ecosystem these components are known as higher order components because they take an existing component and manipulate it slightly without changing the existing component .
  • A higher order function is a function that when called, returns another function.

Read the full article, click here.


@ReactiveConf: “Higher order components: A #ReactJS app design pattern”


Jack Franklin takes a look at Higher Order Components, a design pattern that helps keep your React applications tidy, well structured and easy to maintain.


Higher Order Components: A React Application Design Pattern