## domain name system – SPF DNS void lookup limit exceeded

while testing my DKIM/SPF config by using the port25.com email service, I am getting the following reply for my SPF record:

permerror (DNS void lookup limit exceeded)

However, my spf record does not have any “include”:

v=spf1 mx a ip4:IP1 ip4:IP2 ip6:IP3 ~all

any idea what is going on?

When I am using https://dkimvalidator.com/results, I get a pass on the SPF.

I have checked the docs at https://mxtoolbox.com/problem/spf/spf-void-lookups and found this here:

“The void lookup limit was introduced in RFC 7208 and refers to DNS lookups which either return an empty response (NOERROR with no answers) or an NXDOMAIN response.”

It’s not doing ant DNS lookups, or is it?

## Is there a limit to number of CSOM requests in SharePoint online for Throttling

But it does not specify the exact number of requests that can be made with one account over a period of time, say one hour.

## Is there any better alternative to limit or stop order in crypto exchanges?

I have somewhat understood both limit and stop orders at some exchanges, even executed some similar order types but I am still looking a way to execute an order based on target volume of a coin (say to buy)…for eg.

I wish to buy a volume (say 100) coin B by selling coin A (both are highly volatile) now in limit order I can set to sell A at certain price so that it results in 100 B OR trigger it to sell at price point as in stop-limit (not much of a use here).

But this sometimes take time to fill the order…I wish to buy 100 B if either B goes down or A goes up so that the volume purchased remains at 100 B irrespective of ups and downs of both the coins…

Is this possible in any exchange by combining orders or by using a new order type introduced in any of the exchanges?

## Evaluation of a trignometric limit without l’hopital rule

Lim x–> 0 ((Sin(3x)-4*sin(2x)+5sinx))/(x^5)

How do you evaluate this limit without using l’hopital a tiring 5 times?

## Transaction size limit across a single path in a Lightning Network and fee earned

Given MPP is included in the current version of lnd, an arbitrarily large transaction can be processed in the network. What is the transaction size limit across a single path? Is it still bounded to 0.0429 BTC (limited by max_concurrent_htlc)? What is the estimated fee earned (average as well as maximum) by a lightning node per day?

## calculus and analysis – question on correct use of Limit for multivariable function

V 12.1 on windows.

This limit $$lim_{(x rightarrow 0,yrightarrow 0)} frac{x^2-y^2}{x^2+y^2}$$ depends on the direction. So the limit does not exist, or could be written as Maple does it, which is $$-1dots1$$, here is the help from Maple on this:

How can one get Mathematica to give this result? Now Mathematica says the limit is $$1$$. I tried the `Direction` option but not able to make it change its mind.

``````f = (x^2 - y^2)/(x^2 + y^2);
Limit(f, {x -> 0, y -> 0})
(* 1 *)
``````

But we see the limit depends on the direction

`````` Limit(Limit(f, x -> 0), y -> 0)
(* -1 *)

Limit(Limit(f, y -> 0), x -> 0)
(*  1 *)
``````

Here is also Maple to confirm

``````restart;
f:=(x^2-y^2)/(x^2+y^2);
limit(f, (x=0,y=0));
``````

Btw, this is not the only one I found, here is another

``````f = (x^2*y^2)/(x^4 + y^4);
Limit(f, {x -> 0, y -> 0})
(* 0 *)
``````

Maple gives

``````restart;
f:=x^2*y^2/(x^4+y^4);
limit(f,(y=0,x=0))
(* 0 .. 1/2 *)
``````

And another one (this one is from youtube actually, so you can see they also say there the limit does not exist)

``````f = (x^4 - 4 y^2)/(x^2 + 2 y^2);
Limit(f, {x -> 0, y -> 0})
(* 0 *)

restart;
f:=(x^4-4*y^2)/(x^2+2*y^2);
limit(f, (x=0,y=0));
(* -2 .. 0 *)
``````

So I have feeling I am not using Limit in Mathematica correctly, or missing something about its correct use, but do not now know how to correct it. As I said, I tried different `Direction` option.

## modules – Is \$frac{bigcap_{k=1}^infty M_k}{bigcup_{k=1}^infty N_k}\$ a direct limit?

Suppose we have a sequence of $$R$$-modules $$N_1subseteq N_2subseteqcdots subseteq N_ksubseteq N_{k+1}subseteq cdotssubseteq M_{k+1}subseteq M_ksubseteq cdotssubseteq M_2subseteq M_1.$$

