timer2 | timer2 is an evented timer | Date Time Utils library

Don't try and run timers in a synchronous queue. That's silly.

It looks like all your timers fire every second, and always invoke the same target. So just have one timer that runs constantly. It will be a "check the state of the current exercise" timer.

Have a var hold an array of Doubles that indicates the number of seconds for each exercise. Better yet, have an array of structs representing exercises.

When the user starts an exercise, remove its struct from the array and save it in a variable currentExercise.

When the user begins a specific exercise, also compute an exerciseCompletedTime TimeInterval.

Each time your once-a-second timer fire, see if the current time is ≥ exerciseCompletedTime. If it is, mark that exercise as completed, remove the next exercise struct from the array of exercises, set that one up as the current exercise, and compute a new exerciseCompletedTime.

To save something in Local Storage you can use localStorage.setItem(key, value)
To get something from Local Storage you can use localStorage.getItem(key, value)

You could plus DateTime.Now with User Input Time.

Its not a breaking error, just means that some functionalities might not work as expected. As this npm WARN EBADENGINE required: { node: '>=0.8 <=9' } line shows, the required node version for this package to work as intended is between 0.8 and 9 but you have node 16.

The behavior has slightly changed from Qt5 to 6, but in both cases the documentation already suggests the solution:

Warning: If the value of the Qt property changes after the style sheet has been set, it might be necessary to force a style sheet recomputation. One way to achieve this is to unset the style sheet and set it again.

This is the proper way to achieve this in Qt5 too, by the way, as it ensures that the stylesheet is properly [re]propagated to children widgets, and automatically causes repolishing anyway.

Since stylesheets are cascading, there's not an automatic way to know the origin of the style change.

In your case, this can be enough:

What you want is called "micro-benchmarking". It can get very complex. I assume you are using Ubuntu Linux on x86_64. This is not valid form ARM, ARM64 or any other platforms.

std::chrono is implemented at libstdc++ (gcc) and libc++ (clang) on Linux as simply a thin wrapper around the GLIBC, the C library, which does all the heavy lifting. If you look at std::chrono::steady_clock::now() you will see calls to clock_gettime().

clock_gettime() is a VDSO, ie it is kernel code that runs in userspace. It should be very fast but it might be that from time to time it has to do some housekeeping and take a long time every n-th call. So I would not recommend for microbenchmarking.

Almost every platform has a cycle counter and x86 has the assembly instruction rdtsc. This instruction can be inserted in your code by crafting asm calls or by using the compiler-specific builtins __builtin_ia32_rdtsc() or __rdtsc().

These calls will return a 64-bit integer representing the number of clocks since the machine power up. rdtsc is not immediate but fast, it will take roughly 15-40 cycles to complete.

It is not guaranteed in all platforms that this counter will be the same for each core so beware when the process gets moved from core to core. In modern systems this should not be a problem though.

Another problem with rdtsc is that compilers will often reorder instructions if they find they don't have side effects and unfortunately rdtsc is one of them. So you have to use fake barriers around these counter reads if you see that the compiler is playing tricks on you - look at the generated assembly.

Also a big problem is cpu out of order execution itself. Not only the compiler can change the order of execution but the cpu can as well. Since the x86 486 the Intel CPUs are pipelined so several instructions can be executed at the same time - roughly speaking. So you might end up measuring spurious execution.

I recommend you to get familiar with the quantum-like problems of micro-benchmarking. It is not straightforward.

Notice that rdtsc() will return the number of cycles. You have to convert to nanoseconds using the timestamp counter frequency.

Here is one example:

It is a problem of the Arduino core Stream class's find method. The type of the parameter should be const char* but it is char*.

Cast the parameter to char* to indicate to the compiler that it is OK.

I agree with Paul about the fact that this should likely all be pulled out into an observable model object. I'd make that model hold an arbitrary list of timers, and the index of the currently active timer. (I'll give an example of that at the end.)

But it's still worth exploring how you would make this work.

First, SwiftUI Views are not the actual view on the screen like in UIKit. They are descriptions of the view on the screen. They're data. They can be copied and destroyed at any time. So they're readonly objects. The way you keep track of their writable state is through @State properties (or similar things like @Binding, @StateObject, @ObservedObject and the like). So your properties need to be marked @State.

You are using a System.Threading.Timer that I would assume triggers your reading code. The problem is that this timer runs on a background thread, and you are updating the UI from this thread. This is not allowed and can lead to all sorts of problems. UI-objects are only allowed to be changed from the UI thread.

The solution would be to either use something like a winforms timer to run the read-code on the UI thread, or to post the UI-update part to the main thread, using for example Control.BeginInvoke.