PhineasRex

This explains a lot of why he's so threatened by this random POC. He's projecting onto the author the exact thing that he did.

I don't know why you're being downvoted. Decentralization is effective at limiting the effectiveness of misinformation. It's more difficult to impersonate a legitimate user in a smaller community.

This is complete pseudoscience. The Sawbones podcast has a good overview of this idea: https://maximumfun.org/episodes/sawbones/mewing/

Being constipated for 5 days is not particularly unusual, especially for people who've just undergone a major surgery

Mostly propaganda; there's been a lot of scaremongering about long waitlists and "death panels" in countries with universal healthcare.

And then on the political side it's just straight up corruption

You can do pseudo inline styles by just putting a <style> tag after the element which will let you use those. I think the argument is that tailwind isn't _conceptually_ different than inline styles even if there are a few minor technical differences.

The only really shocking part of this is that Artifactory is vulnerable to this. I expect developers to be lazy about build security because I've seen it over and over again at multiple companies, but Artifactory's whole purpose is to provide secure build dependency management.

I'll be rethinking using Artifactory in my infrastructure.

Making Haskell strict-by-default would also break the rewrite engine which is the core of Haskell's high performance with functional combinators.

The whole haskell project is about allowing programmers to write code that is declarative without making concessions for performance. Laziness makes this possible because it abstracts out evaluation order and thus allows extreme optimization by the compiler

Or that business with a million employees could just return a greater share of the wealth to the employees instead of the owners, thereby avoiding triggering the marginal tax

Email fills a different niche than secure messaging protocols though. Email has come to be used much like mail, including for legal purposes. Non-repudiation is actually a useful feature for a lot of those use-cases.

Obviously the conflation of a bunch of different use-cases into this one protocol is a problem, but I don't know that just making email more secure is a solution.

So in the example where you're constructing HTML, you would never use strings to represent your HTML. So your template might look something like ``` P(Text(someUserText), I(someItalicized)) ```

This is essentially how React.js works; you don't need to tag strings as safe or unsafe because strings are never treated as HTML, only constructed HTML values (via JSX) are treated as HTML.

I used @dataclass in almost every python project I work on. It's one of the most valuable additions to the language I can think of.

The update syntax is actually more of a `.copy` method, than a property update since it returns a new object. It's actually quite nice in that respect since it's easy to update multiple fields:

    e{lbl = val, lbl2 = val2}

There's no real reason you can't have sum types in a relational database, this just goes back to our current crop of RDBMSs being quite old and predating the current emphasis on strong typing. I suspect a modern relational database with an easier way define complex types (not writing a plugin) would be very popular, but the amount of work required to make something like that is immense

This is just a difference between named and anonymous types, really. This is very similar to named functions vs lambda functions, both provide the same exact functionality but avoiding superfluous identifiers makes programming more ergonomic.

More specifically sum types in Rust must also be tagged, meaning you need to explicitly construct and deconstruct them. This aspect is along the type-alias vs newtype axis which gets into structural vs nominative typing and the trade-offs therein.

So yes, Rust enums and Typescript union types are both exactly sum-types and the differences are due to the surrounding decisions made about the languages. Rust's sum types are named and tagged, Typescript's are anonymous and untagged, but they're both sum types.

This is just complaining about naming at this point. An "extension" must necessarily be extending the language with something. That something is a feature. When the GHC devs add a new feature to the language, they put it behind a flag and call it an extension. This is the only way features are added to GHC Haskell.

While it looks weird written down, "winningest" feels lovely in the mouth

Haskell doesn't have any more language extensions than other languages of its age, the only difference is that they're explicitly called out.

When Python adds new string formatters or generators or async, they're just in the language. When Haskell does that they require you to explicitly turn the new feature on. It's just a different strategy of managing language change. Versus the classical approach you get a lot more eyes on your language additions and have a nice "beta" period where you can make improvements before there is wide adoption.

This is basically the same approach that Rust is taking but they've been better about removing the feature flag when the feature is stabilized.

Projects of similar size in JS have hundreds of dependencies, so 52 really isn't a lot

This is more like a landlord evicting a restaurant and then opening a copy of that restaurant in the same location

Also worth noting that Bennett actually reached out to Cotton to write the piece

Several NYT employees have come out with stories of Bari trying to get them fired for disagreeing with her and she has publicly joined or led campaigns to get people fired from other organizations. Here's a good overview of her involvement in censorship campaigns: https://theintercept.com/2018/03/08/the-nyts-bari-weiss-fals...

Ah yes, the old "poor people just aren't as smart" myth. It's definitely their fault for not investing smartly and not the fact that they live paycheck to paycheck. Increasing inequality has nothing to do with the fact that wealth compounds on itself, it's just a coincidence.

The reality that you and other "bootstraps" people ignore is that there is a basic cost-of-living. People need to make rent, they need to pay medical expenses, etc. If your income doesn't rise above this cost-of-living (which is true for literally half of the US population) you don't have any small amounts of money to invest. A lot of long-term investment vehicles have costs for taking out money early, which is a significant risk if you might need that money for an emergency.

The wealthier you are, the more ways there are to increase your wealth and there is absolutely a floor under which you have no opportunities besides luck

What's interesting is that GHC absolutely supports this already. If you manually link your projects you can use multiple versions of the same library in your project. Cabal doesn't support multiple versions of the same library.

The complaint about records is interesting because there aren't that many major languages that actually do records well. For a language of its age, it actually does records rather well. People sometimes forget that Haskell is older than Java and like Java it has a ton of baggage from its early days.

The tooling is definitely an issue for bringing in beginners, but as far as the build process goes if you're using docker and hosting your own package mirror (as you should be for a professional deployment) it's perfectly serviceable.

In my personal experience there's a huge problem with counterfeit beauty products on Amazon.

Even when it's not counterfeit a lot of brands sell a cheaper version on Amazon than they do through other retailers.

If you're talking about the fact that you have to unbox the Maybe, that's not really related to type inference or static types but how "null" values are represented in the language.

If you're talking about exhaustiveness checks, you can disable those and use `-fdefer-type-errors` to compile programs which don't type-check.

Although I will say that most of the time when you have a Maybe instance that you know is Just, it means you're branching in the wrong part of your program.

> It's a common social technique among adults with authority to frame requests as a question-- "Could you please....?" or "Would you like to....?". This is gentler and shows a degree of deference and courtesy from the person with authority to the other person.

If the only answer to the question is agreement then the deference is false. Phrasing orders as questions really only makes authoritarian managers feel better about themselves; nobody under 40 thinks this is an actual question.

You're absolutely correct however Haskell has a couple of function that let you circumvent it's normal evaluation rules which you can see in https://hackage.haskell.org/package/base-4.12.0.0/docs/Syste....

These are sometimes useful for optimization but in an unfortunate bit of history, some developers decided to use these to "simulate" Haskell's lazy semantics for side-effecting I/O operations, the so-called "lazy I/O".

Fortunately this is just a few functions in the standard library which you can simply avoid and serious Haskell codebases should use a linter to prevent people from calling them.

I've deployed flow extensively and the biggest difference is that flow is horribly buggy (lots of false negatives) while typescript is mature. In theory flow's type system is stronger but it's so unreliable that 99% of the time I'd rather use typescript.