I understand Nebulae like the Eagle Nebula are fairly dynamic regions of space, so I find it interesting that we have photographs of the same region over a 27 years time span and at a glance, the structure of the Pillars of Creation appears virtually identical.
I understand that 27 years is minuscule on the cosmic timescale, but what order of timescale would be necessary for the evolution of Pillars of Creation to be are apparent to a casual observer? hundreds of years? thousands?
For another dynamic area with things changing on a human lifespan, the black hole at the center of the galaxy we can watch stars orbit it. https://youtu.be/XA7CAVm31z0
Even more interesting when you think about the plethora of events that must be happening there in this interval of time at human scale. The Sun alone, 8 light minutes away, in seconds is consuming hydrogen and generating energy at amounts that we as humanity could use for thousands and thousands of years.
The pillars of creation are somewhere between four to five light years across. Unless the entire dust cloud moves at relativistic speeds it's going to take a lot of time for any change to be visible when zoomed out that far
Serious question: Why not use source control to identify the files with changes and limit the scope of your formatter run to just those files. If the unchanged files met the formatter rules when they were committed, then repeated runs should be guaranteed to pass. Why introduce a cache when you could just do less work?
Because on CI there's no guarantee that the parent commit has already passed. It might be unchecked, in progress, or CI failed despite being a parent commit.
Now you could query the CI from the CI but that seems to be a dubious dependency to me, and user would need to set up an access token.
I've also noticed the same blank page with spinner (which seems to hang and never actually refresh in my case) on non Google sites since the quantum upgrade. Figured it was a bug that would get squashed in a subsequent version, but no luck yet.
> The thing I like about classes is I vaguely understand what is going on [...] I am not saying the javascript prototype logic is bad, just that I never understood it, even when I work in Javascript for years.
But by using classes, you're still using prototypes, it just isn't as immediately apparent.
Sure, and by using classes in C++, you're still using tables of functions pointer like you can in C. The "not as immediately apparent" part is where the usability improvement comes from. It means you don't need to think about the machinery as much. You can work at a higher level of abstraction.
(Of course, the details of how the feature is designed determine how leaky the abstraction is and how often you actually get the luxury of not thinking about the machinery.)
I think understanding "this" in javascript is actually much easier if you have had exposure to C++ function tables.
With that knowledge in hand, it immediately becomes obvious that:
bar.baz = function(){console.log(this.X)}
var foo = bar.baz;
foo();
Is not going to result in a console log of bar.X. "foo" is a pointer-to-member function, and executing it without a context is going to cause problems. The biggest in javascript as compared to c++ is that javascript will always provide the hidden "this" (even if it's the global context), whereas c++ will always bail out if you don't provide it with a proper context.
But really, understanding that behind the scenes, member function calls change:
A.B(C)
into
B(A, C)
clears up a lot of "this" mistakes, and also enlightens the proper usage of function.bind.
It's probably a good time to start looking at using the Fetch API [1] for making AJAX requests instead of using jQuery or Backbone (or even XMLHttpRequest). Support seems to be growing quickly and Github's polyfill [2] can help cover the gaps.
Agreed... I really have come to like fetch, though I usually wrap it in a couple functions for my most common use cases... since some of the options are a little tedious to specify over and over again... such as `postJson(url, data)` which will post the data as json, and resolve the json response with some extra error handling.
It works well, and combined with babel for async/await, the workflow is pretty smooth as well.
I understand that 27 years is minuscule on the cosmic timescale, but what order of timescale would be necessary for the evolution of Pillars of Creation to be are apparent to a casual observer? hundreds of years? thousands?