curious | A curio/trio-based library for the Discord API | REST library

When in doubt, JLS will help:

If two methods of a class (whether both declared in the same class, or both inherited by a class, or one declared and one inherited) have the same name but signatures that are not override-equivalent, then the method name is said to be overloaded.

So it's not "changing the parameters", it is about not override-equivalent. To find out what that is, you go to another chapter, that says:

Two method signatures m1 and m2 are override-equivalent iff either m1 is a subsignature of m2 or m2 is a subsignature of m1.

And the same chapter explains what subsignature is:

The signature of a method m1 is a subsignature of the signature of a method m2 if either:

• m2 has the same signature as m1, or

• the signature of m1 is the same as the erasure (§4.6) of the signature of m2.

How you interpret your above methods is an exercise left to you.

%s - stands for "The number of seconds since 1970-01-01 00:00:00 UTC", but looks like you've got microseconds instead. Try this: parse_timestamp("%s", left(created_date, 10))

Try running these 2 scripts in two different tabs with app.snowflake.com:

Script 1:

There are concrete efficiency losses because of the inefficient use of threads. Each thread requires at least 1 MB for its stack, so the more threads that are created in order to do nothing, the more memory is allocated for unproductive purposes.

It is also possible for concrete performance losses to appear, in case the demand for threads surpasses the ThreadPool availability. In this case the ThreadPool becomes saturated, and new threads are injected in the pool in a conservative (slow) rate. So the tasks you create and Start will not start immediately, but instead they will be entered in an internal queue, waiting for a free thread, either one that completed some previous work, or an new injected one.

Regarding your concerns about creating busy waiting procedures, no, that's not what happening. A sleeping thread does not consume CPU resources.

As a side note, creating cold Tasks using the Task constructor is an advanced technique that's only used in special occasions. The common way of creating delegate-based tasks is through the convenient Task.Run method, that returns hot (already started) tasks.

A simple way to fix this would be to deduce the non-type template parameter for the function, and reorder the template parameter list

Vim is the god of editors.

Practical Vim Edit Text at the Speed of Thought.pdf

You are modifying the local value x in not isChange this function:

If you specify the width of a div as a percentage, it refers to the percentage of the divs parent's computed width, when you specify viewport it refers to percentage of the window screen. Pixels on other-hand are absolute unit they are not relative like percentage. That is the primary reason percentage acts differently with flexbox and not just flexbox but with everything. See some of this articles for reference: https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Values_and_Units https://developer.mozilla.org/en-US/docs/Web/CSS/percentage

This question is really too big for Stack Overflow.

But one way of answering it is to say that if you can mechanically translate some variant of λ-calculus into some other language, then you can reduce the question of how you might compile λ-calculus to asking how do you turn that substrate language into machine language for some physical machine: how do you compile that substrate language, in other words. That should give an initial hint as to why this question is too big.

Fortunately λ-calculus is pretty simple, so the translation into a substrate language is also pretty easy to do, especially if you pick a substrate language which has first-class functions and macros: you can simply compile λ-calculus into a tiny subset of that language. Chances are that the substrate language will have operations on numbers, strings, and all sorts of other types of thing, but your compiler won't target any of those: it will just turn functions in the λ-calculus into functions in the underlying language, and then rely on that language to compile them. If the substrate language doesn't have first-class functions you'll have to work harder, so I'll pick one that does.

So here is a specific example of doing that. I have a toy language called 'oa' (or in fact 'oa/normal' which is an untyped, normal-order λ-calculus. It represents functions in a slight variant of the traditional Lisp representation: (λ x y) is λx.y. Function application is (x y).

oa then get gets turned into Scheme (actually Racket) roughly as follows.

First of all there are two operations it uses to turn normal-order semantics into Scheme's applicative-order semantics:

• (hold x) delays the evaluation of x – it is just a version of Scheme's delay which exists so I could instrument it to find bugs. Like delay, hold is not a function: it's a macro. If there were no macros the translation process would have to produce into the expression into which hold expands.
• (release* x) will force the held object made by hold and will do so until the object it gets is not a held object. release* is equivalent to an iterated force which keeps forcing until the thing is no longer a promise. Unlike hold, release* is a function, but as with hold it could simply be expanded out into inline code if you wanted to make the output of the conversion larger and harder to read.

So then here is how a couple of λ-calculus expressions get turned into Scheme expressions. Here I'll use λ to mean 'this is a oa/λ-calculus-world thing' and lambda to mean 'this is a Scheme world thing'.