idIOTic | Simple ways to 0wn simple IOT devices

You could convert your date column to datetime, and then use pd.Grouper with groupby, as per below:

You need to run the code from each page individually with some kind of loop. Write a function.

The trick to this is to define a protocol, an extension of that protocol, and put the makeHolder method in that extension. That way, you can use Self as the generic type for the returned ControlHolder.

First define a new protocol (let's call it "HoldableControl") and require that conformers must be UIControls. It doesn't need any other requirements because we just care about adding the makeHolder function to an extension.

Figured out a solution myself, I wrapped double in a class, and then used an attribute to make the actual value an XML Attribute. Might not be the most elegant:

If you use IO.inspect instead of IO.puts, you can see what's going on:

You can host your WebApi application in IIS, so you don't need to run it with Visual Studio.

If you are developing another project, you can ask Visual Studio to run multiple projects during a debugging session. While debuging your unity application, Visual Studio will run your API in the background: https://docs.microsoft.com/en-us/visualstudio/ide/how-to-set-multiple-startup-projects?view=vs-2019

Otherwise, you may self host your asp.net webapi application. There are official Microsoft tutorials on that:

• For WebAPI 1: https://docs.microsoft.com/en-us/aspnet/web-api/overview/older-versions/self-host-a-web-api
• For WebAPI 2: https://docs.microsoft.com/en-us/aspnet/web-api/overview/hosting-aspnet-web-api/use-owin-to-self-host-web-api

You can use useEffect with your input values as dependencies in the following form:

• Prime number list not including 2. (isprime function is wrong)
• You are calling primes function again and again. Not neccessary
• When you divide b/prime it is returning float
• You are appending b in prime factor list Lst instead of prime

Is Task parallel library, PLINQ or Concurrent Collections used in Web Applications built with Asp.Net core MVC or Razor Pages??

The short answer is: No for PLINQ & multi-threading.

First, async/await are wrapped around Task class, which is part of TPL.

Second, it's considered bad practice doing parallelism and spin multiple worker threads in an ASP.NET (Core) application.

In ASP.NET Core you use TPL and async/await for truely async operation (network calls, I/O access (file access), database calls etc), where the application has to wait on an external hardware component to finish.

CPU bound tasks (calculations etc. running on one or multiple threads) arern't awaited in ASP.NET Core applications and just done on the main thread (in a "blocking" fashion).

ASP.NET (the legacy one) used to have its own thread pool for managing connections and ASP.NET Core just uses the default thread-pool for it. In legacy ASP.NET you would still have single thread exection per request, even if you use PLINQ fire off multiple tasks and await them. ASP.NET Core wouldn't.

Still, spinnig off your own tasks and threads is a bad idea. It may make your single threaded operation faster when having low number of requests (lower latency), but may make it unresponsible in high-request scenarios due to thread starvation and your application spending a lot of CPU time managing and switching between threads. It also interferes with the thread heuristics.

Also on thread starvation, your application won't accept any new requests. For that reasons CPU bound tasks are meant to be run syncronously. Running an CPU bound work via Task.Run alone gains you nothing. You free up the request thread while waiting for the task to finish, but since you spin up a new task, another thread is used to process it.

Its similar to when running parallel task. When you run to many per request, there is one point where you have to many tasks queued and to many requests and application stops accepting requests and the user get the dreaded "50x" http errors for your application not accepting new requests where as not spinning up many parallel tasks would allow you to take a much higher number of connections and queue them while the other tasks requests complete

Concurrency and parallel tasks are important for Desktop applications and awaiting them there makes sense (to not block the UI thread), even if its a single lengthy execution. Also, in a Desktop application you can be certain, that the application is only used by a single user, so using up as many CPU cores as possible to process a task quickly is a very good thing.

It just doesn't translate well, when you apply this to a sharerd application such as an ASP.NET Core application where an unknown numbers of users will interact with it.