usability | Actual version of this plugin is here http : //rmplus | Plugin library

As I started to dig into this, I realized that I needed to measure the performance of different scenarios in order to have any confidence in my understanding of the performance aspects of the sx prop.

I believe that the performance information in the MUI documentation was gathered using some variation of this repository: https://github.com/mnajdova/react-native-web. The react-native-web repo was used as a starting point because of its "benchmarks" package which contains a useful framework for measuring the performance of different React element rendering/styling approaches.

I created my own version here: https://github.com/ryancogswell/mui-style-benchmarks. You can use this as a starting point to dig into this further. Below are the measurements I made and my conclusions.

My Results for the "Mount deep tree" Benchmark

This test renders 639 elements with approximately 17 CSS properties each except for the cases ("..._minimal", "..._medium") which reduce the number of CSS properties to show the performance impact.

Styling Implementation Time in ms Implementation Desc inline-styles 22.78 No styling engine, just use style prop mui_sx_full 36.89 MUI Box sx prop with 17 CSS properties mui_sx_medium 24.09 MUI Box sx prop with 9 CSS properties mui_sx_minimal 18.15 MUI Box sx prop with 4 CSS properties mui_styled_box 22.38 MUI styled MUI Box with 17 CSS properties mui_styled_box_minimal 17.90 MUI styled MUI Box with 4 CSS properties tss_react_makestyles 17.10 makeStyles from tss-react with 17 CSS properties mui_styled 16.93 MUI styled div with 17 CSS properties mui_styled_minimal 13.77 MUI styled div with 4 CSS properties emotion_styled 16.69 Emotion styled div with 17 CSS properties emotion_styled_minimal 12.76 Emotion styled div with 4 CSS properties emotion_css 12.58 Emotion css div with 17 CSS properties Conclusions

• MUI styled (e.g. import {styled} from '@mui/material/styles') only adds a small amount of overhead to Emotion's styled.
• tss-react performs similarly to MUI styled.
• Emotion styled, Emotion css, MUI styled, and the MUI sx prop are all more expensive when there are more CSS properties passed to the styling engine.
• The performance of the sx prop degrades more quickly than the styled API as more CSS properties are passed to it. With 17 CSS properties the performance is much worse than the styled API (2x).
• The sx prop performs just fine for a small number (e.g. < 5) of CSS properties. Particularly, if you are already using a MUI component in a given situation, there is no meaningful performance difference between wrapping it with styled or using the sx prop if you are just using a small number of CSS properties.

What is the cause of the sx prop slowness?

Is it a whole different styling engine or something?

It is not a different styling engine. The output of the work done for the sx prop is fed into the styled API of the main styling engine (e.g. Emotion or styled-components); so using the sx prop with the Box component is guaranteed to be slower than the equivalent styles using styled on a div because the sx prop still uses styled in the end but does additional work first.

What is the additional work done by the sx prop?

• The MUI styled API calls styleFunctionSx in order to transform the CSS properties in the sx prop to the form expected by the styling engine.
• styleFunctionSx traverses all the CSS properties in the sx prop
• For each CSS property, it checks to see if it has a style function for transforming the prop value. These style functions provide support for shorthand notation for some properties such as padding and margin and support for using theme spacing units instead of pixel values.
• Each of the style functions leverages the style function in https://github.com/mui/material-ui/blob/v5.5.3/packages/mui-system/src/style.js to handle some common transformations of prop values including the support for breakpoint-specific values.

The net effect is that for each CSS property there are a number of lookups and function calls to see if the CSS property needs to be transformed even in the cases where the value passes through without changes.

I'm curious about the possibility of optimising it, or coming up with a compromise that retains most of the usability but omits whatever feature is causing the slowdown.

I'm sure that performance improvements are possible for the sx prop, but I don't think there is any single silver bullet for easily making it faster. Instead it will probably require a large number of little changes that are each barely measurable, but cumulatively provide decent improvement. The challenge is to make those changes without simultaneously making the code more complex and/or harder to maintain and/or more error prone.

