versions | small module for creating a flexible CDN application | Runtime Evironment library

Although they 'don't exist', can Format.ps1xml files be created/used in versions of PowerShell greater than 5.1?

• Yes; in fact any third-party code must use them to define custom formatting.

  • That *.ps1xml files are invariably needed for such definitions is unfortunate; GitHub issue #7845 asks for an in-memory, API-based alternative (which for type data already exists, via the Update-TypeData cmdlet).

• It is only the formatting data that ships with PowerShell that is now hardcoded into the PowerShell (Core) executable, presumably for performance reasons.

is there some better practice for suggesting to PowerShell how a certain function should format returned data?

The lack of an API-based way to define formatting data requires the following approach:

• Determine the full name of the .NET type(s) to which the formatting should apply.

  • If it is [pscustomobject] instances that the formatting should apply to, you need to (a) choose a unique (virtual) type name and (b) assign it to the [pscustomobject] instances via PowerShell's ETS (Extended Type System); e.g.:

    • For [pscustomobject] instances created by the Select-Object cmdlet:

Actually, there is nothing wrong with the YAML. The problem was a delay in the virtual machine loading the VHDX. In other words, wait about 5 minutes once the VHDX is mounted before trying to run the application. I am leaving this here in case anyone else runs into this issue.

While editing my initial question to add more context as Jay proposed I think it found the issue.

What probably happens? The view where the crash is, contains a table view. Each cell will be configured before being presented. I use a flag which holds the information, if the amount of weight for this cell (it is a strength workout app) has been initially set or is a change. When prepareForReuse is being called, this flag has not been reset. And that now means scrolling through the table view triggers a DB write for each reused cell, that leads to unnecessary writes to the db. Unnecessary, because the exact same number is already saved in the db.

My speculation: Scrolling fast could maybe lead to a race condition (I have read something about that issue with realm) and that maybe causes this weird crash, because there are multiple single writes initiated in a short time.

Solution: I now reset the flag on prepareForReuse to its initial value to prevent this misbehaviour.

The crash only happens when the cell is set up and the described behaviour happens. Therefor I'm quite confident I fixed the issue finally. Let's see. -- I was not able to reproduce the issue, but it also only happens pretty rare.

You have to provide both annotations as object in 1 array, not an array containing objects containing arrays, see example:

So for anyone interested what the problem was:

Since we are using a custom logger (ServiceLoggingInvocationHandler) which try catched the exceptions of an invoke method, the catched exceptions were already wrapped with an invocation exception and were not the original exceptions. To solve the problem we needed to unwrap the exceptions again before forwarding them.

Since the logger was only used in debugging mode and only when specified the problem was only occurring for me.

I would suggest you to use conda (Ananconda/Miniconda) to create a separate environment and install tensorflow-gpu, cudnn and cudatoolkit. Miniconda has a much smaller footprint than Anaconda. I would suggest you to install Miniconda if you do not have conda already.

You can install it from the CRAN github mirror (despite it being removed from CRAN), e.g.

• As per Adding plots to the basic mplfinance plot(), section Plotting multiple additional data sets
  • Aside from the example below, for two columns from a dataframe, the documentation shows a number of ways to configure an appropriate object for the addplot parameter.
  • apdict = [mpf.make_addplot(data['Upper Band']), mpf.make_addplot(data['Lower Band'])] works as well. Note it's a list, not a tuple.
• mplfinance/examples

You will not find this information in the documentation, because it is not a single feature per se, it is simply the compiler/optimizer working its way through the query in various phases, using a number of different techniques to get the best execution plan. Sometimes it can safely push through predicates, sometimes it can't.

Note that "expanding the view" is the wrong term here. The view is always expanded into its definition (NOEXPAND excepted). What you are referring to is called predicate pushdown.

I've assumed here that indexed views and NOEXPAND are not being used.

When you execute a query, the compiler starts by parsing and lexing the query into a basic execution plan. This is a very rough, unoptimized version which pretty much mirrors the query as written.

When there is a view in the query, the compiler will retrieve the view's pre-parsed execution tree and shoves it into the execution plan, again it is a very rough draft.

With derived tables, CTEs, correlated and non-correlated subqueries, as well as inline TVFs, the same thing happens, except that parsing is needed also.

After this point, you can assume that a view may as well have been written as a CTE, it makes no difference.

The compiler has a number of tricks up its sleeve, and predicate pushdown is one of them, as is simplifying views.

The ability of the compiler here is mainly dependent on whether it can deduce that a simplification is permitted, not that it is possible.

For example, this query