So it turns out that the way ChatGPT plugins operate, any user can use unverified plugins from arbitrary urls, just by pasting in a URL: https://platform.openai.com/docs/plugins/introduction/plugin...

With this in mind, how concerned should we really be about a pre-registered list of unverified plugins? The only new information exposed is the URLs of these various plugins, is this information so private if it was already registered in their list to begin with?

Copilot user here.

Copilot (the existing gpt-3 one) definitely helps at writing unit tests. Yeah, sometimes it doesn't nail it, but one thing it can do reliably is to repeat a pattern, and I don't know about you, but my unit tests tend to repeat the same pattern (with some tweaks to test this-or-that-case). Quite often it infers the correct change from the name I gave the test method, but even if it doesn't it'll write a 90% correct case for me. I imagine the GPT-4 version will do more of the same with better results.

It cannot replace reasoning, but it can augment it (by suggesting patterns and implementations from its latent space that I hadn't thought of), and worst case it can replace quite a bit of typing.

Long-term, it remains to be seen how far bigger/better/stronger LLMs can push the illusion of rationality. In many fields, they may be able to simply build their ability to pattern-match to beyond some threshold of usefulness. Perhaps (some subset of) programming will be one of them.

> one thing it can do reliably is repeat a pattern

Isn't this something we've built into every modern language(and arguably the entire point of languages)? If you have multiple pieces of code that share code with tweaks(to test this or that case for example), shouldn't you parameterize the bulk of the code instead of getting autocomplete to parameterize it for you and dump it into your source file multiple times?

Testing best practices have the opposite philosophy for the most part. Avoid abstraction as much as possible. Do repeat yourself. Because a bug in tests is insidious, so you want to minimize that. One of the best ways to minimize bugs is to explicitly avoid abstraction.

Copilot helps me write parametrized unit tests. You might find this example useful: https://til.simonwillison.net/gpt3/writing-test-with-copilot

Oh shit, you're right, I forgot about loops. Guess I'll go uninstall copilot now.

I have a "Generate... -> Test for function" in my JetBrais IDE out of the box for several years, and it takes care of boilerplate pretty well.

That just generated an empty test function in a convenient place for me. I'm not just talking about boilerplate, it's definitely a more... organic-feeling sort of pattern matching. In fact, one of the things I find most interesting about it is the sort of mistakes it makes, like generating wrong field names (as if it simply took a guess). This is the sort of thing that I've grown to expect the deterministic tooling of IDEs to get right, so it always surprises me a bit.

By the same token, often it takes a stab at generating code based on something's name (plus whatever context it's looking at) and does a better job than the IDE could, because the IDE just sees datatypes and code structure. It really does feel like a complementary tool.

You haven't tested how powerful copilot is, have you?

> So many people don't seem to realize that without suburbs you don't have farms.

This strikes me as a bizarre take. What do you consider a "suburb"?

A place outside dense cities, somewhere not too far from farms. A place where a farmer can go for services without having to travel far.

You're describing "rural" living. Suburbs entail something else.

Sure, it's the influencers pumping the oil, but it's social media networks running the pipelines, and they're splitting the profits.

Unfortunately, toxic content is a lot harder to regulate than toxic chemicals, when one man's truth is another man's fake news.

There's an intuitive model that makes some sense of this finding: Masks, air filters, and distancing are effective at preventing transmission by reducing -- not eliminating -- viral load. What suffices to prevent infection from a 15-second encounter with a stranger in line at the supermarket, may not be enough when kids are in the same room breathing the same air 6 hours of every day.

We now know what it takes to protect a person from COVID in an environment where they are likely to be exposed to significant virus concentrations; unfortunately, getting kids to scrub up like COVID ward nurses is probably not realistic.

The essay [1] from which the hairdryer anecdote is quoted has the thesis that categories (in general) are instrumental, and don't have much value separated from their context.

ADHD is a category of psychiatric diagnosis; psychiatric diagnoses exist to address deficiencies in function. Separating the one from the other, as you perceive, renders it meaningless -- or perhaps, useless. If one happens to have some of the traits of ADHD but it doesn't affect their life negatively, so what?

[1] https://slatestarcodex.com/2014/11/21/the-categories-were-ma...

I had the same experience cancelling my subscription. I was able to avoid the sales pitch the author received (I guess I was a little firmer), but I doubt I'll be subscribing again after I realized there was no unsubscribe button.

The gameplay experience is extremely impressive. I expected input lag and streaming quality to be problematic, but I've been a frequent stadia player ever since my (free) premium bundle arrived around Christmas and issues have been rare.

The only thing stopping me from spending more money on games is the fact that I expect it to just evaporate one day and take the games I "bought" with it. Moving to a licensing arrangement to let me play the games I already own/could retain even if Stadia goes away, would help a lot in this regard.

The "object" syntax reminds me a lot of Clojure/script's Hiccup (https://github.com/weavejester/hiccup) style, which has become a de-facto standard across many popular libraries. In hiccup, this example:

    {
        tag: "button",
        attributes: {
            "id": "baz",
            "class": "foo bar",
            "data": "1",
            "onclick": f,
        },
        children: [
            "Hello",
            {
                tag: "em",
                attributes: {},
                children: ["there"],
            }
        ]
    }

Would be represented as:

    [:button#baz.foo.bar {:data 1 :on-click f} "Hello" [:em "there"]]

Thanks for mentioning this. I was about to say that those of us who write ClojureScript do not have the original problem: my functions return vectors with data, which then get turned into HTML, DOM objects, or React classes, depending on the specific use case.

In other words, there is only one language and one syntax to deal with.

That looks identical to WC3 XML Schema language using JSON syntax instead of XML syntax.

I think you've missed that the hiccup example is the code on the final line.

On July 11, 7-11 offers a free slurpee to all customers. The free slurpee cup is a fraction of the size of any of the already-very-cheap options available for sale.

I have seen lineups out the door and around the block on this occasion. I think this illustrates very well people's well-known tendency to irrationally value free stuff.