The Tully Monster is a famously odd 300-million-year-old fossil that looks like an alien, but a new analysis suggests it was a backboned animal like a hagfish or lamprey

Weird blasts of radio waves from space called fast radio bursts have been baffling astronomers since they were discovered, but after finding one in our galaxy we may finally know what creates them

A fresh look at the world’s oldest religious texts suggests ancient Egyptians saw the sky as a water-filled iron container from which chunks fell to Earth as meteorites

Telling Lies is a game where you sift through video calls to solve a mystery. Half the time you don't know what you should be doing, but that's part of the fun, says Jacob Aron

Skatje is working hard on her thesis in computational linguistics, and might not appreciate a joke about how easy it is. It’s hard enough that I don’t even understand what she’s doing when she tries to explain it!

California Governor Gavin Newsom announced Friday that he had signed an executive order to mail ballots to the state’s 20.6 million registered voters, citing potential health risks due to the ongoing coronavirus pandemic.“There’s a lot of excitement around this November’s election in terms of making sure that you can conduct yourself in a safe way, and make sure your health is protected,” Newsom said Friday. In March, the state allowed ballots to be mailed in for its primary, which saw a record-high of 72 percent of all ballots that were cast by mail.California Secretary of State Alex Padilla, who heads the state’s elections, commended the move “It’s great for public health, it’s great for voting rights, it’s going to be great for participation,” he said. California already allows for generous absentee voting, passing a 2002 decision which gives voters the option to request permanent voting by mail, regardless of the reason.While Newsom’s decision applies only to the November election, it could set a precedent for other Democratic states, with voting by mail quickly becoming a partisan issue. It comes after the state’s lawmakers and local officials requested the measure, saying coronavirus will severely hamper voting efforts, a complaint echoed by prominent Democrats.“Why should we be saying to people, ‘Stand in line for hours,’ when we don’t even want you leaving the house?” House Speaker Nancy Pelosi said in April. But President Trump has repeatedly slammed calls for mail-in voting, saying last month that it lets “people cheat” and involves “a lot of dishonesty.”Newsom said that his order would still allow an “appropriate number” of in-person voting sites, saying that some voters, including those that are disabled, require technological help to cast a ballot.

On Thursday, the country reported its largest one-day increase in new cases of 11,231 — yet President Putin already has his eyes on reopening.

Former director of national intelligence James Clapper in 2018 said that he hadn't seen evidence that the Trump presidential campaign colluded with Russia to win the 2016 general election.Clapper was responding to a query from then-representative Tom Rooney, a Florida Republican, during an interview before the House Intelligence Committee. The transcript of the interview was released on Thursday."I never saw any direct empirical evidence that the Trump campaign or someone in it was plotting [or] conspiring with the Russians to meddle with the election," Clapper said."That's not to say that there weren't concerns about the evidence we were seeing, anecdotal evidence…[redacted]," Clapper added. "But I do not recall any instance when I had direct evidence of the content of these meetings. It's just the frequency and prevalence of them was of concern."Rooney then asked Clapper, "At what time is collusion collusion, and at what time is it just people that may have an affiliation with the campaign meeting or talking with… the Russian ambassador or somebody that's of Russian origin, and when should that be taken as something that rises to the level of an Intelligence Community concern?""I really can't answer it other than the sort of visceral reaction to why all these meetings with the Russians," Clapper responded. Clapper admitted that it would be "legitimate" for incoming Trump administration officials to meet with representatives of Russia, "but I think there is a line…between that and violating the principle that in this country we traditionally have one President and one administration at a time."The interview was part of a set of 53 transcripts of interviews held by the House Intelligence Committee as part of the Russia investigation. Current committee chairman Adam Schiff had called for the release of the transcripts in 2018.However, after 43 transcripts had been reviewed and redacted by intelligence agencies as of June 2019, Schiff refused to relase the completed transcripts to the public. Current acting DNI head Richard Grenell informed Schiff on Wednesday that all the transcripts were ready for publication.

Conor Burns used his position as an MP to intimidate a member of the public, standards watchdog finds.

A judge dismisses Christian Hacking's bid to overturn a ban on posters put up around Waltham Forest.

Demand for milk has dropped with the closure of cafes and restaurants during the coronavirus crisis.

