If there was a point there the article did not make it easy to find.
867 karma · joined September 13, 2016
If there was a point there the article did not make it easy to find.
Like, the ability to have multiple mut references to a struct as long as you access disjoint fields? That's amazing!!! A redo of Pin that actually composes with the rest of the language? That's pretty awesome too.
I think you're getting tied up because the the author is describing these features in a very formal way. But someone has to think about these things, especially if they are going to implement them.
Ultimately, these are features that will make Rust's safety features (which really, are Rust's reason for existing) more ergonomic and easier to use. That's the opposite of what you fear.
I would say it's even the thesis of the article. Joann Fabrics was a healthy company with customer demand and zero debt and was basically assassinated by a leveraged buyout.
Hopefully I am paraphrasing you correctly.
To clarify: without being able to simulate the universe from within the universe itself (i.e. needing to resort to some "outside" higher-fidelity universe), then the word "simulation" becomes meaningless.
We could just as easily refer to the whole thing (the inner "simulation" and the outer "simulation") as just being different "layers of abstraction" of the same universe, and drop the word "simulation" altogether. It would have the same ontology with less baggage.
"If there’s a cut in my wire’s insulation, the device won’t get enough voltage" doesn't follow from: "voltage is like water pressure in pipes"
So I don't really get your point.
It doesn't matter how personally upset you might be at this.
Really what produces an advantage is an environment of trust. Having that reduces a lot of friction when it comes to economic activity.
That sentence was particularly hard to parse. It read like you were saying that the structure of British democracy kept fascists away, but did not keep the British people away (???).
I did manage to figure it out eventually though. I think you meant to write:
It was the structure of British democracy that kept fascists away, not the British people.
I find the best way to understand why 2s complement is so desirable is to write down the entire number line for e.g. 3-bit integers.
Using 1s complement, the negative numbers are backwards. 2s complement fixes this, so that arithmetic works and you can do addition and subtraction without any extra steps.
(Remember that negative numbers are less than positive numbers, so the correct way to count them is:
-8 -7 -6 -5 -4 -3 -2 -1 0 +1 +2 +3 +4 +5 +6 +7
Where -1 is the largest possible negative number)
At it's heart it's kind of like an asynchronous task execution engine that sits on top of an I/O layer which allows the high-level code to coordinate the activities of various equipment. Stuff like robot arms, furnace PID controllers, gantry systems, an automatic hydraulic press/spot welder (in one case), various kinds of pneumatic or stepper actuated mechanisms, and of course, measurement instruments. Often there might be a microcontroller intermediary, but the vast majority of the work is handled by Python.
My experience with async Python has been pretty positive, and I'm very happy with our choice to lean heavily into async. Contrary to some of the comments here I don't find the language's async facilities to be rough at all. Having cancellation work smoothly is also pretty important to us and I can't say I've experienced any pain points with exception-based cancellation. Maybe we've been lucky, but injecting an exception into a task to cancel it actually does work pretty reliably. Integrating dependencies that expose blocking APIs has never been a big deal either. Usually you want to have an interface layer for every third party dependency anyways, and it's no big to deal to just write an async wrapper that uses a threads or a thread pool to keep the blocking stuff off of the main thread.
I personally think that a lot of people's negative experiences here might have more to do with asyncio than the language's async features. Prior to stepping into my current role, I also had some rough experiences with asyncio, which is why we chose to build all of our async code on top of curio. There was some uncertainty at first about how well supported it would be compared to a package in the standard library, but honestly curio is a really well put together package that just works really smoothly.
As in: The last 15 years has been just relentless attempts to bend and twist everything the previous generation has built to extract value instead of creating it.
Something like that.
I feel like what's happened here is that the author actually needed a system to cache their derived values, but didn't think to build that out explicitly.
As a teen I used to play around with Core Wars, and my high school taught 8086 assembly. I think I got a decent grasp of it, enough to implement quicksort in 8086 while sitting through a very boring class, and test it in the simulator later.
I mean, probably few people ever need to use it for something serious, but that doesn't mean they don't understand it.
I thought based on the title it would have been about different approaches to backoff.