dradtke

Fundamentally, consumers and producers are at odds with each other in certain ways. For instance, it's best for customers if every shop was open 24x7, but absolutely horrible for the employees needed to make that happen.

Walmart is the extreme end of satisfying consumers above all else. Customers get a single, climate-controlled location to take care of nearly all their shopping, with good prices; but it comes at the expense of the employees, local community, and factory workers. Unfortunately, most customers don't know or care about those downsides because the experience is catered so heavily for them, and it's hard to get people to sacrifice material comfort for benefits that appear so abstract.

I think the idea is to improve the sustainability of a city by reducing people's need to travel by car, which uses energy, and to improve its livability by ensuring easy access to most (or all) of life's amenities.

That doesn't mean it should be impossible to travel beyond the 15-minute limit. Other forms of long-form transit, like trains and cars, will always have a place, but not everyone thinks that they should be required to simply live.

Unlikely, housing is only one factor, and I don't think it's the biggest one.

Declining birth rates as a whole are to blame for this, not just abortion. Plus, legalized abortion helped reduce crime rates. https://law.stanford.edu/publications/the-impact-of-legalize...

True, but it's way easier to add centralization to a system that is decentralized by nature than it is to somehow decentralize something that is centralized by nature.

sd seems to provide a description for the command, too, which your solution wouldn't provide.

HCP might be what you want, but it doesn't support Nomad yet, and unfortunately it's not clear when it will. https://discuss.hashicorp.com/t/status-of-hcp-nomad/33374

To what? What level of consumption will make all these problems disappear? Going back to pre-industruial lifestyles is arguably worse for the average person than climate change is.

Does an LSP-enabled editor count as an IDE then?

I love how the first bullet point is "Not made from a web browser." Great to see some non-Electron competition in the chatting space!

Ah, yeah I didn't realize that Glade didn't work with GTK4. I'll update the post soon to clarify that, thanks for catching it!

One of the big points Bill Gates makes in his recent book on climate change is that once the genie is out of the bottle in terms of lifestyle, there's no going back. It's naive to expect people to willingly reduce their energy use enough to make an impact, and immoral when you consider all the people in poor villages that don't even have electricity yet.

The solution is, in a nutshell, to electrify everything, and push to make electricity clean and plentiful. Anything else is doomed to fail because we can't beat climate change by reducing our carbon footprint; we have to eliminate it entirely.

From that perspective, cloud energy usage is not a problem, since it's already electrified by nature. Now we just need to stop emitting carbon in order to make electricity (among other things).

Really? Every time I check (in the Chicago area), it's still out of stock. https://www.microcenter.com/product/609038/raspberry-pi-4-mo...

I'm curious about this, any links handy?

This post might be the most straightforward starting point: https://go.dev/blog/pipelines

Any discussion of COVID's origins now just makes me think of Jon Stewart on Colbert's show. https://www.youtube.com/watch?v=sSfejgwbDQ8

Braintree created a tool for doing something similar: https://medium.com/braintree-product-technology/https-medium...

Probably because America has only about a quarter of the population that India has? Also, the ideal of the American homestead or even suburban home is one that doesn't place a high value on sharing space or being close to your neighbors.

Looks pretty cool! I've recently become a fan of Overmind (https://github.com/DarthSim/overmind), which does something similar. I like the GUI of exo, though, so I may give it a shot sometime as well.

Does anyone know any VPS providers that are planning to support this? I'm using Linode primarily because they are one of the few providers that provides openSUSE images, but they haven't said anything about supporting MicroOS yet.

Wasn't it originally called Function as a Service? That seems to be a better name for its intended use-case than serverless.

Anyone interested in this idea should check out https://github.com/braintree/runbook

I assume it's mostly to make it easier for people to test this out with existing stuff. Docker containers are the standard for taking a base image and adding stuff on top of it.

While working full-time? Not everyone can afford to take a week off of work just to interview at companies that may not necessarily extend you an offer.

True, software works just dandy these days if you remove the "attack" factor, but software isn't deployed into an attack-free space the same way a plane flies through safe air.

As anyone who has ever logged into a Linux server to be greeted with the number of failed logins since the last successful one knows, _everything_ is under constant attack when it comes to digital technology. That's a large part of the problem, but the other part is that most people don't take security seriously enough. I would be more likely to trust a voting machine that isn't networked at all, with votes periodically extracted manually onto an encrypted USB drive or something, but good luck getting these manufacturers to not put wi-fi and bluetooth in everything.

I'll just end on this note: https://www.engadget.com/2017/10/10/defcon-event-reveals-eas...

I like to use a pattern like this: given a resource defined as an interface:

    type Database interface {
        Users() ([]*User, error)
    }

I like to create an explicitly-mocked version of it like this:

    type MockDatabase struct {
        UsersStub func() ([]*User, error)
    }

    func (m MockDatabase) Users() ([]*User, error) {
        if m.UsersStub == nil {
            panic("MockDatabase.UsersStub is nil")
        }
        return (m.UsersStub)()
    }

Then you can create the resources you need, and define how they work, at the top of your test:

    func TestSomething(t *testing.T) {
        db := MockDatabase{
            UsersStub: func() ([]*User, error) {
                ...
            }
        }

        // use db here
    }

This works well as long as the things you're testing take all the resources they need as parameters.