rer0tsaz
More recently, Vista had (accidentily?) 16-byte aligned stacks when using OpenMP with MingW, but the exact same binary crashes on Windows 10 when it tries to use unaligned SSE instructions.
This refers to Jean-Baptiste ‘JBQ’ Quéru, who responded: put users first.
https://plus.google.com/+JeanBaptisteQueru/posts/jjwjobbMUY8
> ‘When I toss a coin, the probability for heads is one-half.’ [...] the issue is between the following two interpretations:
> (A) ‘The available information gives me no reason to expect heads rather than tails, or vice versa – I am completely unable to predict which it will be.’
> (B) ‘If I toss the coin a very large number of times, in the long run heads will occur about half the time – in other words, the frequency of heads will approach 1/2.’
These are not the same except for special circumstances like controlled experiments. Frequentism usually assumes or restricts itself to those special circumstances. The long run here means `for any ε > 0, the probability that the observed frequency n/N lies in the interval (1/2±ε) goes to 1 as N goes to infinity'.
There is no such thing as an intrinsic probability, a coin only has a chance of landing heads when tossed. If we know everything about the coin and how it is tossed we could calculate the result. Some ways of tossing a fair coin are biased. Some coins are biased when tossed in fair ways. A fair coin toss exaggerates factors that are difficult to know and control exactly, like the force that we apply on the coin with our finger.
Jaynes thinks that `true randomness' such as is postulated by conventional quantum physics is unscientific (10.7). In any case it doesn't matter for calculating, and I don't think many Bayesians lose sleep over whether it's unknown, unknowable or `true randomness'.
If the Bayesian has an informative prior, they won't be mislead too much. If a Bayesian is 100% sure beforehand with a δ(x - 0.5) prior they won't be mislead at all, but of course no one is ever 100% sure (Cromwell's rule). On the other hand a frequentist might say p<0.05 and be mislead.
> When programming languages emerged, the "dynamic" nature of the assignment statement did not seem to fit too well into the "static" nature of traditional mathematics. For lack of an adequate theory mathematicians did not feel to easy about it, and, because it is the repetitive construct that creates the need for assignment to variables, mathematicians did not feel to easy about repetition either. When programming languages without assignments and without repetition --such as pure LISP-- were developed many felt greatly relieved. They were back on familiar grounds and saw a glimmer of hope of making programming an activity with a firm and respectable mathematical basis. (Up to this very day there is among the more theoretically inclined computing scientists still a widespread feeling that recursive programs "come more naturally" than repetitive ones.)
Continued https://tinyletter.com/programmingphilosophy/letters/i-don-t...
I'm really just advocating a rule of least power. Don't go into full general recursion just because you can.
My apologies for making an absolute statement with unclear terms, thus inviting uncharitable interpretations.
https://tinyletter.com/programmingphilosophy/letters/i-don-t...
[1] https://github.com/SteamRE/SteamKit/tree/master/Resources/Pr...
> Every upvote should increase the score, every downvote should decrease the score and the more votes there are the less an additional vote should matter. Only "adding pretend votes" satisfies this.
That really puts into words why "adding pretend votes" just felt right to me in practice.
Django Deployments Done Right by Peter Baumgartner: https://www.youtube.com/watch?v=SUczHTa7WmQ&list=PLE7tQUdRKc...
The first way to deal with it is to take into account higher powers of the differences, e.g. using a linear combination p-norms or a Huber function.
The second way is to take into account second order differences. This promotes piecewise affine instead of piecewise constant functions. You can go further and look at third order differences, but the improvement is minimal.
Other than being more complex, the biggest downside is that all of these methods have some new parameter(s) to tune.
At first, I optimized each channel, then upsampled the chroma channels using replication. This works terribly as you can see in the article.
So then I changed to linear interpolation. Briefly:
+---+---+
a x b y c
+---+---+
This worked decently, but it still showed fringes around sharper edges. I considered using more complicated upsampling methods like Lanczos or Mitchell, but instead went with optimizing a full size image with constraints on the downsampled image. By avoiding upsampling I got my optimized high resolution image for each channel.
But there were still fringes! As it turns out, just because each channel was optimized seperately doesn't mean that the image as a whole is optimized. So I switched to optimizing the three YCbCr channels together, not looking at the differences abs(x_{i+1} - x_i) but looking at the differences sqrt((Y_{i+1} - Y_i)^2 + (Cb_{i+1} - Cb_i)^2 + (Cr_{i+1} - Cr_i)^2). This actually eliminated the fringes.
The final result is https://github.com/victorvde/jpeg2png
a:
times 124 nop
jmp b
jmp a
times 125 nop
b:Clipping is required by JFIF, so you can't implement spilling in the decoder by default, even if you assume the source was 0-255 RGB. So implementing this in the encoder like the article does is best. but I have mixed feelings about it since it's most helpful for images that shouldn't be saved as JPEG at all.
> The image of a finger or a brush pushing along paint immediately brings to mind tensor fields, produced by -diffusiontensors, which directs asymmetrical smoothing kernels in the -smooth command to diffuse noise parallel to detected edges
[1] http://gmic.eu/ [2] https://gmicol.greyc.fr/ [3] http://gmic.eu/gimp_filters.txt
gets was deprecated in C99 and removed in C11.
And then it only works on grayscale images. Maybe because it's easier to get funding for medical images. Just applying the algorithm to each color channel separately leads to color fringing when they get out of sync.
Finally, usability, distribution, and performance are afterthoughts. I don't disagree but it makes a huge difference.
Making assumptions and testing them is very much part of the contest. You are even allowed to do this interactively.