warrant | With support for SRP | AWS library

You are storing the price in your selection state.

You should instead store the selection by the id (which will be unique).

That way you can always find the item in your phones/inventory array by id and then get any of the properties (manufact, item, price, desc, avail).

You should stop trying to invent the wheel, and instead start to leverage the built-in capabilities of Azure Databricks. Because Apache Spark (and Databricks) is the distributed system, machine learning on it should be also distributed. There are two approaches to that:

1. Training algorithm is implemented in the distributed fashion - there is a number of such algorithms packaged into Apache Spark and included into Databricks Runtimes

2. Use machine learning implementations designed to run on a single node, but train multiple models in parallel - that what typically happens during hyper-parameters optimization. And what is you're trying to do

Databricks runtime for machine learning includes the Hyperopt library that is designed for the efficient finding of best hyper-parameters without trying all combinations of the parameters, that allows to find them faster. It also include the SparkTrials API that is designed to parallelize computations for single-machine ML models such as scikit-learn. Documentation includes a number of examples of using that library with single-node ML algorithms, that you can use as a base for your work - for example, here is an example for scikit-learn.

P.S. When you're running the code with multiprocessing, then the code is executed only on the driver node, and the rest of the cluster isn't utilized at all.

The compiler can decide to implement references as pointers, or inlining or any other method it chooses to use. In terms of performance, it's irrelevant. The compiler can and will do whatever it wants to when it comes to optimization. The compiler can implement your reference as a pass-by-value if it wants to (and if it's valid to do so in the specific situation). Caching the result won't help because the compiler will do that anyways. If you want to explicitly tell the compiler that the value might change (because of another thread that has access to the same pointer), you need to use the keyword volatile (or std::atomic if you're not already using a std::mutex).
Edit: The keyword "volatile" is never required for multithreading. std::mutex is enough.
If you don't use the keyword volatile, the compiler will almost certainly cache the result for you (if appropriate). There are, however, at least 2 actual differences in the rules between pointers and references.

1. Taking the address (pointer) of a temporary value (rvalue) is undefined behavior in C++.
2. References are immutable, sometimes need to be wrapped in std::ref.

Here I'll provide examples for both differences.

This code using references is valid:

Method 1 out of the options given is best.

None of them would fail WCAG as such.

However as you have pointed out 2 and 3 result in duplication of effort for keyboard users and links to the same location having different names, which is not a fail under any success criterion but is highly recommended.

Yes in scenario 1 and 4.

All 4 of the examples given would "pass" WCAG. However they offer very different experiences.

So the question is what things are we considering for accessibility?

The first is Keyboard operability. Examples 2 and 3, as you pointed out result in duplication of focus stops for the same item. So we should avoid them.

The second thing is link purpose. Yet again examples 2 and 3 are not great here as we have 2 links to the same place on the same page that have different accessible labels / text that assistive tech will use.

So we can rule out options 2 and 3 for best practices.

So what about options 1 and 4?

Well as the items are located within a hyperlink we want the link text (the accessible name for those links) to be descriptive of the product page we are going to visit.

As such option one would read: "link: Squeaky Fox Dog Toy" and the second link would read "link: (image) Red fox stuffed dog toy with white braided rope arms, Squeaky Fox Dog Toy"

The second option results in duplication of information so is not as desirable as the first option.

So we land on option 1.

The only consideration you now have is whether that link text describes the product sufficiently. Now if you sold multiple dog toys (different product types) then you need text that describes them as such i.e. "plastic dog toys" and "fluffy dog toys".

If you sell different coloured products and they all had their own page (so you don't have a colour picker on the end page, they are listed as separate items) then you would need to describe the colour there too. "Red fluffy dog toy", "blue fluffy dog toy".

Essentially you need to provide enough information that each product link is easily identifiable as to where it leads (the purpose of the link itself).

This is where judgement comes into play, provide enough information to describe the product generally in a unique way on the page, not so much information that browsing that page becomes problematic due to 100 products with 200 word link text.

So in the example given the "balance" would be something like "Red fox stuffed dog toy", and then describe the appearance in far more detail on the product page, wither in the description or in the product image alt attributes.

It is worth noting that the last option for a product page is no text at all. Just an image inside a link. The following is also valid HTML and accessible as the alt text will be used as the link text (not if an image contains any text at all that should all appear in the alt attribute).

With o365 you can use

I think the columns 'ticker' and 'date' present in both DataFrames are causing both the 'ticker' and 'date' columns to become multidimensional when you concatenate the DataFrames together.

When I run your original code, this is what var['ticker'] looks like (and var['date'] looks similar):

What type of data do you have? It looks like the columns metricA / metricB are of type object, and pandas performs slow summation for Python objects rather than fast summation for numpy arrays. Try to convert metric columns to float64 or integer type.

You can inspect data types using df.info() method.

Proof:

What you want is a custom Load Shape. You define what you want Locust do at any given moment in code. Example from the docs:

Since you are using create-react-app for this, there's no need to eject the webpack.config.js (since this is irreversible, I hope you have a git commit you can revert). So here's the general gist:

• You create a file called chatLoader.js outside of your react project (if you don't intend to learn how to configure this in the same webpack config, which might get a little tricky) and add babel transpilation and minification by yourself.
• This file contains something like (untested)