sim0n

Looks perfectly fine in FF 144.0 on Mac OS.

I would assume that lot of people just find the JSX equivalent a lot more readable and familiar (a matter of opinion, of course.)

  <div>
    <p>this is easy</p>
    {list.map((l) => <li>{l}</li>)}
  </div>

> you automatically get loops, variable interpolation etc without having to invent a compiler and new syntax

To be fair to JSX, you use regular loops, interpolation, etc without any different syntax (`{}` accepts a vanilla JS expression), you just obviously need the compiler step to de-sugar the element tags to `createElement` calls.

That's not particularly high for a large scale web application where every file is a ES module, especially so if it includes dependencies.

Nothing is "wrong" with it, the design is just something from the 90s/early 2000s.

They haven't.

One case I've come across them using it for is delivering updates for visible tweets in a timeline (e.g. like/retweet counts being mutated).

Not exactly a framework, but a React app from 2014 will still work great in 2019 and can be updated with very little pain.

Build tools wise, a simple Webpack/Babel config from 2014 would be relatively straightforward to update to the latest versions.

> Soccer would be a much better sport

Very subjective. I personally think having a limited set of substitutions helps keep the game more interesting as every change can be hugely impactful to the team's tactics and the result of the game.

Why is "map an array with a function" unintuitive but "filter an array with a function" isn't?

I'm sure they do. This is pretty standard at lots of big tech companies (Airbnb, most likely Uber, etc).

DOM APIs have much improved since jQuery first arrived, so while that was the case originally, it's become less true over time. It's definitely still less verbose though, for example:

  $('.my-component div').css({ background: 'yellow' })

vs.

  Array.from(document.querySelectorAll('.my-component div')).map(node => {
    node.style.background = 'yellow';
  })

The article says they will no longer allow Touch ID to trust a computer, I imagine they also won't allow Face ID.

I personally think that the syntax is great considering it's being added to an existing language. await/async allows you to opt-in to having your code behave in a synchronous-like manner, when you want it to.

One of the best things about JS/Node is that you can wait on I/O from different sources at the same time and since the async/await syntax is just sugar over Promises, you can do things like:

  const [user, notifications, messages] = await Promise.all([
    getUser(),
    getNotifications(),
    getMessages(),
  ]);

Instead of having to wait on I/O sequentially like:

  const user = getUser();
  const notifications = getNotifications();
  const messages = getMessages();

if awaiting were implicit.