puzzles | Such as Sudoku : And others from the 1to9Puzzles folks

To plot the simple barplot use.

The first thing I see is that you have quite a few instances of let with no matching in.

At the top level of a module you can have let name = value. This declares a value to be exported from the module (roughly speaking).

Everywhere else (inside function definitions in particular), every let has to have a matching in. The let expression looks like this:

If you want to use a format string, you could define

session.execute(select(User)) will return a list of Row instances (tuples), which you need to unpack:

I think the key piece of information is this part of the error message:

Unable to connect to the discovered orderer orderer0.example.com:7050

This is a node that has been located by the client using service discovery, not defined in your connection profile.

What I suspect has happened is that, even though you have changed the port mappings between your local machine and the Docker network, the orderer is still listening on port 7050 within your Docker network.

The discovery.asLocalhost connection option is there to support the scenario where the blockchain network is running within a Docker network on the client's local machine, so it causes any discovered hostnames to be treated as localhost, but it leaves the discovered port numbers unchanged. So, when using the discovery.asLocalhost option, the port numbers that nodes are listening on within the Docker network must be mapped to the same port numbers on the local machine.

If you want to change the port numbers then you need to change them on the actual nodes themselves, not just in your Docker network mappings.

It could mean that you used .align 32, and it was interpreted as .p2align (power-of-2) instead of .balign (byte).

Never use the ambiguous .align directive when targeting GAS, which supports unambiguous directives.

In your case, the alignment is coming in the 3rd arg to .comm to define a global variable in the BSS. Like .align, the interpretation is target-dependent, and when assembling for Windows, that means you're asking it to align by 2**32 (or 4GiB), which ld doesn't handle.

(When assembling for i386-elf-linux, it means align by 32, 2**5, which works as intended.)

As documented in the GAS manual:

When using ELF or (as a GNU extension) PE, the .comm directive takes an optional third argument. This is the desired alignment of the symbol, specified for ELF as a byte boundary (for example, an alignment of 16 means that the least significant 4 bits of the address should be zero), and for PE as a power of two (for example, an alignment of 5 means aligned to a 32-byte boundary).

The alignment must be an absolute expression, and it must be a power of two. If ld allocates uninitialized memory for the common symbol, it will use the alignment when placing the symbol.

If no alignment is specified, as will set the alignment to the largest power of two less than or equal to the size of the symbol, up to a maximum of 16 on ELF, or the default section alignment of 4 on PE

Unfortunately there's no portable unambiguous syntax way to use it. You could just omit that optional 3rd arg and use the default alignment.

Or you could instead use a .bss directive to switch to the BSS section and use .space to reserve space after a label:.

Or just don't use any global vars, and leave the result in st0. You don't need any to eval an expression, if you take args on the stack instead of globals. At most you could use stack space, if you run out of x87 registers. Or you could reference globals but leave the definitions up to other compilation units (e.g. a caller that does input/output.)

Also, does result really need to be 7360 bytes? Your compiler (https://flatassembler.github.io/compiler.html) only ever uses [result], not [result + reg] or + constant

My original interpretation was incorrect. Refer to @OznOg's answer below.

Modified Answer:

I created a simple benchmark that uses std::async and std::thread to do some tiny tasks:

pass a boolean isFinished and return it inside of response object. If your response object is already defined, create a wrapper that has the previous response dto and a boolean flag.

Also we did use a solution like this in one of our projects at work for a big company so I would say it is somewhat industry accepted way of doing it.

It automatically detects changes on make so that it then re-runs ./configure with all the options recalled and reused from the disk

Which seems to be a very good use case.

If you fixed something in the build system, and want to rebuild, chances are you want to keep all the options passed to configure when you last ran it.

the result of this operation isn't saved to the disk

This is not really true. ./config.status --recheck does run configure with the --no-create option, which says to "not create output files", but that's only half-true: It does update the config.status script itself.

Typically you do not run config.status manually, but it gets invoked automatically by make. And make will then typically also invoke the just updated config.status (without the --recheck flag), which in turn will update your Makefile. And then it will build the project using the updated Makefile.