gory | Think factory_girl | Wrapper library

In 64-bit mode, the actual contents of the 16-bit FS and GS segment registers are essentially irrelevant. Instead, there are separate 64-bit "FSBASE" and "GSBASE" registers within the CPU, and when you specify, say, an FS segment override to an instruction, the base address from the FSBASE register is added to the operand's effective address to determine the actual linear address to be accessed.

The kernel's context structure for each thread stores a copy of its FSBASE and GSBASE registers, and they are reloaded appropriately on each context switch.

So what actually happens is that each thread sets its FSBASE register to point to its own thread-local storage. (Depending on the CPU features and OS design, this may only be possible for privileged code, so a system call may be required.) Then instructions with an FS segment override can be used to access an object with a given offset in the thread-local storage block, as you've seen.

In 32-bit mode, on the other hand, the values in FS and GS do have meaning; they are segment selectors which are used to index into a descriptor table maintained by the kernel. The descriptor table holds the actual segment info, including its base address, and you could use a system call to ask the kernel to modify it. Each thread would have its own local descriptor table, so you wouldn't necessarily see different selectors in FS for different threads, but it would still be the case that FS-override instructions from different threads would result in accesses to different linear addresses.

tag doesn't include the name attribute.

You have to name your tag and use its value : Cat gories Canap s Lits

From the documentation available at https://docs.oracle.com/javafx/2/deployment/self-contained-packaging.htm

in section 6.2 it states

Package per target platform Self-contained application packages are platform specific and can only be produced for the same system that you build on. If you want to deliver self-contained application packages on Windows, Linux and Mac you will have to build your project on all three platforms.

As you can see from your .bat excerpt, the JavaFX modules are platform specific, indicating 'linux'

I have never personally leveraged gradle to build multiple platforms but I believe there are some answers on here who have, check this one I quickly found https://stackoverflow.com/a/53760018/3625077

Short of building in Windows native or via VM, you can possibly open a new question and post your build.gradle file and the community could help you sort this out

So, you are never returning the file to the browser. One way to accomplish this is to use System.IO.FileStream and FileStreamResult.

This should get you started:

You will need to create an installable trigger for onMyEdit function. The dialog will help you to design you email by giving you an html format to display it. When you're ready just comment out the dialog and remove the // from in front of the GmailApp.sendEdmail() line.

A far better approach is to create the separate documents from the outset. By adding the following macro to your mailmerge main document, you can generate one output file per record. Files are saved to the same folder as the mailmerge main document, using the 'Date' field in the data source for the filenames. PDF & DOCX output formats are catered for. Do be aware that, should your data source have duplicate dates, only the last one processed will survive.

The method Evaluate takes quite some time because it must call the algorithm method that is passed in many times. The algorithm method is not async.

The Evaluate method works by timing execution. Since "asynchronous" usually means I/O, and since I/O is orders of magnitude slower than CPU execution (the actual algorithm being measured), I do not believe an asynchronous overload would be useful.

I could certainly put the entire loop where algorithm is called inside a Task and await the Task but various articles suggested this is a poor idea

A naturally-synchronous method should be synchronous. It doesn't matter how long it takes to run.

If Evaluate is run by a UI application, and it wants to keep its UI responsive, it can call the Evaluate method wrapped in a Task.Run.

The reason is: type List_Item is private (in plain English from the Ada code)!

This means the author of package Linked_List doesn't want its users to make use of its details (that it is a record with two components). In a more complex software, it is useful to hide those details since they are subject to change and users would run into trouble if they used details (in this case, the composite type) that would become incompatible after a design change in the type List_Item. There are two solutions:

1. Make List_Item public (usually a bad solution if you want to build "real" software)
2. Add Null_List : constant List_Item; after type List_Item is private and Null_List : constant List_Item := (null, 0); in the private part. Then you can use Null_List in your main.adb.

Heroku support are saying that the problem here is using npm with the asset pipeline and the better approach would be to use webpacker