re-framer

I believe this works on Android in general, but I tried on GrapheneOS. Open the Settings app. Tap Security & Privacy > More security & privacy > App pinning. After that is enabled, if you want to pin an app, open it, swipe up into the recent-apps view, tap the icon of the app above the preview pane, and select "Pin".

The feature is buried a bit. I believe this is because it's more of a best-effort protection. The settings page itself says:

"When an app is pinned, the pinned app may open other apps and personal data may be accessible. If you want to securely share your device with someone, try using a guest user instead."

Yes, and I'm still interested in better understanding that reason. My previous response just noted that the explanation you gave seemed overly simplistic to me in that it did not address that renewable energy can be stored, making it less volatile.

Renewables can be combined with storage technologies such as batteries, so the syllogism "no generation during Dunkelflaute, but need reliablye generation -> renewables not viable" is too simple. My question is about whether renewables with storage technologies are a viable replacement for the gas power plants.

I asked whether solar/wind in combination with storage technologies, including but not limited to batteries, was able to reliably power a data center.

What is it that makes gas power plants so much more attractive than renewable energy? From what I heard, it's a bit easier to build them very fast and they reliably produce energy on demand (as long as gas is available of course). But I imaging one could replicate this using solar/wind and storage units.

I could imagine that the challenge is that that having enough solar panels for a few gigawatts of consumption is hard to do on-site, so one needs to connect the data center to the grid, which, in turn, complicates matters and transformators are scarce right now.

Is this about right? I do hope that we find a way to do this more sustainably. AI doesn't solve climate change in the next few years, so clean energy isn't irrelevant.

(On the other hand, I have been fooled by too many billionaires claiming to act in the interest of democracy and freedom. I once fell for a billionaire buying a social media platform, claiming to be a free speech fundamentalist, and it didn't age too well.)

I appreciate the critical perspective on political and economic power, as long as it's consequently followed, and every willingness for cooperation and the creation of fair rules is good.

What makes me doubt that Dario Amodei has really internalized the problem is the lack of humility, the stance that it's just important that the "good guys" keep the technology away from the "bad guys".

If you really want to provide AI with public benefit, you need to prevent power concentration. How? Some unpolished ideas, I'd be happy to hear yours:

- Avoid getting too close to an administration that is openly attacking democracy and is not interested in the benefit of humanity or mutually beneficial cooperation.

- Don't support surveillance. Non-(US-)Americans have human rights and privacy, too. Prepare for a situation where a government tries to convert your compute infrastructure into surveillance infrastructure.

- Support the creation of community data centers. In other words, build data centers together with local communities and make sure they profit from them.

- Advocate for laws that require transparency about resource usage and emissions of data centers.

- If you don't want an AI race, make sure that other countries don't need to fear the US concentrating too much power. Create institutions that can be trusted by other countries, too.

EDIT: I forgot:

- If qualified labor will actually turn out to get devalued, we also need a plan to prevent states from turning into rentier states that don't depend on a well-educated society any longer.

Your example, deduplicating the two functions into one, illustrates an interesting point, although I'd prefer still having the two specialized functions there:

    def set_deadline(deadline):
      if deadline <= datetime.now():
        raise ValueError("Date must be in the future")
    
    def set_task_deadline(task_deadline):
      set_deadline(task_deadline)

    def set_payment_deadline(payment_deadline):
      set_deadline(payment_deadline)

    set_task_deadline(datetime(2024, 3, 12))
    set_payment_deadline(datetime(2024, 3, 18))

You lose absolutely nothing. If you later want to handle the two cases differently, most IDEs allow you to inline the set_deadline method in a single key stroke.

So the argument from the article...

> Applying DRY principles too rigidly leads to premature abstractions that make future changes more complex than necessary.

...does not apply to this example.

There clearly are kinds of DRY code that are less easy to reverse. Maybe we should strive for DRY code that can be easily transformed into WET (Write Everything Twice) code.

(Although I haven't worked with LISPs, macros seem to provide a means of abstraction that can be easily undone without risk: just macro-expand them)

In my experience, it can be much harder to transform WET code into DRY code because you need to resolve all those little inconsistencies between once-perfect copies.