I haven't read the paper in full detail, but reading between the lines I'm guessing that there's a significant portion of manual processing and hand waving involved. From the abstract, emphasis mine:
> the second stage uses a pixel-wise nearest neighbor method to map the smoothed output to multiple high-quality, high-frequency outputs in a controllable manner.
My interpretation is that they select training data by hand and generate a bunch of outputs. Repeating the process until they like the final result. From the paper:
> we allow a user to have an
arbitrarily-fine level of control through on-the-fly editing of
the exemplar set (E.g., “resynthesize an image using the eye from this image and the nose from that one”).
There's nothing weak or negative about that, it's exactly what'd you expect. Obviously for a given input there will be multiple plausible outputs. With any such system it would make sense to allow some control in choosing among the outputs.
I fail to understand the need to re-use terms from other fields in a completely twisted way. For those like me wondering what an "idempotent API" is: making multiple identical requests has the same effect as making a single request[1].
Then you have other people using the exact same term to refer to a (seemingly) totally different concept: An idempotent operation completes no more than one time[2].
Maybe I'm thicker than the average web developer, but I think that there must be a simpler way to explain this concept. Specially without reusing a term that, formally, means something completely different[3] than any of the possible interpretations that I have come up with so far.
The AWS example is really the same thing (making multiple identical requests is the same as one request), just explained very poorly. Further down:
> If you launch your instance using run-instances (AWS CLI), ec2-run-instances (Amazon EC2 CLI), or RunInstances, you can optionally provide a client token to ensure that the request is idempotent. If you repeat a request, the same response is returned for each repeated request. The only information that might vary in the response is the state of the instance.
These are also both the same as the original mathematical definition. You're right about term overloading in the general case, but this isn't really an example of that.
I teach a lot of pretty middling software developers about idempotence when discussing configuration management tools, and it seems pretty graspable. Idempotence is `f(f(x)) = f(x)` and nothing but. This is your #1.
Upon a second read, what AWS is saying is "if you pass a token and this has already been done with that token, return the original result." That token is just setting part of `x`.
By your definition, how can a REST API be idempotent? Say that GET(user) = john so, what I'm interpreting is that: GET( GET(user) ) = GET(john) = john. That doesn't seem valid to me.
GET requests are a bad example because usually GET(x) will always return the same thing, unless x was updated in some fashion
Let's work with the classic TODO app example. Say the user adds a TODO item, and makes a POST request to the server to store it. If the user POSTs their TODO, but due to your front-end being overly-eager to hear back from the server, it sends the request twice because the first one took too long to respond.
This should not create two identical TODO items, but instead only create one. This is the concept of idempotence; performing the same operation n (n > 0) times should be the same as performing it once.
It's slightly notationally inaccurate to say f(f(x)) is what the client is performing in this case, it's more like f(x) * f(x), but these details surely are unimportant.
Your point is valid, but just wait till you encounter "isomorphic javascript". Web development uses formal terms in a more "feels like" way than academic literature, sadly.
I'd say that the Windows equivalent is https://chocolatey.org/. It has the largest amount of "packages" from all other similar efforts that I have seen.
Thanks for sharing that! Some of them are just a big pile of CSS which I don't know if it's a better option than JavaScript... But others were pure gold and a very clever use of HTML (like the carousel)
Actually, no. Microsoft instrumented essentially every OS component (and sharing backend infrastructure, universal telemetry client, etc.) starting in Windows 10. Prior to that, it was just a few isolated pieces that had their own kind of telemetry.
Not quite. Windows 8 had most of the same telemetry, but it was off by default and you were given the option to turn it on during or after installation. Windows 10 flipped that on its head by giving you a page during install that said "get started quickly" which automatically turned everything on, and there was a tiny text link at the bottom which said "customize". Clicking that gave you three pages of telemetry-related toggles that you had to manually click to turn off. Even then, basic telemetry (anonymized usage data and crash reports) is still sent to them.
After Windows 10 was released, Microsoft started backporting most of its telemetry capabilities to Windows 8 and 7 and turning them on by default, rendering those versions just as "backdoored" as 10. That was what pushed me to accept that Windows was never going to get better in that regard, and so I've upgraded all my Windows 7 and 8 machines (except my Surface RT obviously) to take advantage of the new features. I'm especially enjoying native NVMe support on my new workstation build; I can't go back to a spinning HDD without feeling like I've stepped 20 years into the past.
Also wrong. The telemetry in Windows 8 was just in critical components that had been instrumented long ago, such as Windows Update, crash management, etc. None of those were using the current universal telemetry system. In fact, I don't know if all of them moved to the new telemetry infrastructure shared with the rest of the OS or if they kept what they had and just added the new telemetry on top.
All that said, I agree with your last point about upgrading being a fair compromise compared to staying in Windows 7 or gasp Windows 8.
> The telemetry in Windows 8 was just in critical components that had been instrumented long ago, such as Windows Update, crash management, etc. None of those were using the current universal telemetry system.
Are you sure? I did a lot of Windows 8 installations when I was evaluating it, and I distinctly recall the option to turn on the same tracking features that 10 had on by default. In the Windows 8 installer they were presented up front and off by default, in 10 they are hidden and on by default.
As of a month ago this is still the case; I reset a Windows 8 hybrid laptop, going through the standard installation screens, and then upgraded it to 10.
The EULA for it is the same, but the underlying system is totally different. I am 100% sure about this :-)
But, as you noted, a lot of the telemetry instrumentation has been backported so that argument is lost for someone wanting to avoid upgrading to Windows 10 from an earlier version.
Shameless plug: I have been working on my own code editor as well, I wanted something between Notepad++ and Jupyter Notebooks; I called it TeIDE: https://github.com/omtinez/teide
Fully open source, built on Polymer and currently working on a plugin/action model to enable users to execute custom commands on the underlying shell.
Accepting pull requests and all forms of feedback :-)
Actually, I had a similar experience. For that reason, I decided to work on a side project precisely to encourage people to get started lifting weights and lose the fear of going to the gym: https://ezworkout.org
That is slick! I'll be using this next time I go to the gym. One of the big problems it solves for me is boredom - I lifted for a couple years but couldn't stand doing the same workouts week adter week. I do realize you're supposed to switch it up, but your app makes it easy :)
I don't see the point of this with newer generation cameras. Almost all drivers nowadays support the "photo burst" mode where you take a single photo and the driver gives you back X frames before and after the fact (at full resolution). I think Nokia calls it Perfect Shot
> the second stage uses a pixel-wise nearest neighbor method to map the smoothed output to multiple high-quality, high-frequency outputs in a controllable manner.
My interpretation is that they select training data by hand and generate a bunch of outputs. Repeating the process until they like the final result. From the paper:
> we allow a user to have an arbitrarily-fine level of control through on-the-fly editing of the exemplar set (E.g., “resynthesize an image using the eye from this image and the nose from that one”).