kutyel

import React, { useReducer, createContext } from 'react'
import { propOr } from 'ramda'

import en from '../../assets/literals/EN'
import es from '../../assets/literals/ES'

const translations = { en, es }
const getTranslate = lang => key => propOr(key, key, translations[lang])
const initialState = { lang: 'en', t: getTranslate('en') }

sebmarkbage

I heard some points of criticism to how React deals with reactivity and it's focus on "purity". It's interesting because there are really two approaches evolving. There's a mutable + change tracking approach and there's an immutability + referential equality testing approach. It's difficult to mix and match them when you build new features on top. So that's why React has been pushing a bit harder on immutability lately to be able to build on top of it. Both have various tradeoffs but others are doing good research in other areas, so we've decided to focus on this direction and see where it leads us.

I did want to address a few points that I didn't see get enough consideration around the tradeoffs. So here's a small brain dump.

"Compiled output results in smaller apps" - E.g. Svelte apps start smaller but the compiler output is 3-4x larger per component than the equivalent VDOM approach. This is mostly due to the code that is usually shared in the VDOM "VM" needs to be inlined into each component. The tr

arunas-cesonis

module GoogleChart exposing (..)

import Html exposing (Html)
import Html.Attributes as HtmlA
import Json.Encode as E
import List.Extra as List
import Chart exposing (..)


colors =

kutyel

{
  "presets": [
    "@babel/preset-react",
    [
      "@babel/preset-env",
      {
        "targets": {
          "browsers": [
            "last 2 versions",
            "ie >= 11"

rachelcarmena

const curry = fn => {
    const arity = fn.length;
    const _curry = (...args) =>
        args.length === arity
            ? fn(...args)
            : arg => _curry(...args, arg);
    return _curry();
}

kutyel

git ls-files | grep \\.js$ | xargs wc -l

choonkeat

module Http.Extra exposing (..)

import Http
import Json.Decode


{-| to obtain a String from `Http.task`

    Http.task
        { resolver = Http.stringResolver httpStringBodyResolver

threepointone

https://twitter.com/snookca/status/1073299331262889984?s=21

‪“‬In what way is JS any more maintainable than CSS? How does writing CSS in JS make it any more maintainable?”

‪Happy to chat about this. There’s an obvious disclaimer that there’s a cost to css-in-js solutions, but that cost is paid specifically for the benefits it brings; as such it’s useful for some usecases, and not meant as a replacement for all workflows. ‬

‪(These conversations always get heated on twitter, so please believe that I’m here to converse, not to convince. In return, I promise to listen to you too and change my opinions; I’ve had mad respect for you for years and would consider your feedback a gift. Also, some of the stuff I’m writing might seem obvious to you; I’m not trying to tell you if all people of some of the details, but it might be useful to someone else who bumps into this who doesn’t have context)‬

So the big deal about css-in-js (cij) is selectors.

aarongarciah

React Alicante 2018 Talks

Conference Day 1

• 2018 - The Year of Web Components, Dominik Kundel
• The Lonely and Dark Road to Styling in React, Sara Vieira
• Next Generation Forms with React Final Form, Erik Rasmussen
• The ABC of Coded Style Guides, Henning Muszynski
• Testing, Testing, 1, 2, NaN, Gant Laborde
• Lambdas, lambdas everywhere..., Flavio Corpa

IagoLast

license: gpl-3.0
height: 600
scrolling: no
border: no