My question is is it possible to make the following set $$bigg{P_k:=frac{M_k}{N_k}bigg|kgeq 1bigg}$$ with some $$R$$-modules homomorphsims to a directed set so that $$frac{bigcap_{k=1}^infty M_k}{bigcup_{k=1}^infty N_k}$$ is direct limit.

Of course, if all $$M_k$$ are equals to some fixed $$M$$, then for $$i,jin Bbb N$$ with $$ileq j (text{ordering w.r.t. natural order of }Bbb N)$$ we have a $$R$$-module homomorphism $$varphi^i_j:P_ilongrightarrow P_j$$ defined by $$varphi^i_j:x+N_ilongmapsto x+N_jtext{ for all }xin M.$$ And in this case, $$frac{bigcap_{k=1}^infty M_k}{bigcup_{k=1}^infty N_k}=frac{M}{bigcup_{k=1}^infty N_k}$$ is obviously the direct limit of $${P_i,varphi^i_j|ileq j}$$.

Any help will be appreciated.

## performance – Rate limit a method by generating particular load on demand in C#

I am working on a project where I want to generate random throughput on a particular method so that I can do some performance testing on it. This way I can test my method by generating random throughputs and see how my method works under all those scenarios.

For example: I need to call my `doIOStuff` method at an approximate rate of `x requests per second` from multiple threads where x will be less than `2000` mostly but it really doesn’t matter in this case. It doesn’t have to be accurate so there is some room for an error but the overall idea is I need to make sure that my method `doIOStuff` is executed no more than x times in a sliding window of y seconds.

Assuming we start `n threads` and want a maximum of `m calls per second`. We can achieve this by having each thread generate a random number between 0 and 1, k times per second and call `doIOStuff` method only if the generated number is less than m / n / k.

Below is the code I got which uses global variables and it does the job but I think it can be improved a lot where I can use some cancellation tokens as well and make it more efficient and clean.

``````using System;
using System.Collections.Generic;

namespace ConsoleApp
{
class Program
{
const int n_throughput = 2000;
const int k_toss_per_second = 2000; // Note that k_toss_per_second x  m_threads >= n_throughput

static void Main(string() args)
{

for (int i = 0; i < m_threads; i++)

}

static void callDoIOStuff()
{
int sleep_time = (int) (1000 * 1.0d / k_toss_per_second);
double threshold = (double) n_throughput / m_threads / k_toss_per_second;
Random random = new Random();
while (true) {
if (random.NextDouble() < threshold)
doIOStuff();
}
}

static void doIOStuff()
{
// do some IO work
}
}
}
``````

I wanted to see what can we do here to make it more efficient and clean so that it can used in production testing for generating random throughput load.

## Design of a single microservice, size limit?

I’ve been struggling for a while of what would be the “recommended” approach for a microservice itself.

There are quite of top architecture designs that are the holy sacred for a lot of craftsman devs, such as CQRS, Hexagonal, DDD, etc…

But from my point of view, depending of how “big” is the microservice, because you know the word itself it’s giving you a hint… “micro”!!

Should I consider build all the packages, interfaces, divisions between layers such as Hexagonal, or split the content of the microservice based on DDD (its supposed that 1 microservice its 1 domain??? if not… 😐 kind of WTF??)

Or just keep it on its essence like split the entrypoints(rest,queues)-core(business logic)-outpoints(DB,queues, or whatever) and let it open for a “little” extension.

If its too big, think on a split? In order to avoid “minimonolits” and what would be the limit to consider an “app”/API a microservice or a little monolit?

Maybe to be more clear.

i.e:

``````Microservice/API
├── Product
│   └── DDD/CQRS/Hexagonal stuff
|       └── ....
├── Sells
│   └── DDD/CQRS/Hexagonal stuff
|       └── ....
└── Customer
└── DDD/CQRS/Hexagonal stuff
└── ....
``````

Microservice with basic crud -> Product-Sells-Customer(with patterns such as CQRS, Hexagonal, etc…?) -> Its a minimonolit for me.

The kind of what I look forward…

``````Gateway microservice
├── Product
│   └── routing stuff
|       └── ....
├── Sells
│   └── routing stuff
|       └── ....
└── Customer
└── routing stuff
└── ....
``````

Product

``````Product Microservice
├── Product
└── Basic separation layer(REST/SERVICE/ORM-QUEUE)
└── ....
``````

Sells

``````Sells Microservice
├── Sells
└── Basic separation layer(REST/SERVICE/ORM-QUEUE)
└── ....
``````

Customer

``````Customer Microservice
├── Customer
└── Basic separation layer(REST/SERVICE/ORM-QUEUE)
└── ....
``````

The previous ones should have patterns such as CQRS, Hexagonal, etc…???