Picking the right architecture = Picking the right battles + Managing trade-offs

1. Clarify and agree on the scope of the system

• User cases (description of sequences of events that, taken together, lead to a system doing something useful)
  • Who is going to use it?
  • How are they going to use it?

This serves as a quick reference and showcase of GitHub Flavored Markdown. For more complete info, see John Gruber's original spec and the Github-flavored Markdown info page.

NEW! Notes

I used a DFS with a cache. DFS is implemented with a stack and a while loop, no function call. I used 2 stacks, one for the generated boards containing only the board as an int32 and one for the parent board with the hash being accumulated, the number of children and the permutation (used for symetries).

I used 3 bit per cell in a board fitted into a 32bit integer. I never decode that representation into an array, instead I use SWAR (SIMD within a register) to do computations, shuffling and tests. During move generation, two operations are quite useful: add_saturate and zmask. The first one adds each of the 9 cells of two input board, if the result overflows it is clamped to 7 (maximum representable value in 3 bits). The second set the top bit of each cell to one if the cell is zero, otherwise it clears all bits of the cell.

The following table outlines the detailed functional requirements of The Urlist website.

This subflow uses the http request node to fetch solar forecasts for geographical positions, using the API from https://forecast.solar/. Please check their website and consider getting a paid account.

Do note that, on a free account, you are limited in the number of requests to do. Also note that the data only gets updated once every 15 minutes, so there is no reason to query more often. There is rate limiting built in the subflow not to perform requests more than once every 15 minutes.

Yoneda (and its duel Coyoneda) is well known in the Category Theory field and has been ported over to functional languages such as Haskell. Each have their uses - sometimes in similar scenarios, also in very different ways.

This will be a newbie's explanation of the concept, using Haskell to illustrate, without any Category Theory.

From what I've read, the Yonedas are not 'daily-drivers' (not used everyday), but rather can be pulled out when the time is right.

Uses: Both Yoneda's can be used to help speed up a program where there are many fmap with long lists or big trees involved. Coyoneda can be used if you want to create an 'interface' and build up calculations, then pass those calculations to an 'executor' to run them.