The PM says government is "working hard" to tackle it - and sets 200,000 test aim by end of month.

Nadia Whittome claims she was "sacked" but the care employer says she was no longer needed.

Almost half a million people are at "high risk" of homelessness, local councils warn government.

UFC middleweight Jacaré Souza tests positive for Covid-19 and will no longer compete at the controversial UFC 49 show.

He and his stage partner Siegfried Fischbacher were one of the longest-running acts in Las Vegas.

Dax was one of YouTube's first stars, but 13 years later, few people remember his name. Can a vlogging legend seize glory again?

Figures suggest that IT now generates as much CO2 as flying, with some arguing it's nearly double.

A BBC investigation has found online scams selling fake protective equipment and coronavirus tests.

A petition calling for maternity leave to be extended due to coronavirus has attracted many signatures.

I’ve been working on a pretty large react-router codebase at work. Currently it has around 50~ code splits, which as you can imagine, is a lot of routes. This is going to be a post on the things I’ve learned throughout building out my development / production config and how we are using webpack in production.

###Initial Setup

Before I really dive into how my webpack config is setup and the problems I’ve found, I’ll quickly go over how this app is setup. Currently, there’s one entry point and it looks like this:

import React from 'react'
import { render } from 'react-dom'
import { match, Router, browserHistory } from 'react-router'
import AsyncProps from 'async-props'
import routes from '../routes/index'
/* globals document, window */

const { pathname, search, hash } = window.location
const location = `${pathname}${search}${hash}`

match({ routes, location }, () => {
  render(
    <Router
      render={props => <AsyncProps {...props}/>}
      routes={routes}
      history={browserHistory}
    />,
    document.getElementById('app')
  )
})

It looks like a standard react-router setup, except a couple things are different. For one, there’s way too many routes to have them all in this file, so we are importing the main route object into this file. Second, we are using match on the client side. Without matching first, the client side would try to render before the splits were downloaded causing an error. You can read a little more about match on the client here.

Next, we are using Ryan Florence’s awesome async-props library for loading data into components. It allows me to load data from an api before the server renders components. It will pass the data down to the client for the client-side render, and then data will load as you navigate to new pages automatically.

###Routes

Our main routes file looks like this:

export default {
  component: 'div',
  path: '/',
  indexRoute: require('./index'),
  childRoutes: [
    require('./login'),
    require('./account'),
    ...
  ]
}

There’s a lot more require’s in our app of course. And these are nested pretty deep. The files referenced in the root file have more child routes, and those use require.ensure which you can read about in the webpack docs on code splitting. It tells webpack to make a new bundle, and then load that bundle when require.ensure is called on the client. Here’s an example:

if(typeof require.ensure !== "function") require.ensure = function(d, c) { c(require) }

module.exports = {
  path: 'account',
  getComponent(location, cb) {
    require.ensure([], (require) => {
      cb(null, require('../../views/master/index.jsx'))
    })
  },
  childRoutes: [
    require('./settings'),
  ]
}

There’s a few things going on here. First, we have a function at the top that will polyfill require.ensure. Why? Well, on this project we are server rendering our whole site as well, which I would rather not do, but due to the type of site we are building: we have to. The next thing is the relative require path. I’m using this awesome babel resolver plugin along with webpack’s resolve paths so that I can import files like this:

import Header from '../../master/header'
//becomes
import Header from 'master/header'

Why do I have to use a babel plugin AND webpack’s resolve feature? Once again, doing a server rendered app, the code is ran on the server and also through webpack. In this particular app, I haven’t had time to experiment with webpacking the server. Anyways, if I didn’t use the babel plugin, errors would be thrown on the server, but webpack would work fine. This is one of the common things I have ran into while building this app.

Realizing some things need to be done slightly different on the server or client. You may still be wondering why I am referencing the component as a relative path in the above route example, and that’s because the babel plugin I’m using only works with import and not require. My route objects are the one place that I have these “nasty” looking paths.

##Webpack

I was prompted to make this article after tweeting this out:

webpack splits vs AggressiveMergingPlugin({minSizeReduce: 1.0}) pic.twitter.com/b6kxHEqNcO

