adambard

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?

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.

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

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.

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"?

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"],
            }
        ]
    }

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

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.

Why do people make mistakes at all? Everything would be much easier if people would just be less fallable.

The incinerators used in this case (claim to) recapture the emissions from the incineration. However, they do leave some amount of toxic ash, which requires special disposal.

"Better, for people!"

The drive across India took place in a non-electric Kwid.

For more details on Japanese zoning law, see https://urbankchoze.blogspot.com/2014/04/japanese-zoning.htm...

I think it has less to do with the languages themselves, and more to do with the frameworks available, and the metaprogram-y things those frameworks are free to do without a type system stopping them.

I've yet to see the equivalent of Django or Rails when it comes to rapidly assembling a database-backed CRUD app in a statically typed language.

.NET-the-technology is pretty good, but for many developers, .NET is synonymous with expensive licensing and tooling (and you pretty much have to use Windows, ick).

The JVM and .NET are presently about the same capability-wise, but Java is (or at least, is perceived as) much easier and cheaper to freely experiment with. Unless you need to use C# for some deep Windows integration, this makes Java the obvious choice for anyone without sunk costs in the .NET ecosystem.

A few notes on why this is so:

- Keywords (i.e. `:vehicles`) can be used as getter functions, as covered in the OP.

- mapcat (like most collection functions in clojure) treats `nil` as an empty sequence

Unless OP means to imply that people can't mentally separate the machinations of the state from the rules of a game

I think this is pretty much it. Behavior is learned. The participants were playing the game in a way that was irrational when viewed in isolation, but natural in the context of their lives.

If the commons takes more than it gives, it becomes irrational to participate. This tendency persists and spreads over time and people and eventually crystallizes into an aspect of morality, where collaborating with the (exploitative or oppressive) commons is viewed with suspicion and distrust (think "Party Officials"). Eventually this habit becomes so ingrained that it emerges even during simple games.

I believe you can and have always been able to insert the bang anywhere in the query, as long as it has spaces between it and any words.

Compared to popular open-source options like Python, Javascript, and Java:

- Linq is great but less unique than it once was, and almost everyone has async and await (or some equivalent) now -- javascript & friends and python almost exactly, and Java has a wealth of options in this arena.

- .NET is "multiplatform", but clearly second-class in terms of tooling and perf on non-windows platforms.

- Congratulations on the open-source licence?

- This one is legit, but other languages do some pretty interesting stuff too

- VS might be ahead in this regard, but Java IDE's aren't far behind, and even the dynamic languages are starting to get really impressive tooling.

I have used and liked .NET, but I have no need to pay the premium it imposes. .NET is just another very capable platform among very capable platforms -- and then throw in the single-ecosystem thing.

I'd love to see some docs/examples around supporting pluggable brokers; Faust looks like exactly what I want from a python stream processor, but for various technical and operational reasons it would be nice to be able to provide a RabbitMQ/AMQP broker.

To be fair, the US isn't noted for being especially good at bicycle safety either.

I think her pieces are informed by the essential character of the medium, no different than if she had used watercolors instead of oils.

I run a Reddit post scheduler (https://laterforreddit.com/), and I have noticed a substantial bias towards posting in various adult subreddits.

I suspect in my case that this has a lot to do with how people who are browsing porn use Reddit, versus how people use the rest of the site at large. Most subs moderate posts and discussion actively and have norms (and moderators) that act against posting frequently, cross-posting and self-promotion. On the other hand, most porn subreddits are quite happy to accept x-posts, self promotion, etc, because their goal/approach is to provide more porn faster.

This seems to be an emergent property of Reddit rather than a deliberate strategy, but they seem happy enough to keep the revenue coming (as am I).

This is absolutely correct, and considerate Lisp writers make a point of using macros only when necessary for exactly this reason.

That said, Lisp writers also use macros every day -- for example, in Clojure, only `if` is defined as a special form, and other conditional operators (`when`, `cond`, `case`, `condp`, `if-not`, etc.) are implemented as macros that use `if` under the hood. Good macros are almost necessarily difficult to implement, because they're deployed to solve problems that functions can't, but if done well they can be easy to read and use.

To this Canadian as well!

In Scala, you can use `for`, although I think your point remains valid for languages without any sort of monad support:

    def func1(q: Option[Int], z: Option[Int]): Int = {
        (for {
            qval <- q
            zval <- z
        } yield q + z).getOrElse(0)
    }