halpert

So why did they evacuate Fukushima, and why were people concerned about ocean contamination? It’s undeniable that there are failure scenarios that are unknown with any design.

Reading Voices from Chernobyl changed my opinion on nuclear. The potential human cost is so great it doesn’t seem worth it.

One other way of thinking about the issue is this: what would you consider a safe power plant? How about one that has a probability of failing once every ten thousand years. That sounds pretty safe, doesn’t it? Well with hundreds of power plants, the probability of a single one failing starts to get quite high on any given year. And that matches reality: three mile island, Chernobyl, Fukushima, among many others: https://en.m.wikipedia.org/wiki/Nuclear_and_radiation_accide...

The potential downside is that large swaths of the planet become uninhabitable. Is that really a wise bet to make in the face of climate change?

> You can achieve anything you want to from a DAO with a corporation plus a twitter poll or SurveyMonkey thing.

How would accept money from thousands of people without being public? How would those ownership stakes be easily transferred?

I actually use rust-analyzer, but I’m not a hardcore Rust developer, and I wasn’t even aware there were two plugins. I picked the first result off of Google. The fact that the first result is a bad plugin seems like an issue with the Rust community.

Doesn’t seem to work on an iPhone?

What’s the easiest way to access the javadocs for the transitive dependency closure of your project? I didn’t know about cargo docs until now, but it seems way more useful than javadocs. An good IDE still seems better than both, however.

VS Code definitely has Rust language server support via the Rust extension.

https://marketplace.visualstudio.com/items?itemName=rust-lan...

Properly maintained bridges of any size shouldn’t randomly collapse. It’s always major.

You still are implicitly assuming it’s easier to write bug-free imperative configuration compared to declarative. It doesn’t really matter which is harder to debug if it’s much easier to write bug-free code using declarative code. Again, some specific examples that underpin your assumption would be helpful in making your argument more convincing.

What you’re saying is equivalent to “buggy declarative code is harder to debug than working imperative code.” Obviously that’s true, but not exactly a convincing argument that imperative is better than declarative.

Your underlying assumption is that it’s easier to write correct imperative configuration than it is to write correct declarative configuration. In my experience, this is not the case. Consider a basic task like provisioning a fleet of hosts and deploying some code to the fleet. In an imperative approach, you need two distinct steps. One for provisioning, and one for deploying. Both operations are multi-step processes that are required to be idempotent because the number of possible failures between the start of provisioning and the end of deployment is quite large. It’s not easy to write a system that does this, as there are a lot of steps that need to be enumerated via imperative scripts for both provisioning and deployment, and it’s even harder to do in a failure tolerant way.

Compare the above to a Kubernetes deployment. The entire configuration is 30 lines of yaml. There is no providing step. Kubernetes will make sure the resources you need are provisioned and it will do so in a failure tolerant way.

Declarative is better because it’s simpler. For instance let’s say you have a system and you want to add a new resource to it. If you’re using an imperative paradigm, then you’ll write a script to transition the state from the current state to the desired state. Now let’s say you want to spin up a new cluster in a different region, you need to write another script to go from the empty state to your final state from before. With a declarative paradigm, both modifying and creating resources are the same.

It’s also easier to understand the current state of the system. In an imperative style, you need to understand every operation that has been performed to know what the current state is. In a declarative system, you just need to look at the most recent declaration.

In short, declarative is more scalable and understandable.

Another way to look at your question is to ask what is better about the imperative style? Having used both, I can’t think of any advantages. Maybe you could say you have more control with imperative, but is that control really necessary? In my experience, it is not. The additional control just makes things more complex.

And of course you can make a overly complex, hard to understand system using a declarative paradigm. But the simplest declarative system can be simpler than the simplest imperative system for achieving the same configuration.

Can you really separate the “design” from how it’s manufactured?

Notorious is the wrong word you’re right. It’s an active area of research. It’s called the “common ownership hypothesis”.

Where you trying to create a tuple? Does `const z: [Thing, Thing] = [exprA, exprB];` work?

I would want to see an iOS app that renders 1000 items in a list, with each item pushing to the navigation stack when clicked. And then I would want to see the same thing implemented in the browser with similar responsiveness on iOS Safari.

Writing this out made me realize another limitation of the browser: the page unloads when navigating, so going “back” can be a pain / impossible depending on the circumstances.

Hmm the layout is working for me now, but the tile animation is broken. They flicker instead of smoothly flipping over.

I disagree. Yes, if you have a static webpage and all you need to do is scroll, then you can easily get 60 fps, notably because the scrolling is handled natively by the browser and basically is just a translation on the GPU. If the web app accepts user input, especially touch with dragging, then the page will not feel native with the current batch of browsers for the reasons I mentioned above.

This is notoriously playing out in the ETF space. Large institutions own vast quantities in stock in competitors and competition decreases as a result. See Rise of Institutional Investors Raises Questions of Collusion.

I made a another comment further down, but basically web apps can’t run as fast as native apps for a variety of reasons.

One reason is the thread model. There are two main threads that need to be synchronized (browser main thread and JS main thread) which will always be slower than a single main thread.

Another reason is that layout and measurement of elements in HTML is really complicated. Native apps heavily encourage deferred measurement which lets the app measure and lay itself out once per render pass. In JavaScript, layouts may need to happen immediately based on what properties of the dom you’re reading and setting.

On iOS, the perf of Safari is definitely better than every other browser, because every other browser is mandated to use WkWebView by Apple. They aren’t allowed to implement their own engine. Of course Apple isn’t subject to the same restriction.

The issue isn’t so much having additional threads, it’s needing two main threads. The browser has one main thread for accepting user input and then dispatches the relevant user events to the JS main thread.

The browser can either dispatch the events asynchronously, leading to the events being handled in a noticeably delayed way, or the browser can block its main thread until the JS dispatch finishes, leading to fewer UI events being handled. Either way is an inferior experience.

Really? Even something simple like Wordle feels janky with the way Safari’s chrome overlaps the keyboard.

The web always feels terrible compared to a native app, especially on a phone. Some of the difference is due to Safari being a bad browser (probably intentional), but a bigger part is that the threading model makes it really difficult to have a responsive UI. Not to mention the browser’s gestures often clash with the application’s gestures.

There are some variables though. Like the glass bottle, screw top vs. plastic cork vs. real cork, and quality of label printing.

Has he heard of a zero sum game?

Sure they do, but does the average consumer understand the difference between the regions and grapes? Probably not. I bet there are even many experienced drinkers who could not identify them in a blind test.

That friendly blog site includes trackers. They won’t get my money until they respect my privacy.

I’m not claiming management structure is the only factor in whether or not a business is competitive. It’s just a factor, and business usually try to optimize the factors under their control to be the most competitive. Of course, there are many factors outside of the businesses control as well.

For civil engineering, I believe the expectation is that you can be licensed as an engineer after attending undergrad. Grad school for civil engineering assumes you’ve already done the undergrad portion. Just fyi.

If the markets are underestimating inflation, then the Fed will need to be even more aggressive with the interest rate increases, meaning the price of speculative assets like BTC will drop even more.