— ReactJS News (@ReactJSNews) March 10, 2016

A couple people wanted a better explanation as to what’s happening here. When I was first building my production webpack config, even after using all of these plugins:

new webpack.optimize.CommonsChunkPlugin('vendor', 'vendor.js'),
new webpack.optimize.OccurenceOrderPlugin(),
new webpack.optimize.DedupePlugin(),
new webpack.optimize.UglifyJsPlugin({
  compress: { warnings: false },
  comments: false,
  sourceMap: false,
  mangle: true,
  minimize: true
}),

My bundle looked like this:

That’s pretty huge if you think about it. And I’m not talking about the amount of bundles. I’m talking about the file size. After searching everywhere for a solution to get the bundle size down further, I found webpack’s AggressiveMergingPlugin. This thing is a life saver. As you may have seen from the tweet, the output turns into this:

Just having the main, vendor, and one other bundle brings the whole site under 1MB. I’m using the plugin to only merge files if the size reduction is more than 50%, which is the default.

People talk about code splitting in webpack and think it’s really amazing to load the JS for the page you’re on and nothing more. It sounds great. The problem is that the file size is immensely bigger. If someone more familiar with webpack has a better idea as to why this is, I’d like a better explanation. It isn’t feasable to keep the splits instead of merging them. This site is pretty large, with a lot of routes as you can tell from the screenshots. Codesplitting without merging would cause way more waiting on the client side every time you navigate to a new page. Even if the JS was heavily cached, the first time you hit these pages it will have to load a 300kb bundle for some of them.

##Caching

That takes us to caching. We are about a month away from publicly launching this site, so we haven’t setup the workflow for pushing updates through a cdn, but that will be the end result. For now, in my webpack config, my output object looks like this:

output: {
  path: __dirname + '/public/assets/js/[hash]/',
  filename: '[name].js',
  chunkFilename: '[id].js',
  publicPath: '/assets/js/[hash]/'
},

This is in the production config of course. This way I can cache the files and when I update the code, the hash will change and the browser won’t be caching the old code. I pass in the hash as an env variable at runtime to that the server has the correct path to the assets folder.

##Problems

There were a few big problems I came across while building out a server rendered app with dynamic routes. The first was page titles. How am I supposed to have the right title on the client and on the initial server render? Thankfully, Ryan has yet another solution. react-title-component solves this perfectly.

The next was, how do I hit an api, wait for the response on server render, load new data on route changes, and of course, do this at the component level. As I mentioned before, async-props solves this problem too. It will give you route info so that you can make requests based on things in the url.

The next problem is one that I haven’t fully solved. Webpack is getting really slow. It takes around 20 seconds on a maxed out macbook 15” to build code in production. On the server, it takes more like a minute! If I’m in development mode, it takes around 10 seconds to make the initial build, and sometimes it lags on building the splits on code change. If anyone has insight into this I would love to hear it.

This one goes along with the webpack one, and it is reloading the server. I haven’t tried to webpack the server but I hear doing so works great for this. I don’t think it would fix the problem with webpack being slow though, and in fact it would probably make it even slower.

##Folder structure

I almost forgot to throw this one in here! I’m really happy with the structure of this project. I have a views folder that has all of the same folders and file names as the routes folder. It makes it really easy to find things. These also correspond with the URL to the page. /account/settings will be in views/account/settings.jsx and routes/account/settings.js. The same is true for my tests folder.

##Conclusion

I hope this gave you a good glimpse at how webpack and react router work at a larger scale than you see most blog posts cover. If you have any questions or things that you would like me to talk about that I haven’t already, please leave a comment below and I will update this post! I’m sure that I forgot a few problems and tips writing this. I was thinking this would be a short post but it blew up on me!

Without any modifications, React is really fast as-is. There are, however, a few things that you can do to improve performance. While working at HelloSign, I discovered some quick fixes that made our apps incredibly snappy. With these simple changes, I was able to reduce render time from over 3000 milliseconds to less than 200 milliseconds.

Without any modifications, React is really fast as-is. There are, however, a few things that you can do to improve performance. While working at HelloSign, I discovered some quick fixes that made our apps incredibly snappy. With these simple changes, I was able to reduce render time from over 3000 milliseconds to less than 200 milliseconds.