The main compromise that "retains most of the usability" is to use Emotion's css prop directly. It can be used directly on elements in a similar fashion as the sx prop -- you just lose the shorthand notations and theme lookups that the sx prop provides. The theme lookups (e.g. for colors or spacing units) are easy to get directly from the theme by using the useTheme hook in the component. The theme.breakpoints API can be used instead of the breakpoint shorthands; though the sx breakpoint features are much nicer from a DX standpoint.

Yes, it's possible by using an older API version 1.2. You need to create an execution context with /api/1.2/contexts/create API (it requires cluster ID and what language is used), and then you can submit code using the /api/1.2/commands/execute API, and get command execution status using /api/1.2/commands/status API. Please note that you need to keep context to execute multiple commands depending on each other...

You can find an example of such execution using the Go language in the source code of Databricks Terraform provider

December 10,2021.
I'm using vscode with ubuntu 20.04.
I came across the XHR errors from yesterday and could not install any extensions.
Googled a lot but nothing works.
Eventually I downloaded and installed the newest version of VSCode(deb version) and everything is fine now. (I don't know why but maybe you can give it a try! Good Luck!)

If you see errors about a specific library missing, you can use dnf itself to find out the name. For example, on Fedora 35:

In your very first setup, .Values.config is a string. The key: |- syntax creates a YAML block scalar that contains an indented text block that happens to be JSON. helm install --set-file also sets a value to a string, and .Files.Get returns a string.

All of these things being strings means you can simplify the logic around them. For example, consider the Helm default template function: if its parameter is an empty string, it is logically false, and so default falls back to its default value.

In your final layout you want to keep the default configuration in a separate file, but use it only if an override configuration isn't provided. So you can go with an approach where:

1. In values.yaml, config is an empty string. (null or just not defining it at all will also work for this setup.)

Finally I solved that issue. I found that GitKraken is based on EletronJS which has some auxAttributes for GPU. These attributes can be altered via command line given that they are enabled via app.commandLine.appendSwitch command in the gitkraken EletronJS application. All these additional EletronJS related parameters are hidden from the command line parameters documented via /usr/share/gitkraken/gitkraken -h.

So the solution was for me to start GitKraken from command line using the ElectronJS attribute "InProcessGpu", which basically run the GPU process as a thread. To enable that feature simple start gitkraken wiht the attribute --in-process-gpu, e.g.

Some browsers won't allow the focus to be moved to an element if it's not an interactive element. In the blue box, you have an

, which is not natively focusable. In the red box, you have a , which is focusable.

To get around it, add tabindex="-1" to the

.

This will allow the focus to be moved to a non-interactive element via JS but won't allow the user to tab to it.

Now, having said that, in general you should not move the user's focus unless there's a really good reason for it. You mentioned you wanted to do it for a

"better experience from a usability point of view"

As a keyboard only user, I would find that a worse experience. If I'm a new user to the app and I wanted to explore the LHS menu to see what's available, I would tab to the menu, press enter or space to select the menu, then see what appears on the right. I'd then want to tab to the next menu item and select it to see what appears, but you moved my focus over to the right so now I have to shift+tab all the way back up to the menu. If I were using a sip-and-puff device or another assistive technology instead of a keyboard, that's going to be a lot of effort.

So your intention is good but it might cause a lot of difficulty for some users. That's why I recommend not moving the user's focus unless there's a really, really good reason for it.

Of course the opposite argument can be made. If the focus is not moved then the sip-and-puff user will have to navigate all the way over to the right side to interact with what appears.

You have to do some research to see what might benefit the most users without adversely affecting other users.

I see 2 options.

1. Write my own Appender in case i really need this display pattern in a timely manner.
2. as llompalles mentioned i give it a try with a GitHub Issue

Meanwhile I found a (temporary?) solution, to call again the click event of the button, this way the button is back in "released" mode. Here's (for one button) the code: