congratulations on launching! we created a website builder for nft artists called butiq.art where we will test the simplehash api in the next weeks.

on a side note, if you ever need nft data for the tezos blockchain, feel free to shoot me a message. i developed an nft indexer that covers that chain very well.

Thank you! Just sent you an email

I think people with enough experience in software development know quite well if the code they are currently writing is going to be testable or not.

In Germany they are tracking down clusters. As a random person you won't get tested, unless you visited a risky region, had contact with an infected person or your doctor orders a test for you. As a German, this strategy makes sense to me.

Considering the shortage of reagentia for these tests, that definitely makes sense.

Belgium only does tests on people who have recently been in regions at risk (China, Italy) or who have symptoms of pneumonia.

200 infected to date, zero deaths (so far).

Yep, that’s my understanding too and it makes perfect sense.

I use this stack:

Frontend: React - Unstated (or just setState) - Axios - Plain CSS (with BEM notation) - Create React App - Prettier - Jest

Backend: Node.JS - Express - Knex - PostgreSQL - Tape

You can do that, but you will need to find a way to re-render the components which use that service, after something changed.

I think this works well for Angular, because it's based on observables. Rendering is just a function from state->ui. If they build their state-container on observables too, the re-render will follow implicitly by subscribing to it.

I think that's what mobx is all about. I create a simple Javascript class called WhateverStore and make it observable. Then all the UI components are observer of an instantiated WhateverStore and that's about it.

Just do it the React way and re-render everything by calling ReactDOM.render() again. In most cases that is fast enough.

They are used to create arrays. You are able to subscribe to multiple containers:

  <Subscribe to={[CounterContainer, SomeOtherContainer]}>
      {(counter, someOther) => ()}
  </Subscribe>

For example if you have multiple lists of continents and each one needs its own collapsed state. Maybe the user can even dynamically add/remove such continent lists in the UI. IMHO in most of these cases it's best to keep the continents data inside of redux and have the collapsed state being managed by the "ContinentsList" component.

Still, wouldn’t the list of continent-lists be stored as an array in Redux?

Yes, generally something like expanding an accordion component can just sit in the local component state, as long as the collapsed state doesn’t need to affect or be affected by other app state.

I wouldn't store it as array in Redux because that would be too limiting (e.g. let's say I want a continent-list which is decoupled from the other continent-lists). If I would be forced to use redux in this case then I would create some random id for each ComponentList where I would store the UI state (but keep the continents data separated). Something like:

  {
    '<randomId>':
    {
        Asia:
        {
            collapsed: true
        }
    }
  }

IMHO this really makes things unnecessary complicated. It also makes it hard to re-use the ContinentsList component (maybe you want to use the same component in some other project which uses something else than redux?). I always try to think of the API of my react components first and how they later on can be easily reused. After I figured out the API of the react component then I might connect it to some store.

Probably the ContinentsList component would somehow look like this:

  <ContinentsList
    continents={<continents data>}
    renderItem={({ collapse, isCollapsed, continent }) => {
        return <ContinentItem onCollapseClick={collapse} isCollapsed={isCollapsed} continent={continent} />
    }}
  />

I’m still having trouble imagining an application where you would need ContinentLists in different spots without some well-defined arrangement of them in the Redux state where each can be identified by something more concrete than a random ID.

Yeah, I agree that this is an edge case (nothing that I run into on a daily base) and the ContinentLists example might not be the best in this context. Something like a Dashboard with dynamic widgets would probably be a more realistic case.

This one is also nice: https://github.com/sindresorhus/noop3 It has a noop factory :-)

See also the issues: https://github.com/sindresorhus/noop3/issues

What's up with the funky labels?

It's called Zalgo [1]. I'm surprised that GitHub allows Zalgo characters in the issues.

1 : https://eeemo.net

There is no such a thing as zalgo characters. It is plain unicode (utf-8 shaped), in particular it is an abuse of combining characters. Disabling those can cripple non-english languages.

It's possible to look at how "overloaded" the combination characters are and trigger a filter if above a certain level.

I doubt non-english languages quite overload as much as "zalgo" generators.

I'm actually not sure where the term Zalgo comes from. I know the effect is abused Unicode feature, but was never sure how does the term "Zalgo" end up explaining it.

Checkout the import() proposal:

https://github.com/tc39/proposal-dynamic-import

It basicly is what you are describing.

This could be a really nice replacement of Backbone.View.