Editor’s Note:

Check out our upcoming React University Workshops. Our next workshop, React 2016, will be held on April 23 at Microsoft Reactor in San Francisco and will offer a deep dive into creating modern Single-Page Applications (SPA) using React, Redux, React Router, Immutable.js, and Webpack. Also, if you’re interested in learning the basics about what it takes to be a Data Visualization Engineer, check out React and D3.

Introduction

HelloSign is a cloud-based electronic signature tool founded in 2010. As you can imagine, HelloSign is a very JavaScript-heavy codebase. A lot of client-side behavior is necessary to create a rich signing experience. Lately, we’ve moved much of our codebase toward React. In fact, in many places we’ve broken up our codebase into several single-page applications written in React.

Although the HelloSign team was happy with React’s performance before I initially joined the project, I quickly found some low-hanging fruit that could improve runtime speed. Here are the steps you should take to see similar improvements in your own applications.

Create a Baseline Performance Measurement

Before you begin, you should take a baseline measurement. Optimizations are meaningless if you can’t verify the results of your modifications.

Thankfully, Chrome has excellent developer tools to help. One, little-used feature of Chrome’s DevTools is the “Timeline” tool. It allows you to record and analyze all activity in your application. You can record interactions on the page, locate potential memory leaks, measure the total time it takes to perform a task, and identify areas of potential jank. Best of all, the results can be recorded for comparison with your final benchmark.

There’s actually a really awesome video on Chrome’s DevTools that goes into detail about the “Timeline” feature. You can view it here.

We chose to measure the time elapsed between the initial paint of our signer page to the final rendering of the entire page. The initial download of our bundles still needs some optimization, but we’re neither going to mess with nor measure this parameter. It’s fairly easy and consistent to test render time rather than trying to click areas around the page and trying to measure its performance in a repeatable way. Then, all we needed to do was to go to the signer page, open Chrome’s DevTools “Timeline” tab, and refresh the page.

As a side note, make sure that when performing this test, the “Paint” and “Screenshots” boxes are checked so that you can see what the user sees as the page is being rendered.

After all that, we determined that our rendering time from initial paint was a little over 3 seconds. Much too long. Luckily, there was little we had to do to make this quite a bit faster.

Set NODE_ENV to Production

This step is easy to get wrong, even if you are well-informed. React’s documentation provides an overview, but doesn’t provide many specifics. React has great developer warnings and error checking, but these are only intended for development; if you take a look at React’s source code, you’ll see a lot of if (process.env.NODE_ENV != 'production') checks. This is running extra code that is not needed by the end user, not to mention that calling process.env.NODE_ENV is extremely slow. For production environments, we can remove all this unnecessary code. Just keep in mind that you don’t want to do this in development because it will remove all those helpful developer warnings.

If you’re using Webpack, you can use DefinePlugin to replace all instances of process.env.NODE_ENV with 'production', and then use the UglifyJsPlugin to remove all the dead code that no longer runs. Here’s a sample setup that you might use:

// webpack.config.js
  ...
  plugins: [
    new webpack.DefinePlugin({
      // A common mistake is not stringifying the "production" string.
      'process.env.NODE_ENV': JSON.stringify('production')
    }),
    new webpack.optimize.UglifyJsPlugin({
      compress: {
        warnings: false
      }
    })
  ]
  ...

React Constant and Inline Elements Transforms

React 0.14 introduced support for certain transpile time optimizations with Constant and Inline Element Babel Transforms. React Constant Elements treats JSX elements as values and hoists them to a higher scope. In other words, it hoists static elements and thereby reduces calls to React.createClass. React Inline Elements converts JSX elements into the object literals that they eventually return. Again, this minimizes the runtime calls to React.createClass.

The implementation is rather simple. We added our Babel configuration in our package.json file:

// package.json
  ...
  "babel": {
    "env": {
      "production": {
        "plugins": [
          "transform-react-constant-elements",
          "transform-react-inline-elements"
        ]
      }
    }
  },
  ...

Final Measurement / Conclusion

Lastly, you’ll want to run the benchmark again and compare it with that saved benchmark from before these optimizations. As you can see, the total runtime profile ends 200ms after initial paint! That’s 15 times faster!