numbersapi | API consumption with Svelte | Frontend Framework library

change flask route logic to detect the type of error

In api.py

Decodable protocol (in your context) assumes you to create the model struct with all the properties, that you get via JSON. When requesting http://numbersapi.com/2/trivia?json you'll get something like:

From Wikipedia:

Every HTTP URL conforms to the syntax of a generic URI. The URI generic syntax consists of a hierarchical sequence of five components:

(Q1.) Is the presented approach optimal ?

I have a suggestion how to enhance current solution. Currently all crawling threads process their http responses by themself. Moreover when they process their http responses they try to acquire an exclusive lock (ReaderWriterLockSlim.EnterWriteLock) to write results to the file.

I suggest to make crawling threads only send http requests and immediately add http responses into some collection. And another thread (lets call it processing thread) will process these http responses (extract data, parse it, write to file and etc). Such approach will give us next benefits:

1. Crawling threads will not waste their time to process http responses. They will only execute the most expensive operations: send http requests and receive http responses.
2. An exclusive lock will not be needed to process http responses. Processing thread will be able to process http responses without setting any locks.

If in your real program processing of the http responses is more time consumable than in the provided sample then these benefits will decrease the overall execution time of the program.

Here are changes that you need to make in your program to implement this suggestion:

Fetch is a promise based api, it returns a promiss, and you don't need to wrap fetch in promise.

You could prepare the url string in the if checks, and then use it in the fetch call.

Example

An update happens when a component's state or props change. Your render function has neither. I would expect {this.store.getState().count} to run on mount and then never again. Your component has no props and there is no reference to this.state. Referring to this.store is not the same thing and the component-local state. It's the redux store --in an unconventional place, I might add-- and the component does not directly respond the redux store. This is what methods like mapStateToProps are for.

https://reactjs.org/docs/react-component.html#updating

https://react-redux.js.org/using-react-redux/connect-mapstate

It appears you are using Python 2. I would recommend you install the futures package form PYPI. Then this would be one way (by the way, you don't seem to be doing anything with the result of the second request).

Currently you are printing the response object, which contains the raw response including headers, etc. You can do the following:

Would it be faster to resolve the parent straight away after kicking off the child job, then summing the result later?

Yes, it would. If understand correctly, you would want only sibling nodes to be processed sequentially, and have each node wait for its predecessors before starting the work of its children, but not have a node wait for its children to finish.

Or being more explicit, the first fetch from the first level is executing at the same time as the first fetches from the second, third and fourth. That's 4 requests executing in parallel rather than in serial (as in the example code in the op) which would surely save significant time when scaled out to a bigger example.

Yes, that would be faster, but not significantly - a constant factor at most. You would still have to sequentially process all the leaves of the tree.

The code for this is trivial though - you'd just replace the fetch(node).then(processChildren) with a concurrent version: