Writing userscripts and CSS filters
becomes more tedious each few years,
especially mucking with dynamic DOM
and complex frameworks websites tend to
use now. WASM and obfuscated/minified javascript made "programmable web" impossible in practice.
Wikipedia is not a reliable source
for anything that is remotely controversial or recent(as in last 20 years), as there always people who have
agenda to 'correct the record' on something.
I just binge watched a dozen videos,
this is probably my new favorite genre.
The complexity and speed are on par
with very fast electronic but far more
pleasant(like classical orchestra). Are all such Black MIDI using only piano
notes or this is just a stylistic convention?
Well, the little tigers can be dangerous and hold pathogenic bacteria in their little claws.
You'd be nervous too if that thing could claw at your eye
at any moment. Plus they could carry toxoplasmosis and tons of infections picked up from street animals.
I'd play it safe and eat only natural sweeteners like inulin/stevia/xylitol. Gut microbes haven't evolved to
expirience the whole array of artificial sweeteners.
It won't work:
Left doesn't acknowledge the benefits of meritocracy.
Right is anti-intellectual and suspicious of progress.
There is no social movement supporting intellectual achievement:
the public is focused on cheap infotainment and sensationalist science
that is 'group-activity' such as "scientists from X find Y, due being funded for Z". Lone genius/inventor doesn't have such appeal as 'Big Science', which is actually collectivist mediocrity rewarding social climbers and salesmen:
Academic science has to justify itself financially and 'discoveries' are usually coming from the above(Y found but funded for Z).
In the past the idea of scientific progress was understood as necessarily, but today the status quo is more comfortable
the word "meritocracy" has an interesting backstory that you might find interesting (tl;dr the creator of the word intended for it to be used as satire). relevant link: https://www.theguardian.com/politics/2001/jun/29/comment
From reading the paper, it basically does jump unthreading. Basically, if you imagine code like this:
bool found = false;
for (...) {
if (...) {
found = true;
break;
}
}
if (found) {
// A
} else {
// B
}
Jump threading is an optimization pass that replace the break statement with a goto A. After that replacement, found is always false, so the boolean variable and the if statement is deleted. The resulting code would look something like this [1]:
for (...) {
if (...) {
// A
goto end;
}
}
// B
end:;
What the lifting is doing here is essentially running this pass in reverse. If you find a branch pattern that doesn't meet any preordained schema (such as a loop with multiple exits), just synthesize a variable that tells you which target you're going to jump to. Were the compiler to optimize the resulting code, jump threading would convert it back into the gotos present in the compiled binary.
[1] This kind of optimization pass runs at a stage when the code is basically treated entirely as a CFG and there's no such thing as if statements or jumps or gotos, just conditional and unconditional branches terminating basic blocks. Any reflection of the code outside of this form is therefore somewhat imprecise.
[EDITED to say explicitly:] You can translate any goto-laden code into "conventionally structured" code mechanically, if you don't care about having the structure of the resulting code actually indicate what it does. Here's an example of the sort of code for which that might be the best you can do.
Suppose you implement a state machine with gotos. So, for a simple (and contrived) example, suppose you have something that absorbs the decimal digits of a number and keeps track of the value of the number modulo 3 by having three states. Something like this (pseudocode):
def mod3():
state0:
d = getdigit()
if d == FINISHED: return 0
if d is 0, 3, 6, 9: goto state0
if d is 1, 4, 7: goto state1
if d is 2, 5, 8: goto state2
return ERROR
state1:
d = getdigit()
if d == FINISHED: return 0
if d is 0, 3, 6, 9: goto state1
(etc.) You've got three stateN labels each of which can jump to any of the stateN labels (as well as being able to return from the function).
If you have tail-call optimization you can turn this into conventionally structured code, more or less:
def state0():
d = getdigit()
if d == FINISHED: return 0
if d is 0, 3, 6, 9: return state0()
if d is 1, 4, 7: return state1()
if d is 2, 5, 8: return state2()
return ERROR
with similar definitions for state1() and state2(), and then the top-level function just calls state0. But this depends on knowing that all those tail calls will get optimized, or else on never having enough digits to overflow your stack.
Or else you can have an explicit state variable:
def mod3():
state = 0
loop:
if state == 0:
d = getdigit()
if d == FINISHED: return 0
if d is 0, 3, 6, 9: state = 0
else if d is 1, 4, 7: state = 1
else if d is 2, 5, 8: state = 2
else: return ERROR
else if state == 1:
...
else:
...
which works pretty well for the special case of state machines but badly for most other things a goto might be used for. (Though obviously you can translate literally any goto-using code into this sort of thing. You might want to call the analogue of the "state" variable here "program_counter" in that case.)
The translation can always be done, but for dense spaghetti control structures duplication of code may be required. One can construct artificial cases where the size increase is exponential, but that's unlikely to be an issue in even the worst real code.
This is actually why we chose _not_ to implement no-more-gotos for Binary Ninja's HLIL! Code is actually more readable with gotos in some situations and trying to force their elimination hurts readability.
Perhaps the older lens has more pleasing colors:
normally absorbing a bit more of hi-freq(blue/violet) lens a comfy "orange sunset" effect and warm atmosphere.
Modern digital cameras tend to be "colder"
in color, with sharp blue/violet.
To me, the copy of the EF 1.2L that I tested had a softness to its rendering that was very painterly. I shudder to use the term "microcontrast", but the lens appeared to have solid contrast and sharpness at broader spatial scales and a softness at the smallest scales.
It felt like a lens that rendered every scene with a deft touch, making everything just a little prettier than it might really be.
Someday, I may find a used one to call my own, but I can't quite justify its weight and expense today. The EF 1.4 largely fills that bill without the price and heft, but doesn't render things so instantaneously as art.
