What does "loop on itself" mean in this context? The article repeats it 5 times but I can't find a thesaurus definition, and it's unclear to me if the author means it as a synonym repeat or *self-amplify or something different.
My impression was that the author was referring to *self-amplifying like a positive feedback loop.
I agree I would have loved more of a hard / concrete definition oriented approach to the whole piece but everything they were saying really resonated at least in terms of my personal experience. I haven't ever come across a writer focusing on this. It was really unexpected / refreshing. It's already is reshaping little moments in my day like hugging my son just now. Very unexpected transcendental value for an HN skim while ignoring a boring zoom standup. The truth is out there.
> What does "loop on itself" mean in this context?
What it means is understood by looking at its converse - panic attack. Wherein, anxiety stirs some negative thoughts which stirs even more anxiety which stirs more negativity and so on until the system seizes - or that has been my understanding of it.
Here, positivity feeds joy which feeds more positivity etc..
The author is perhaps presenting a good argument for languages/runtimes like JavaScript/Node where dependencies may be isolated and conflicting dependencies may coexist in the dependency tree (e.g., "app -> { libpupa 1.2.3 -> liblupa 0.7.8 }, { libxyz 2.0 -> liblupa 2.4.5 }" would be fine), but the proposed dependency resolution algorithm...
> Our dependency resolution algorithm thus is like this:
> 1. Get the top-level dependency versions
> 2. Look up versions of libraries they depend on
> 3. Look up versions of libraries they depend on
...would fail in languages like Python where dependencies are shared, and the steps 2, 3, etc. would result in conflicting versions.
In these languages, there is good reason to define dependencies in a relaxed way (with constraints that exclude known-bad versions; but without pins to any specific known-to-work version and without constraining only to existing known-good versions) at first. This way dependency resolution always involves some sort of constraint solving (with indeterminate results due to the constraints being open-ended), but then for the sake of reproducibility the result of the constraint solving process may be used as a lockfile. In the Python world this is only done in the final application (the final environment running the code, this may be the test suite in for a pure library) and the pins in the lock aren't published for anyone to reuse.
To reiterate, the originally proposed algorithm doesn't work for languages with shared dependencies. Using version constraints and then lockfiles as a two-layer solution is a common and reasonable way of resolving the dependency topic in these languages.
> Notice: sr.ht is currently in alpha, and the quality of the service may reflect that. As such, payment is currently optional for most features, and only encouraged for users who want to support the ongoing development of the site. For a summary of the guarantees and limitations that the alpha entails, see this reference.
I've used it for a few years and it's been stable and without issue. builds.sr.ht is the best CI that I've ever used. I think the only time it has been down has been due to DDOS.
Would I run the git server of a multi-national bank on it? Probably not. A standard SAAS? Yeah if my team felt it was important to use EU companies.
Otherwise you could also self-host with a VM, then you can use gitea or gitolite with systemd oneshot services.
The spiral rule works only if there is no pointer to pointer or array of array in the type. In other words it is an incorrect rule. But take this for example:
The type of VAR is a [1-element] array of [2-element] array of [3-element] array of pointer to pointer to ints. I drew a spiral that passes through each specifier in the correct order. To make the spiral correct it has to skip the pointer specifiers in the first three loops. This is marked by ¦.
The spiral rule can be modified to process all array specifiers before all pointer specifiers, but then you'd have to specify that the order to do so is right and then left. At that point it's just the Right-Left Rule.
I've found that 'declaration follows use' is actually the easiest way to understand C type declarations. The only annoying to remember thing is which way the various type specifiers like const bind.
In physics that usually means that we are missing something in the ¦'s. Like these hypothetical/imaginary "arr" keywords, look:
int ** arr arr arr VAR[1][2][3];
By introducing these virtual storage kind specifiers, the spiral model works! It becomes apparent that these specifiers are actually real, cause the model wouldn't be consistent otherwise, and there's so much evidence for it all over the C codebases. We just tend to see the "real" part of it (sigh, stuck forever with that legacy terminology), while this is what actually happens:
long double _Complex ** arr arr arr VAR[1][-1][sqrtl(-1)];
which is naturally homomorphic to most C compilations.
My own interpretation (which effectively matches the right-left rule, at least algorithmically) is that, (), [], and * are operators, which have different semantics at the declaration vs the 'usage/expression' level, where:
() and [] are right-associative unary type-operators, with high fixity, (or equivalently, binary type-operators when () or [] have arguments)
and * is a binary type-operator, with low fixity (i.e. lower than () or [] ), where the 'left' argument is effectively the context that's left after removing the asterisk and the 'right' argument (rather than what's to the left of the asterisk in a purely 'anatomical 'sense')
(whereas, at the expression level, * is a unary value-operator instead, while () and [] behave the same as in their type-form, except acting as value-operators instead)
If you're going to adjust willy-nilly on which loop of the spiral a given element appears, then it's not much of a rule, isn't it? I mean, why not write this?
It took roughly 20 years for the EU to deploy 30 satellites.
How long do you think it's going to take to deploy 300 or so of them when the Ariane 6 had only one launch (with a partial failure) in the last 14 years?
If you want to build a constellation, you need the means to send payloads in space at a relatively low cost. The EU can't do that so it will be an expensive and slow endeavor and by the time those 300 satellites are up there, Space X will have deployed 10s of thousands of them.
You can say, that the EU does not want to compete with Space X or that their goals are not the same but either way, it's just too little too late IMHO.
I agree with your overall point, but that's a super deceptive metric to use. First Ariane 6 was scheduled for 2020 and only the first one ever launched.
An entrance or exit construction is a place on a road where you aren't just turning onto the road but exiting the road entirely. The most common example from any country would be a private driveway. Pedestrians, cyclists and cars going along the sidewalk, bike path or road have priority against anyone turning into the driveway or turning onto the road from the driveway.
The Netherlands generalizes this concept to some low-priority side streets. If there is a continuous sidewalk (i.e., the cars go up a bump to the level of the sidewalk as opposed to the pedestrians stepping down from the sidewalk to the level of the street). This is not the case in this specific intersection.
And yet the photo in the article shows piano teeth markings before the shark teeth, which indicates a level change for the car. In that case I would assume that cars are required to yield to pedestrians crossing the side street even though the sidewalk surface is not continuous.
This specific turn is onto a street that the article describes as "traffic volume here is low, since only residents will use this street." They probably expect the 1-car buffer to be enough for this intersection. You can see in the video that the 1-car buffer is empty most of the time.
For intersections where they expect more turning traffic (where the one car buffer wouldn't be enough), they add turning lanes that can accomodate more than one car. You can see an example of this a few hundred meters northeast when Graafseweg intersects the Van Grobbendocklaan: https://maps.app.goo.gl/ZmURqawr3oeBX5Sq9
The previous poster intentionally mentioned password recovery flow. If you can gain access without your password, than law enforcement can too. If you could only gain access with your password, you could consider your data safe.
> If you could only gain access with your password, you could consider your data safe.
You can't assume the negation.
If you can get access without your password then you have proven that law enforcement or the hosting company can to.
If you can't get access then you haven't proven anything. They may be securely storing your data end-to-end encrypted. Or they may just have a very strict account recovery process but the data is still on their servers in the clear.
