fragile | Ruby Pipeline Framework | BPM library

You are missing an important point about race:

The observable to emit first is used

This means that if first emission of longActionObservable occurs before the timer, then timer is not used, regardless of how long the "expand" observable takes to complete.

no toArray because I do not need result

Even though you don't need the result, toArray actually makes this work as you wish because it will not allow any emissions until your "expand" observable completes. Instead of using toArray, you could use reduce instead:

Your approach does not work. The correct approach is this:

• Unless you are a performance expert (which is hard to become), do not make assumptions about what kind of code performs well vs. performs poorly, and maintain skepticism when analysing profiler reports. This is not particularly useful advice (it boils down to: A profiler report may be lying to you!), but it is what it is. Effectively, either be a performance expert, or accept that there's not much you can do about it. Sucks, but, don't shoot the messenger.
• Write idiomatic java code. It is easiest to maintain and most likely to get optimized by hotspot.
• Reduction of algorithmic complexity is useful and should always be the first thing you check. To some extent, an optimization that reduces algorithmic complexity gets to ignore the first rule. You do not need to be particularly up to date on the vagaries of JVMTI or Flight Recorder and how profilers work to conclude that an algorithmic rewrite is worthwhile and is going to significantly improve performance.
• do not trust pithy rules of thumb, no matter how many people are saying it. Do not look for 'easy to apply patterns' like 'replace all foreach loops by appending an if-block that tests for empty first' - these are essentially never correct and usually reduce performance.
• Be aware that bad performance advice is rampant. You should never treat ubiquitous presence of some argument otherwise bereft of proof or research as "that makes it more likely to be true" as a general principle in life and logical reasoning (it is, after all, a logical fallacy!), but this counts double for performance!

Presumably, you're not going to trust the above maxims just because I'm telling you to trust them. I'll try to take you through some falsifiable reasoning to show you why the above maxims are correct.

In particular, this idea of checking for empty first seems extremely misguided.

Let's first translate the overly hyperbolical and therefore rather useless well-known maxim premature optimization is the root of all evil into something more tangible:

Do not make your code an ugly, caveat-ridden mess of weirdness because of an imagined performance issue.

Do not go by "people" here. Because "people" are notorious for being utterly wrong on performance, time and time again. If you can find widespread, pithy and entirely bereft of proof or research statements that X is good or bad for performance, you can rest assured in the thought that this means absolutely nothing whatsoever. Your average joe twitter writter or whatnot is a clueless idiot in this regard. Proof, ample research, or credentials are an absolute requirement to take things seriously, preferably 2 or 3 of those. There are lists of well known performance falsehoods (commonly held beliefs about how to improve JVM performance that absolutely do not help whatsoever and often actually hurt), and if you then search for these falsehoods you can find entire hordes of folks who espouse it, thus proving that you just cannot trust anything based solely on the fact that you "keep hearing it".

Note also that for just about every imaginable line of java code, you can come up with 100+ plausible if somewhat exotic ideas on how to make the code less obvious but seemingly 'more performant'. Clearly then you can't apply all 100 variants to every line in the entire project, so the road you were planning on taking here ("I do not quite trust that profiler, I find it plausible escape analysis will fail to eliminate this iterator allocation, so, just to be safe I will add an if that checks for empty first"), ends in a disaster where even the simplest task becomes a many-lined, seemingly excessively redundant soup. And performance will be worse on average, so it's a lose-lose scenario.

Here's a simple example to drive the point home, and you can watch those presentations by Doug for more of this sort of thing:

Instead of monitoring you have the desired number of healthy targets, monitor that you have no unhealthy ones. Your ECS service will take care of managing your desired count, plus you might want to scale the service so UnHealthyHostCount is the better metric to alarm on, I think anyway.

Create one alarm for each target group as below.

These won't trigger between normal ECS blue/green deployments, only if there is a registered target failing health-checks. You need to tune the health-check settings on the target group and HealthCheckGracePeriodSeconds setting for the ECS service accordingly.

Posted an issue in the spring-security github repo.

According to the reply there is no better way to configure MethodSecurityInterceptor right now and they are making major changes in that part of the code so no point in improving anything right now.

So best way to configure MethodSecurityInterceptor is through a BeanPostProcessor like below:

Your media query syntax is wrong.

Instead of: @media screen only (min-width: 800 px) { ... }

Try: @media only screen and (min-width: 800px) { ... }

What was wrong:

1. Using screen only instead of only screen.
2. Not using the and keyword to join media rules (screen and min-width).
3. Using 800 px instead of 800px

You can use the addThemeVariants() method to define the variant you want to use:

You could use functools.lru_cache to memoize the result so the result of the method call is cached

Custom metrics for Automatic Device Management (ADM) deployments might help? https://docs.microsoft.com/azure/iot-hub/iot-hub-automatic-device-management#monitor-a-configuration

When you create a layered deployment for IoT Edge, you'll see a couple of pre-cooked custom metrics that you can use as a template.

ServiceStack treats structs like a single scalar value type, just like most of the core BCL Value Types (e.g. TimeSpan, DateTime, etc). Overloading the Parse() and ToString() methods and Struct's Constructor let you control the serialization/deserialization of custom structs.

Docs have been corrected. Structs use Parse whilst classes use ParseJson/ParseJsv

If you want to serialize a models properties I'd suggest you use a class instead as the behavior you're looking for is that of a POCO DTO.

If you want to have structs serailized as DTOs in your RDBMS an alternative you can try is to just use JSON.NET for the complex type serialization, e.g: